diff --git a/.env.example b/.env.example
index 69b1b9cde..c9f3c855c 100644
--- a/.env.example
+++ b/.env.example
@@ -272,9 +272,9 @@ AZURE_APP_SECRET=
 # ENABLE_SIDEKIQ_DEQUEUE_LOGGER=false
 
 
-# AI powered features
-## OpenAI key
-# OPENAI_API_KEY=
+# AI powered features (Captain)
+# The OpenAI API key and endpoint for Captain are not configured via .env.
+# Set them at Super Admin > App Configs > Captain (CAPTAIN_OPEN_AI_API_KEY, CAPTAIN_OPEN_AI_ENDPOINT).
 
 # Housekeeping/Performance related configurations
 # Set to true if you want to remove stale contact inboxes
diff --git a/app/builders/v2/reports/drilldown_builder.rb b/app/builders/v2/reports/drilldown_builder.rb
new file mode 100644
index 000000000..a3d2c073d
--- /dev/null
+++ b/app/builders/v2/reports/drilldown_builder.rb
@@ -0,0 +1,213 @@
+class V2::Reports::DrilldownBuilder
+  include DateRangeHelper
+  include TimezoneHelper
+
+  DEFAULT_GROUP_BY = 'day'.freeze
+  DEFAULT_PAGE = 1
+  DEFAULT_PER_PAGE = 25
+  MAX_PER_PAGE = 100
+  SUPPORTED_GROUP_BY = %w[hour day week month year].freeze
+  SUPPORTED_DIMENSION_TYPES = %w[account inbox agent label team].freeze
+  MESSAGE_METRICS = {
+    'incoming_messages_count' => :incoming,
+    'outgoing_messages_count' => :outgoing
+  }.freeze
+  MESSAGE_EVENT_METRICS = %w[avg_first_response_time reply_time].freeze
+
+  pattr_initialize :account, :params
+
+  def self.supported_dimension_type?(type) = SUPPORTED_DIMENSION_TYPES.include?((type.presence || 'account').to_s)
+
+  def build
+    records = paginated_records.to_a
+    { meta: meta, payload: records.map { |record| record_serializer(records).serialize(record) } }
+  end
+
+  private
+
+  def meta
+    {
+      metric: metric,
+      record_type: record_type,
+      bucket: {
+        since: bucket_range.begin.to_i,
+        until: bucket_range.end.to_i
+      },
+      current_page: current_page,
+      per_page: per_page,
+      total_count: paginated_records.total_count,
+      conversation_count: conversation_count
+    }
+  end
+
+  def conversation_count
+    return paginated_records.total_count if conversation_metric?
+
+    drilldown_scope.except(:includes).reorder(nil).distinct.count(:conversation_id)
+  end
+
+  def paginated_records
+    @paginated_records ||= drilldown_scope.page(current_page).per(per_page)
+  end
+
+  def drilldown_scope
+    if message_metric?
+      message_scope
+    elsif conversation_metric?
+      conversation_scope
+    else
+      reporting_event_scope
+    end
+  end
+
+  def message_scope
+    scope.messages
+         .where(account_id: account.id, created_at: bucket_range)
+         .public_send(MESSAGE_METRICS.fetch(metric))
+         .includes(:sender, conversation: [:assignee, :contact, :inbox])
+         .reorder(created_at: :desc)
+  end
+
+  def conversation_scope
+    scope.conversations
+         .where(account_id: account.id, created_at: bucket_range)
+         .includes(:assignee, :contact, :inbox)
+         .order(created_at: :desc)
+  end
+
+  def reporting_event_scope
+    events = scope.reporting_events
+                  .where(account_id: account.id, name: raw_event_name, created_at: bucket_range)
+                  .includes(:user, :inbox, conversation: [:assignee, :contact, :inbox])
+                  .order(created_at: :desc)
+
+    if raw_count_strategy == :exclude_bot_handoffs
+      events = events.where.not(conversation_id: bot_handoff_conversation_ids_subquery)
+    elsif raw_count_strategy == :distinct_conversation
+      events = events.where(id: distinct_conversation_event_ids(events))
+    end
+
+    events
+  end
+
+  def bot_handoff_conversation_ids_subquery
+    scope.reporting_events
+         .where(account_id: account.id, name: :conversation_bot_handoff, created_at: range)
+         .where.not(conversation_id: nil)
+         .select(:conversation_id)
+  end
+
+  def distinct_conversation_event_ids(events)
+    events.reorder(nil)
+          .where.not(conversation_id: nil)
+          .select('MAX(reporting_events.id)')
+          .group(:conversation_id)
+  end
+
+  def record_serializer(records)
+    @record_serializer ||= V2::Reports::DrilldownRecordSerializer.new(
+      account,
+      metric,
+      use_business_hours?,
+      records
+    )
+  end
+
+  def bucket_range
+    @bucket_range ||= begin
+      bucket_start = Time.zone.at(params[:bucket_timestamp].to_i).in_time_zone(timezone)
+      bucket_end = bucket_end_for(bucket_start)
+      requested_start = Time.zone.at(params[:since].to_i)
+      requested_end = Time.zone.at(params[:until].to_i)
+
+      [bucket_start, requested_start].max...[bucket_end, requested_end].min
+    end
+  end
+
+  def bucket_end_for(bucket_start)
+    {
+      'hour' => bucket_start + 1.hour,
+      'day' => bucket_start + 1.day,
+      'week' => bucket_start + 1.week,
+      'month' => bucket_start + 1.month,
+      'year' => bucket_start + 1.year
+    }.fetch(group_by)
+  end
+
+  def scope
+    case dimension_type
+    when 'account' then account
+    when 'inbox' then inbox
+    when 'agent' then user
+    when 'label' then label
+    when 'team' then team
+    else
+      raise ArgumentError, "Unsupported drilldown dimension type: #{dimension_type}"
+    end
+  end
+
+  def inbox = @inbox ||= account.inboxes.find(params[:id])
+
+  def user = @user ||= account.users.find(params[:id])
+
+  def label = @label ||= account.labels.find(params[:id])
+
+  def team = @team ||= account.teams.find(params[:id])
+
+  def metric
+    params[:metric].to_s
+  end
+
+  def report_metric
+    @report_metric ||= Reports::ReportMetricRegistry.fetch(metric)
+  end
+
+  def raw_event_name
+    report_metric&.raw_event_name
+  end
+
+  def raw_count_strategy
+    report_metric&.raw_count_strategy
+  end
+
+  def record_type
+    return 'message' if message_metric? || MESSAGE_EVENT_METRICS.include?(metric)
+
+    'conversation'
+  end
+
+  def message_metric?
+    MESSAGE_METRICS.key?(metric)
+  end
+
+  def conversation_metric?
+    metric == 'conversations_count'
+  end
+
+  def dimension_type
+    (params[:type].presence || 'account').to_s
+  end
+
+  def group_by
+    @group_by ||= SUPPORTED_GROUP_BY.include?(params[:group_by].to_s) ? params[:group_by].to_s : DEFAULT_GROUP_BY
+  end
+
+  def timezone
+    @timezone ||= timezone_name_from_offset(params[:timezone_offset])
+  end
+
+  def current_page
+    [params[:page].to_i, DEFAULT_PAGE].max
+  end
+
+  def per_page
+    requested_per_page = params[:per_page].to_i
+    requested_per_page = DEFAULT_PER_PAGE if requested_per_page <= 0
+
+    [requested_per_page, MAX_PER_PAGE].min
+  end
+
+  def use_business_hours?
+    ActiveModel::Type::Boolean.new.cast(params[:business_hours])
+  end
+end
diff --git a/app/builders/v2/reports/drilldown_record_serializer.rb b/app/builders/v2/reports/drilldown_record_serializer.rb
new file mode 100644
index 000000000..04edf65b4
--- /dev/null
+++ b/app/builders/v2/reports/drilldown_record_serializer.rb
@@ -0,0 +1,199 @@
+class V2::Reports::DrilldownRecordSerializer
+  MESSAGE_EVENT_METRICS = %w[avg_first_response_time reply_time].freeze
+
+  attr_reader :account, :metric, :use_business_hours, :records
+
+  def initialize(account, metric, use_business_hours, records = [])
+    @account = account
+    @metric = metric
+    @use_business_hours = use_business_hours
+    @records = records
+  end
+
+  def serialize(record)
+    return serialize_message(record) if record.is_a?(Message)
+    return serialize_conversation_event(record) if record.is_a?(ReportingEvent)
+
+    serialize_conversation(record)
+  end
+
+  private
+
+  def serialize_message(message, metric_value: nil, occurred_at: nil)
+    {
+      record_type: 'message',
+      conversation: conversation_attributes(message.conversation),
+      message: message_attributes(message),
+      metric_value: metric_value,
+      occurred_at: (occurred_at || message.created_at).to_i
+    }
+  end
+
+  def serialize_conversation_event(event)
+    inferred_message = inferred_message_for(event)
+    if inferred_message.present?
+      return serialize_message(
+        inferred_message,
+        metric_value: event_metric_value(event),
+        occurred_at: event_timestamp(event)
+      )
+    end
+
+    serialize_conversation(
+      event.conversation,
+      metric_value: event_metric_value(event),
+      occurred_at: event_timestamp(event),
+      event_name: event.name
+    )
+  end
+
+  def serialize_conversation(conversation, metric_value: nil, occurred_at: nil, event_name: nil)
+    serialized_record = {
+      record_type: 'conversation',
+      conversation: conversation_attributes(conversation),
+      message: nil,
+      metric_value: metric_value,
+      occurred_at: (occurred_at || conversation&.created_at)&.to_i
+    }
+    serialized_record[:event_name] = event_name if event_name.present?
+    serialized_record
+  end
+
+  def conversation_attributes(conversation)
+    return {} if conversation.blank?
+
+    {
+      id: conversation.id,
+      display_id: conversation.display_id,
+      contact_id: conversation.contact_id,
+      contact_name: conversation.contact&.name,
+      inbox_id: conversation.inbox_id,
+      inbox_name: conversation.inbox&.name,
+      assignee_id: conversation.assignee_id,
+      assignee_name: conversation.assignee&.name,
+      status: conversation.status,
+      created_at: conversation.created_at.to_i,
+      last_activity_at: conversation.last_activity_at.to_i,
+      last_message: last_message_attributes(conversation)
+    }
+  end
+
+  def message_attributes(message)
+    {
+      id: message.id,
+      content: message.content,
+      message_type: message.message_type,
+      sender_name: message.sender&.try(:name),
+      created_at: message.created_at.to_i
+    }
+  end
+
+  def last_message_attributes(conversation)
+    message = latest_messages_by_conversation_id[conversation.id]
+    return if message.blank?
+
+    message_attributes(message)
+  end
+
+  def inferred_message_for(event)
+    return unless MESSAGE_EVENT_METRICS.include?(metric)
+    return if event.conversation.blank? || event.event_end_time.blank?
+
+    inferred_messages_by_event_id[event.id]
+  end
+
+  def first_response_event_with_user?(event)
+    metric == 'avg_first_response_time' && event.user_id.present?
+  end
+
+  def message_inference_range(event)
+    (event.event_end_time - 1.second)..(event.event_end_time + 1.second)
+  end
+
+  def event_metric_value(event)
+    use_business_hours ? event.value_in_business_hours : event.value
+  end
+
+  def event_timestamp(event)
+    event.event_end_time || event.created_at
+  end
+
+  def latest_messages_by_conversation_id
+    @latest_messages_by_conversation_id ||= if conversation_ids.blank?
+                                              {}
+                                            else
+                                              latest_messages.index_by(&:conversation_id)
+                                            end
+  end
+
+  def latest_messages
+    Message
+      .where(account_id: account.id, conversation_id: conversation_ids)
+      .where.not(message_type: :activity)
+      .select('DISTINCT ON (messages.conversation_id) messages.*')
+      .reorder(Arel.sql('messages.conversation_id, messages.created_at DESC, messages.id DESC'))
+      .includes(:sender)
+  end
+
+  def inferred_messages_by_event_id
+    @inferred_messages_by_event_id ||= inference_events.each_with_object({}) do |event, messages_by_event_id|
+      messages_by_event_id[event.id] = inferred_message_candidates.find do |message|
+        message_matches_event?(message, event)
+      end
+    end
+  end
+
+  def inferred_message_candidates
+    @inferred_message_candidates ||= if inference_events.blank?
+                                       []
+                                     else
+                                       inferred_messages.to_a
+                                     end
+  end
+
+  def inferred_messages
+    Message
+      .where(account_id: account.id, conversation_id: inference_events.map(&:conversation_id).uniq)
+      .where(created_at: inference_time_range)
+      .where(message_type: %i[outgoing template])
+      .includes(:sender)
+      .reorder(created_at: :desc, id: :desc)
+  end
+
+  def message_matches_event?(message, event)
+    message.conversation_id == event.conversation_id &&
+      message.created_at.between?(
+        message_inference_range(event).begin,
+        message_inference_range(event).end
+      ) &&
+      message_sender_matches_event?(message, event)
+  end
+
+  def message_sender_matches_event?(message, event)
+    return true unless first_response_event_with_user?(event)
+
+    message.sender_id == event.user_id && message.sender_type == 'User'
+  end
+
+  def inference_time_range
+    event_end_times = inference_events.map(&:event_end_time)
+
+    (event_end_times.min - 1.second)..(event_end_times.max + 1.second)
+  end
+
+  def inference_events
+    @inference_events ||= records.select do |record|
+      record.is_a?(ReportingEvent) && record.conversation_id.present? && record.event_end_time.present?
+    end
+  end
+
+  def conversation_ids
+    @conversation_ids ||= records.filter_map { |record| conversation_id_for(record) }.uniq
+  end
+
+  def conversation_id_for(record)
+    return record.conversation_id if record.is_a?(Message) || record.is_a?(ReportingEvent)
+
+    record.id
+  end
+end
diff --git a/app/controllers/api/v1/accounts/articles_controller.rb b/app/controllers/api/v1/accounts/articles_controller.rb
index 5e1609b64..4a8363fdd 100644
--- a/app/controllers/api/v1/accounts/articles_controller.rb
+++ b/app/controllers/api/v1/accounts/articles_controller.rb
@@ -40,8 +40,8 @@ class Api::V1::Accounts::ArticlesController < Api::V1::Accounts::BaseController
   end
 
   def reorder
-    Article.update_positions(portal: @portal, positions_hash: params[:positions_hash])
-    head :ok
+    positions = Article.update_positions(portal: @portal, positions_hash: params[:positions_hash])
+    render json: { positions: positions }
   end
 
   private
diff --git a/app/controllers/api/v2/accounts/reports_controller.rb b/app/controllers/api/v2/accounts/reports_controller.rb
index 192b3619c..93be19eb9 100644
--- a/app/controllers/api/v2/accounts/reports_controller.rb
+++ b/app/controllers/api/v2/accounts/reports_controller.rb
@@ -51,6 +51,13 @@ class Api::V2::Accounts::ReportsController < Api::V1::Accounts::BaseController
     generate_csv('conversation_traffic_reports', 'api/v2/accounts/reports/conversation_traffic')
   end
 
+  def drilldown
+    return head :unauthorized unless Current.account_user.administrator?
+    return head :unprocessable_entity unless valid_drilldown_params?
+
+    render json: V2::Reports::DrilldownBuilder.new(Current.account, drilldown_params).build
+  end
+
   def conversations
     return head :unprocessable_entity if params[:type].blank?
 
@@ -133,6 +140,22 @@ class Api::V2::Accounts::ReportsController < Api::V1::Accounts::BaseController
                         })
   end
 
+  def drilldown_params
+    permitted_params = params.permit(
+      :metric, :id, :since, :until, :group_by, :timezone_offset, :bucket_timestamp, :page, :per_page
+    ).to_h.symbolize_keys
+    permitted_params.merge(
+      type: (params[:type].presence || 'account').to_sym,
+      business_hours: ActiveModel::Type::Boolean.new.cast(params[:business_hours])
+    )
+  end
+
+  def valid_drilldown_params?
+    %i[metric bucket_timestamp since until].all? { |param| params[param].present? } &&
+      Reports::ReportMetricRegistry.supported?(params[:metric]) &&
+      V2::Reports::DrilldownBuilder.supported_dimension_type?(params[:type]) && Reports::DrilldownTimestampValidator.valid?(params)
+  end
+
   def conversation_params
     {
       type: params[:type].to_sym,
diff --git a/app/helpers/billing_helper.rb b/app/helpers/billing_helper.rb
index e2ada7e86..7545b6d8f 100644
--- a/app/helpers/billing_helper.rb
+++ b/app/helpers/billing_helper.rb
@@ -22,4 +22,16 @@ module BillingHelper
   def agents(account)
     account.users.count
   end
+
+  # current_period_end moved to the subscription item in newer Stripe API versions; read both.
+  def subscription_period_end(subscription)
+    subscription['current_period_end'] || subscription['items']['data'].first&.[]('current_period_end')
+  end
+
+  def subscription_ends_on(subscription)
+    period_end = subscription_period_end(subscription)
+    return if period_end.blank?
+
+    Time.zone.at(period_end)
+  end
 end
diff --git a/app/javascript/dashboard/api/enterprise/account.js b/app/javascript/dashboard/api/enterprise/account.js
index 9e6d40a62..03456a288 100644
--- a/app/javascript/dashboard/api/enterprise/account.js
+++ b/app/javascript/dashboard/api/enterprise/account.js
@@ -14,6 +14,10 @@ class EnterpriseAccountAPI extends ApiClient {
     return axios.post(`${this.url}subscription`);
   }
 
+  selectBillingCurrency(currency) {
+    return axios.post(`${this.url}select_billing_currency`, { currency });
+  }
+
   getLimits() {
     return axios.get(`${this.url}limits`);
   }
@@ -27,6 +31,11 @@ class EnterpriseAccountAPI extends ApiClient {
   createTopupCheckout(credits) {
     return axios.post(`${this.url}topup_checkout`, { credits });
   }
+
+  // Topup packages for the account's billing currency.
+  getTopupOptions() {
+    return axios.get(`${this.url}topup_options`);
+  }
 }
 
 export default new EnterpriseAccountAPI();
diff --git a/app/javascript/dashboard/api/reports.js b/app/javascript/dashboard/api/reports.js
index 00f040f8e..daa0cb11d 100644
--- a/app/javascript/dashboard/api/reports.js
+++ b/app/javascript/dashboard/api/reports.js
@@ -31,6 +31,42 @@ class ReportsAPI extends ApiClient {
     });
   }
 
+  getDrilldown({
+    metric,
+    bucketTimestamp,
+    from,
+    to,
+    type = 'account',
+    id,
+    groupBy,
+    businessHours,
+    page,
+    perPage,
+    signal,
+  }) {
+    const requestConfig = {
+      params: {
+        metric,
+        bucket_timestamp: bucketTimestamp,
+        since: from,
+        until: to,
+        type,
+        id,
+        group_by: groupBy,
+        business_hours: businessHours,
+        timezone_offset: getTimeOffset(),
+        page,
+        per_page: perPage,
+      },
+    };
+
+    if (signal) {
+      requestConfig.signal = signal;
+    }
+
+    return axios.get(`${this.url}/drilldown`, requestConfig);
+  }
+
   // eslint-disable-next-line default-param-last
   getSummary(since, until, type = 'account', id, groupBy, businessHours) {
     return axios.get(`${this.url}/summary`, {
diff --git a/app/javascript/dashboard/api/specs/reports.spec.js b/app/javascript/dashboard/api/specs/reports.spec.js
index e458633d0..178c98a70 100644
--- a/app/javascript/dashboard/api/specs/reports.spec.js
+++ b/app/javascript/dashboard/api/specs/reports.spec.js
@@ -1,6 +1,8 @@
 import reportsAPI from '../reports';
 import ApiClient from '../ApiClient';
 
+const timezoneOffset = () => -new Date().getTimezoneOffset() / 60;
+
 describe('#Reports API', () => {
   it('creates correct instance', () => {
     expect(reportsAPI).toBeInstanceOf(ApiClient);
@@ -11,6 +13,7 @@ describe('#Reports API', () => {
     expect(reportsAPI).toHaveProperty('update');
     expect(reportsAPI).toHaveProperty('delete');
     expect(reportsAPI).toHaveProperty('getReports');
+    expect(reportsAPI).toHaveProperty('getDrilldown');
     expect(reportsAPI).toHaveProperty('getSummary');
     expect(reportsAPI).toHaveProperty('getAgentReports');
     expect(reportsAPI).toHaveProperty('getLabelReports');
@@ -42,11 +45,14 @@ describe('#Reports API', () => {
       });
       expect(axiosMock.get).toHaveBeenCalledWith('/api/v2/reports', {
         params: {
+          business_hours: undefined,
+          group_by: undefined,
+          id: undefined,
           metric: 'conversations_count',
           since: 1621103400,
           until: 1621621800,
           type: 'account',
-          timezone_offset: -0,
+          timezone_offset: timezoneOffset(),
         },
       });
     });
@@ -59,13 +65,70 @@ describe('#Reports API', () => {
           group_by: undefined,
           id: undefined,
           since: 1621103400,
-          timezone_offset: -0,
+          timezone_offset: timezoneOffset(),
           type: 'account',
           until: 1621621800,
         },
       });
     });
 
+    it('#getDrilldown', () => {
+      reportsAPI.getDrilldown({
+        metric: 'incoming_messages_count',
+        bucketTimestamp: 1621103400,
+        from: 1621103400,
+        to: 1621621800,
+        type: 'inbox',
+        id: 1,
+        groupBy: 'day',
+        businessHours: false,
+        page: 2,
+        perPage: 25,
+      });
+      expect(axiosMock.get).toHaveBeenCalledWith('/api/v2/reports/drilldown', {
+        params: {
+          metric: 'incoming_messages_count',
+          bucket_timestamp: 1621103400,
+          since: 1621103400,
+          until: 1621621800,
+          type: 'inbox',
+          id: 1,
+          group_by: 'day',
+          business_hours: false,
+          timezone_offset: timezoneOffset(),
+          page: 2,
+          per_page: 25,
+        },
+      });
+    });
+
+    it('#getDrilldown with abort signal', () => {
+      const controller = new AbortController();
+
+      reportsAPI.getDrilldown({
+        metric: 'incoming_messages_count',
+        bucketTimestamp: 1621103400,
+        signal: controller.signal,
+      });
+
+      expect(axiosMock.get).toHaveBeenCalledWith('/api/v2/reports/drilldown', {
+        params: {
+          metric: 'incoming_messages_count',
+          bucket_timestamp: 1621103400,
+          since: undefined,
+          until: undefined,
+          type: 'account',
+          id: undefined,
+          group_by: undefined,
+          business_hours: undefined,
+          timezone_offset: timezoneOffset(),
+          page: undefined,
+          per_page: undefined,
+        },
+        signal: controller.signal,
+      });
+    });
+
     it('#getAgentReports', () => {
       reportsAPI.getAgentReports({
         from: 1621103400,
diff --git a/app/javascript/dashboard/components-next/Conversation/ConversationCard/CardMessagePreviewWithMeta.vue b/app/javascript/dashboard/components-next/Conversation/ConversationCard/CardMessagePreviewWithMeta.vue
index df2b22b7e..3486816d5 100644
--- a/app/javascript/dashboard/components-next/Conversation/ConversationCard/CardMessagePreviewWithMeta.vue
+++ b/app/javascript/dashboard/components-next/Conversation/ConversationCard/CardMessagePreviewWithMeta.vue
@@ -16,6 +16,10 @@ const props = defineProps({
     type: Array,
     required: true,
   },
+  contact: {
+    type: Object,
+    required: true,
+  },
 });
 
 const { t } = useI18n();
@@ -49,7 +53,9 @@ const unreadMessagesCount = computed(() => {
 
 const hasSlaThreshold = computed(() => {
   return (
-    slaCardLabelRef.value?.hasSlaThreshold && props.conversation?.slaPolicyId
+    !props.contact?.blocked &&
+    slaCardLabelRef.value?.hasSlaThreshold &&
+    props.conversation?.appliedSla?.id
   );
 });
 
diff --git a/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCard.vue b/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCard.vue
index f9a2507a1..be3ddf280 100644
--- a/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCard.vue
+++ b/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCard.vue
@@ -126,6 +126,7 @@ const onCardClick = e => {
         v-show="!showMessagePreviewWithoutMeta"
         ref="cardMessagePreviewWithMetaRef"
         :conversation="conversation"
+        :contact="contact"
         :account-labels="accountLabels"
       />
     </div>
diff --git a/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCardExpanded.vue b/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCardExpanded.vue
index d0f8f0211..0119b7168 100644
--- a/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCardExpanded.vue
+++ b/app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCardExpanded.vue
@@ -51,7 +51,9 @@ const unreadCount = computed(() => props.chat.unread_count);
 const slaCardLabel = useTemplateRef('slaCardLabel');
 
 const hasSlaPolicyId = computed(
-  () => props.chat?.sla_policy_id || slaCardLabel.value?.hasSlaThreshold
+  () =>
+    !props.currentContact?.blocked &&
+    (props.chat?.applied_sla?.id || slaCardLabel.value?.hasSlaThreshold)
 );
 
 const selectedModel = computed({
diff --git a/app/javascript/dashboard/components-next/Conversation/ConversationCard/SLACardLabel.vue b/app/javascript/dashboard/components-next/Conversation/ConversationCard/SLACardLabel.vue
index ff57d6c93..608bd84bd 100644
--- a/app/javascript/dashboard/components-next/Conversation/ConversationCard/SLACardLabel.vue
+++ b/app/javascript/dashboard/components-next/Conversation/ConversationCard/SLACardLabel.vue
@@ -1,6 +1,6 @@
 <script setup>
 import { ref, computed, onMounted, onUnmounted, watch } from 'vue';
-import { evaluateSLAStatus } from '@chatwoot/utils';
+import { evaluateSLAStatus } from 'dashboard/helper/slaHelper';
 
 const props = defineProps({
   conversation: {
@@ -19,16 +19,8 @@ const slaStatus = ref({
   icon: null,
 });
 
-// TODO: Remove this once we update the helper from utils
-// https://github.com/chatwoot/utils/blob/main/src/sla.ts#L73
-const convertObjectCamelCaseToSnakeCase = object => {
-  return Object.keys(object).reduce((acc, key) => {
-    acc[key.replace(/([A-Z])/g, '_$1').toLowerCase()] = object[key];
-    return acc;
-  }, {});
-};
-
 const appliedSLA = computed(() => props.conversation?.appliedSla);
+const slaEvents = computed(() => props.conversation?.slaEvents);
 const isSlaMissed = computed(() => slaStatus.value?.isSlaMissed);
 
 const hasSlaThreshold = computed(() => {
@@ -41,8 +33,9 @@ const slaStatusText = computed(() => {
 
 const updateSlaStatus = () => {
   slaStatus.value = evaluateSLAStatus({
-    appliedSla: convertObjectCamelCaseToSnakeCase(appliedSLA.value || {}),
+    appliedSla: appliedSLA.value || {},
     chat: props.conversation,
+    slaEvents: slaEvents.value || [],
   });
 };
 
diff --git a/app/javascript/dashboard/components-next/Conversation/Sla/SLACardLabel.vue b/app/javascript/dashboard/components-next/Conversation/Sla/SLACardLabel.vue
index 98a79c921..359e237ec 100644
--- a/app/javascript/dashboard/components-next/Conversation/Sla/SLACardLabel.vue
+++ b/app/javascript/dashboard/components-next/Conversation/Sla/SLACardLabel.vue
@@ -1,6 +1,6 @@
 <script setup>
 import { ref, computed, onMounted, onUnmounted, watch } from 'vue';
-import { evaluateSLAStatus } from '@chatwoot/utils';
+import { evaluateSLAStatus } from 'dashboard/helper/slaHelper';
 
 import Icon from 'dashboard/components-next/icon/Icon.vue';
 import Label from 'dashboard/components-next/label/Label.vue';
@@ -27,6 +27,7 @@ defineOptions({
 });
 
 const appliedSLA = computed(() => props.chat?.applied_sla);
+const slaEvents = computed(() => props.chat?.sla_events);
 const hasSlaThreshold = computed(() => slaStatus.value?.threshold);
 const isSlaMissed = computed(() => slaStatus.value?.isSlaMissed);
 
@@ -34,6 +35,7 @@ const updateSlaStatus = () => {
   slaStatus.value = evaluateSLAStatus({
     appliedSla: appliedSLA.value || {},
     chat: props.chat,
+    slaEvents: slaEvents.value || [],
   });
 };
 
diff --git a/app/javascript/dashboard/components-next/DraggableReorderList/DraggableReorderList.vue b/app/javascript/dashboard/components-next/DraggableReorderList/DraggableReorderList.vue
new file mode 100644
index 000000000..95c05f6b6
--- /dev/null
+++ b/app/javascript/dashboard/components-next/DraggableReorderList/DraggableReorderList.vue
@@ -0,0 +1,378 @@
+<script setup>
+import { computed, ref, watch, nextTick, onBeforeUnmount } from 'vue';
+import { useEventListener, onKeyStroke, useRafFn } from '@vueuse/core';
+import Icon from 'dashboard/components-next/icon/Icon.vue';
+
+// Reorderable list with cross-page drag. It must stay mounted during a page
+// fetch — hide the list spinner while `dragging`, or the held item is lost.
+const props = defineProps({
+  items: { type: Array, required: true },
+  itemKey: { type: String, default: 'id' },
+  disabled: { type: Boolean, default: false },
+  currentPage: { type: Number, default: 1 },
+  totalPages: { type: Number, default: 1 },
+});
+const emit = defineEmits(['reorder', 'navigatePage', 'dragging']);
+
+const DRAG_THRESHOLD = 5;
+const EDGE_BAND = 72; // px from a side that arms a page turn
+const AUTO_PAGE_DELAY = 600; // ms hovering an edge before it flips
+const SCROLL_BAND = 60; // px from top/bottom that autoscrolls the list
+const SCROLL_STEP = 10; // px scrolled per frame while parked at an edge
+const PILL = 36; // px, the page-turn arrow button on each edge
+
+const root = ref(null);
+const isDragging = ref(false);
+const dragged = ref(null);
+const pointer = ref({ x: 0, y: 0 });
+const insertBefore = ref(null); // key the gap sits before, null = end of list
+const activeEdge = ref(null);
+const bounds = ref({ left: 0, right: 0, top: 0, bottom: 0 }); // visible list rect
+const grab = ref({ dx: 0, dy: 0 }); // cursor offset inside the grabbed card
+const dragHeight = ref(0);
+
+let press = null; // pending press, before it becomes a drag
+let dwell = null; // timer that flips the page after hovering an edge
+let paging = false; // waiting for a flipped page to load
+let scroller = null; // scrollable ancestor, found when a drag begins
+let scrollDir = 0; // -1 up, +1 down, 0 idle
+let sourcePage = 1; // page the drag started on, to resolve cross-page end-drops
+
+const keyOf = item => String(item?.[props.itemKey]);
+const others = item => props.items.filter(o => keyOf(o) !== keyOf(item));
+const isRTL = () =>
+  document.querySelector('#app[dir]')?.getAttribute('dir') === 'rtl';
+const canPage = dir =>
+  dir === 'next' ? props.currentPage < props.totalPages : props.currentPage > 1;
+
+// Key of the item after `key` in `list`, or null when it is the last one.
+const keyAfter = (list, key) => {
+  const next = list[list.findIndex(o => keyOf(o) === key) + 1];
+  return next ? keyOf(next) : null;
+};
+
+const edges = computed(() =>
+  ['prev', 'next'].filter(canPage).map(dir => {
+    const onLeft = isRTL() ? dir === 'next' : dir === 'prev';
+    return {
+      dir,
+      onLeft,
+      icon: onLeft ? 'i-lucide-chevrons-left' : 'i-lucide-chevrons-right',
+    };
+  })
+);
+
+// Cursor overlay: an edge glow band, a page-turn arrow per edge, and a ghost of
+// the dragged row that follows the cursor and shrinks when aimed at an edge.
+const EDGE_BAND_W = 80; // px width of the glow band on each pageable edge
+const bandStyle = onLeft => {
+  const x = onLeft ? bounds.value.left : bounds.value.right - EDGE_BAND_W;
+  return {
+    width: `${EDGE_BAND_W}px`,
+    height: `${bounds.value.bottom - bounds.value.top}px`,
+    transform: `translate(${x}px, ${bounds.value.top}px)`,
+  };
+};
+const pillStyle = onLeft => {
+  const x = onLeft ? bounds.value.left + 12 : bounds.value.right - PILL - 12;
+  return { transform: `translate(${x}px, ${pointer.value.y - PILL / 2}px)` };
+};
+const ghostStyle = computed(() => ({
+  width: `${bounds.value.right - bounds.value.left}px`,
+  transform: `translate(${pointer.value.x - grab.value.dx}px, ${pointer.value.y - grab.value.dy}px)`,
+}));
+const scaleStyle = computed(() => ({
+  transformOrigin: `${grab.value.dx}px ${grab.value.dy}px`,
+}));
+
+// The list as shown mid-drag: the dragged row slotted into the gap at `insertBefore`.
+const displayItems = computed(() => {
+  if (!isDragging.value || !dragged.value) return props.items;
+  const rest = others(dragged.value);
+  const at = rest.findIndex(o => keyOf(o) === insertBefore.value);
+  rest.splice(at === -1 ? rest.length : at, 0, dragged.value);
+  return rest;
+});
+
+// Move the gap when the cursor crosses the midpoint of the card it is over.
+const aim = () => {
+  const card = document
+    .elementFromPoint(pointer.value.x, pointer.value.y)
+    ?.closest('[data-drag-id]');
+  const key = card?.dataset.dragId;
+  if (!key || key === keyOf(dragged.value)) return;
+
+  const { top, height } = card.getBoundingClientRect();
+  const above = pointer.value.y < top + height / 2;
+  insertBefore.value = above ? key : keyAfter(others(dragged.value), key);
+};
+
+const flip = dir => {
+  if (paging || !isDragging.value) return;
+  paging = true;
+  emit('navigatePage', props.currentPage + (dir === 'next' ? 1 : -1));
+};
+
+const aimEdge = x => {
+  const rect = root.value?.getBoundingClientRect();
+  if (!rect) return;
+  // Clip the list rect to the scroll viewport so the glow band and its top/bottom
+  // fade always sit on the visible edges, not the far ends of the full content.
+  const view = scroller?.getBoundingClientRect();
+  const viewTop = Math.max(view?.top ?? 0, 0);
+  const viewBottom = Math.min(
+    view?.bottom ?? window.innerHeight,
+    window.innerHeight
+  );
+  bounds.value = {
+    left: rect.left,
+    right: rect.right,
+    top: Math.max(rect.top, viewTop),
+    bottom: Math.min(rect.bottom, viewBottom),
+  };
+
+  let dir = null;
+  if (x <= rect.left + EDGE_BAND) dir = isRTL() ? 'next' : 'prev';
+  else if (x >= rect.right - EDGE_BAND) dir = isRTL() ? 'prev' : 'next';
+  if (dir && !canPage(dir)) dir = null;
+  if (dir === activeEdge.value) return;
+
+  activeEdge.value = dir;
+  clearTimeout(dwell);
+  if (dir) dwell = setTimeout(() => flip(dir), AUTO_PAGE_DELAY);
+};
+
+// Nearest scrollable ancestor, so a drag can reach rows that are off-screen.
+const scrollParent = () => {
+  let el = root.value?.parentElement;
+  while (el) {
+    const { overflowY } = getComputedStyle(el);
+    if (overflowY === 'auto' || overflowY === 'scroll') return el;
+    el = el.parentElement;
+  }
+  return null;
+};
+
+// While parked at the top/bottom edge, keep scrolling and re-aim as rows slide by.
+const { pause: pauseScroll, resume: resumeScroll } = useRafFn(
+  () => {
+    if (!scroller || !scrollDir) return;
+    scroller.scrollTop += scrollDir * SCROLL_STEP;
+    aim();
+    aimEdge(pointer.value.x);
+  },
+  { immediate: false }
+);
+
+const updateAutoScroll = y => {
+  if (!scroller) return;
+  const rect = scroller.getBoundingClientRect();
+  const atTop = scroller.scrollTop <= 0;
+  const atBottom =
+    scroller.scrollTop >= scroller.scrollHeight - scroller.clientHeight;
+  if (y < rect.top + SCROLL_BAND && !atTop) scrollDir = -1;
+  else if (y > rect.bottom - SCROLL_BAND && !atBottom) scrollDir = 1;
+  else scrollDir = 0;
+  if (scrollDir) resumeScroll();
+  else pauseScroll();
+};
+
+const reset = () => {
+  isDragging.value = false;
+  dragged.value = null;
+  insertBefore.value = null;
+  activeEdge.value = null;
+  clearTimeout(dwell);
+  paging = false;
+  scrollDir = 0;
+  scroller = null;
+  pauseScroll();
+  document.body.classList.remove('select-none');
+  emit('dragging', false);
+};
+
+// Positions sit on a gap-of-10 grid; a midpoint (±5 at the ends) slots between two rows.
+// Cross-page end-drops are the tricky case: moving an item off its source page pulls the
+// target page's boundary row into the vacated slot. So at the leading edge after moving
+// DOWN (or the trailing edge after moving UP) we land between the two boundary rows, or
+// the item sorts onto the adjacent page and vanishes from view.
+const drop = (item, rawBefore) => {
+  const pos = o => o?.position || 0;
+  const mid = (a, b) => Math.floor((pos(a) + pos(b)) / 2);
+  const rest = others(item);
+  // No other rows to position against — e.g. the lone article on a page dropped
+  // without crossing to another page. Leave the order untouched.
+  if (!rest.length) return;
+  // A page flip can leave the aimed key pointing at a row that is no longer on
+  // this page. Like displayItems, resolve an unknown key to null (end of list),
+  // so what the user sees and what we save agree.
+  const before = rest.some(o => keyOf(o) === rawBefore) ? rawBefore : null;
+  const movedDown = props.currentPage > sourcePage;
+  const movedUp = props.currentPage < sourcePage;
+
+  let position;
+  if (before === null) {
+    position =
+      movedUp && rest.length >= 2
+        ? mid(rest.at(-2), rest.at(-1))
+        : pos(rest.at(-1)) + 5;
+  } else {
+    const i = rest.findIndex(o => keyOf(o) === before);
+    if (i > 0) {
+      position = mid(rest[i - 1], rest[i]);
+    } else if (movedDown) {
+      // Top-of-page after moving down: the old first row slid up into the source
+      // page's gap, so land just after it to stay this page's first.
+      position = rest.length >= 2 ? mid(rest[0], rest[1]) : pos(rest[0]) + 5;
+    } else {
+      position = pos(rest[0]) - 5;
+    }
+  }
+  emit('reorder', { [item[props.itemKey]]: position });
+};
+
+const startDrag = () => {
+  isDragging.value = true;
+  dragged.value = press.item;
+  grab.value = { dx: press.dx, dy: press.dy };
+  dragHeight.value = press.h;
+  insertBefore.value = keyAfter(props.items, keyOf(press.item));
+  sourcePage = props.currentPage;
+  scroller = scrollParent();
+  document.body.classList.add('select-none');
+  emit('dragging', true);
+};
+
+const onPointerDown = (item, e) => {
+  if (e.button !== 0 || props.disabled) return;
+  if (e.target.closest('button, a, input, [role="button"]')) return;
+  const rect = e.currentTarget.getBoundingClientRect();
+  press = {
+    item,
+    x: e.clientX,
+    y: e.clientY,
+    dx: e.clientX - rect.left,
+    dy: e.clientY - rect.top,
+    h: rect.height,
+  };
+};
+
+useEventListener(window, 'pointermove', e => {
+  if (!press) return;
+  if (!isDragging.value) {
+    const moved = Math.hypot(e.clientX - press.x, e.clientY - press.y);
+    if (moved < DRAG_THRESHOLD) return;
+    startDrag();
+  }
+  e.preventDefault();
+  pointer.value = { x: e.clientX, y: e.clientY };
+  aim();
+  aimEdge(e.clientX);
+  updateAutoScroll(e.clientY);
+});
+
+useEventListener(window, 'pointerup', () => {
+  if (!press) return;
+  press = null;
+  if (!isDragging.value) return; // a press without movement is a click
+  const item = dragged.value;
+  const before = insertBefore.value;
+  const flipping = paging;
+  reset();
+  if (!flipping) drop(item, before);
+});
+
+// When the flipped page loads, re-aim under the held cursor so a parked edge keeps flipping.
+watch(
+  () => props.items,
+  () => {
+    if (!isDragging.value || !paging) return;
+    paging = false;
+    nextTick(() => {
+      if (!isDragging.value) return;
+      aim();
+      activeEdge.value = null;
+      aimEdge(pointer.value.x);
+    });
+  }
+);
+
+onKeyStroke('Escape', () => {
+  if (!isDragging.value) return;
+  press = null;
+  reset();
+});
+
+onBeforeUnmount(() => {
+  clearTimeout(dwell);
+  document.body.classList.remove('select-none');
+});
+</script>
+
+<template>
+  <div ref="root" class="relative w-full h-full">
+    <ul class="w-full h-full space-y-4">
+      <li
+        v-for="(item, index) in displayItems"
+        :key="keyOf(item)"
+        :data-drag-id="keyOf(item)"
+        class="relative list-none"
+        :class="{ 'cursor-grab': !disabled && !isDragging }"
+        @pointerdown="onPointerDown(item, $event)"
+        @dragstart.prevent
+      >
+        <div
+          v-if="isDragging && keyOf(item) === keyOf(dragged)"
+          :style="{ height: `${dragHeight}px` }"
+          class="border-2 border-dashed rounded-2xl border-n-brand/50 bg-n-brand/5"
+        />
+        <slot v-else name="item" :item="item" :index="index" />
+      </li>
+    </ul>
+
+    <Teleport v-if="isDragging" to="body">
+      <div
+        v-for="edge in edges"
+        :key="`band-${edge.dir}`"
+        :style="bandStyle(edge.onLeft)"
+        class="fixed top-0 left-0 z-40 pointer-events-none from-n-brand/15 to-transparent transition-opacity duration-200 [mask-image:linear-gradient(to_bottom,transparent,#000_56px,#000_calc(100%_-_56px),transparent)] [-webkit-mask-image:linear-gradient(to_bottom,transparent,#000_56px,#000_calc(100%_-_56px),transparent)]"
+        :class="[
+          edge.onLeft ? 'bg-gradient-to-r' : 'bg-gradient-to-l',
+          activeEdge === edge.dir ? 'opacity-100' : 'opacity-0',
+        ]"
+      />
+
+      <div
+        v-for="edge in edges"
+        :key="edge.dir"
+        :style="pillStyle(edge.onLeft)"
+        class="fixed top-0 left-0 z-50 flex items-center justify-center transition-all duration-150 border rounded-full pointer-events-none size-9 backdrop-blur-sm"
+        :class="
+          activeEdge === edge.dir
+            ? 'scale-110 border-n-brand bg-n-brand/20 text-n-brand shadow-md'
+            : 'opacity-70 border-n-weak/60 bg-n-solid-1/70 text-n-slate-10'
+        "
+      >
+        <Icon
+          :icon="edge.icon"
+          class="size-4"
+          :class="activeEdge === edge.dir && 'animate-pulse'"
+        />
+      </div>
+
+      <div
+        v-if="dragged"
+        :style="ghostStyle"
+        class="fixed top-0 left-0 z-50 pointer-events-none select-none"
+      >
+        <div
+          :style="scaleStyle"
+          class="transition-transform duration-150 shadow-2xl rounded-2xl"
+          :class="{ 'scale-50': activeEdge }"
+        >
+          <slot name="ghost" :item="dragged" />
+        </div>
+      </div>
+    </Teleport>
+  </div>
+</template>
diff --git a/app/javascript/dashboard/components-next/DraggableReorderList/specs/DraggableReorderList.spec.js b/app/javascript/dashboard/components-next/DraggableReorderList/specs/DraggableReorderList.spec.js
new file mode 100644
index 000000000..a6800beb5
--- /dev/null
+++ b/app/javascript/dashboard/components-next/DraggableReorderList/specs/DraggableReorderList.spec.js
@@ -0,0 +1,222 @@
+import { mount } from '@vue/test-utils';
+import { h, nextTick } from 'vue';
+import DraggableReorderList from '../DraggableReorderList.vue';
+
+// The component is pointer-driven, so we drive it through real pointer events on
+// window while mocking the layout APIs jsdom does not implement: elementFromPoint
+// (which card is under the cursor) and getBoundingClientRect (its geometry).
+const elementAtPoint = { current: null };
+
+const move = (clientX, clientY) =>
+  window.dispatchEvent(new MouseEvent('pointermove', { clientX, clientY }));
+const release = () => window.dispatchEvent(new MouseEvent('pointerup'));
+
+// Stack the rows 50px apart, each 40px tall, inside a 500px-wide list.
+const stubGeometry = wrapper => {
+  wrapper.element.getBoundingClientRect = () => ({
+    left: 0,
+    right: 500,
+    top: 0,
+    bottom: 600,
+  });
+  wrapper.findAll('[data-drag-id]').forEach((li, index) => {
+    const top = index * 50;
+    li.element.getBoundingClientRect = () => ({
+      top,
+      height: 40,
+      bottom: top + 40,
+    });
+  });
+};
+
+const mountList = (props = {}) =>
+  mount(DraggableReorderList, {
+    props: { items: [], ...props },
+    slots: {
+      item: scope => h('div', { class: 'card' }, scope.item.title),
+      ghost: scope => h('div', { class: 'ghost' }, scope.item.title),
+    },
+    global: { stubs: { Icon: true, teleport: true } },
+  });
+
+describe('DraggableReorderList', () => {
+  let wrapper;
+
+  beforeEach(() => {
+    elementAtPoint.current = null;
+    document.elementFromPoint = vi.fn(() => elementAtPoint.current);
+  });
+
+  afterEach(() => {
+    wrapper?.unmount();
+    vi.useRealTimers();
+  });
+
+  const startDragging = async id => {
+    stubGeometry(wrapper);
+    wrapper.find(`[data-drag-id="${id}"]`).element.dispatchEvent(
+      new MouseEvent('pointerdown', {
+        button: 0,
+        clientX: 250,
+        clientY: 20,
+        bubbles: true,
+      })
+    );
+    await nextTick();
+  };
+
+  it('renders each item through the item slot', () => {
+    wrapper = mountList({
+      items: [
+        { id: 1, title: 'Alpha' },
+        { id: 2, title: 'Beta' },
+      ],
+    });
+
+    const cards = wrapper.findAll('.card');
+    expect(cards).toHaveLength(2);
+    expect(cards[0].text()).toBe('Alpha');
+    expect(wrapper.find('[data-drag-id="1"]').exists()).toBe(true);
+    expect(wrapper.find('[data-drag-id="2"]').exists()).toBe(true);
+  });
+
+  it('shows a grab affordance only when enabled', () => {
+    wrapper = mountList({ items: [{ id: 1, title: 'Alpha' }] });
+    expect(wrapper.find('[data-drag-id="1"]').classes()).toContain(
+      'cursor-grab'
+    );
+
+    wrapper.unmount();
+    wrapper = mountList({ items: [{ id: 1, title: 'Alpha' }], disabled: true });
+    expect(wrapper.find('[data-drag-id="1"]').classes()).not.toContain(
+      'cursor-grab'
+    );
+  });
+
+  it('does not start a drag when disabled', async () => {
+    wrapper = mountList({
+      items: [
+        { id: 1, title: 'Alpha' },
+        { id: 2, title: 'Beta' },
+      ],
+      disabled: true,
+    });
+    await startDragging(1);
+    move(250, 200);
+    await nextTick();
+
+    expect(wrapper.emitted('dragging')).toBeUndefined();
+  });
+
+  it('emits dragging true then false across a drag', async () => {
+    wrapper = mountList({
+      items: [
+        { id: 1, title: 'Alpha' },
+        { id: 2, title: 'Beta' },
+      ],
+    });
+    await startDragging(1);
+    elementAtPoint.current = wrapper.find('[data-drag-id="2"]').element;
+    move(250, 60);
+    await nextTick();
+
+    expect(wrapper.emitted('dragging')[0]).toEqual([true]);
+
+    release();
+    await nextTick();
+    expect(wrapper.emitted('dragging')[1]).toEqual([false]);
+  });
+
+  it('emits the midpoint position when dropped between two rows', async () => {
+    wrapper = mountList({
+      items: [
+        { id: 1, title: 'Alpha', position: 10 },
+        { id: 2, title: 'Beta', position: 20 },
+        { id: 3, title: 'Gamma', position: 30 },
+      ],
+    });
+    await startDragging(1);
+
+    // Hover the lower half of Beta (top 50, height 40 → midpoint 70) so the gap
+    // sits before Gamma; dropping there lands halfway between Beta and Gamma.
+    elementAtPoint.current = wrapper.find('[data-drag-id="2"]').element;
+    move(250, 85);
+    await nextTick();
+    release();
+    await nextTick();
+
+    expect(wrapper.emitted('reorder')[0][0]).toEqual({ 1: 25 });
+  });
+
+  it('does not reorder when the only row on a page is dropped in place', async () => {
+    // P1: dragging the lone article on a later page and releasing without
+    // crossing to another page must be a no-op, not move it to the top.
+    wrapper = mountList({
+      items: [{ id: 5, title: 'Solo', position: 260 }],
+      currentPage: 2,
+      totalPages: 2,
+    });
+    await startDragging(5);
+    move(250, 300);
+    await nextTick();
+    release();
+    await nextTick();
+
+    expect(wrapper.emitted('dragging')).toEqual([[true], [false]]);
+    expect(wrapper.emitted('reorder')).toBeUndefined();
+  });
+
+  it('turns the page after dwelling on a pageable edge', async () => {
+    vi.useFakeTimers();
+    wrapper = mountList({
+      items: [
+        { id: 1, title: 'Alpha', position: 10 },
+        { id: 2, title: 'Beta', position: 20 },
+      ],
+      currentPage: 1,
+      totalPages: 2,
+    });
+    await startDragging(1);
+
+    // Drag to the right edge over blank space (no card) and hold.
+    elementAtPoint.current = null;
+    move(490, 20);
+    await nextTick();
+    vi.advanceTimersByTime(600);
+
+    expect(wrapper.emitted('navigatePage')[0]).toEqual([2]);
+  });
+
+  it('can still turn pages after releasing during a pending flip', async () => {
+    // Releasing while a flip fetch is in flight must clear paging state, or every
+    // later drag would be stuck unable to navigate.
+    vi.useFakeTimers();
+    wrapper = mountList({
+      items: [
+        { id: 1, title: 'Alpha', position: 10 },
+        { id: 2, title: 'Beta', position: 20 },
+      ],
+      currentPage: 1,
+      totalPages: 2,
+    });
+
+    // First drag: park at the edge to start a flip, then release before the new
+    // page arrives (items never change here).
+    await startDragging(1);
+    elementAtPoint.current = null;
+    move(490, 20);
+    await nextTick();
+    vi.advanceTimersByTime(600);
+    release();
+    await nextTick();
+
+    // Second drag must be able to flip again.
+    await startDragging(1);
+    elementAtPoint.current = null;
+    move(490, 20);
+    await nextTick();
+    vi.advanceTimersByTime(600);
+
+    expect(wrapper.emitted('navigatePage')).toEqual([[2], [2]]);
+  });
+});
diff --git a/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticleList.vue b/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticleList.vue
index 75aeb86d1..9e886d1d3 100644
--- a/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticleList.vue
+++ b/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticleList.vue
@@ -1,6 +1,5 @@
 <script setup>
-import { ref, computed, watch } from 'vue';
-import Draggable from 'vuedraggable';
+import { computed, ref } from 'vue';
 import { useMapGetter, useStore } from 'dashboard/composables/store.js';
 import { useRouter, useRoute } from 'vue-router';
 import { useI18n } from 'vue-i18n';
@@ -10,6 +9,7 @@ import { getArticleStatus } from 'dashboard/helper/portalHelper.js';
 import wootConstants from 'dashboard/constants/globals';
 
 import ArticleCard from 'dashboard/components-next/HelpCenter/ArticleCard/ArticleCard.vue';
+import DraggableReorderList from 'dashboard/components-next/DraggableReorderList/DraggableReorderList.vue';
 
 const props = defineProps({
   articles: {
@@ -28,9 +28,22 @@ const props = defineProps({
     type: Boolean,
     default: false,
   },
+  currentPage: {
+    type: Number,
+    default: 1,
+  },
+  totalPages: {
+    type: Number,
+    default: 1,
+  },
 });
 
-const emit = defineEmits(['translateArticle', 'toggleSelect']);
+const emit = defineEmits([
+  'translateArticle',
+  'toggleSelect',
+  'navigatePage',
+  'dragging',
+]);
 
 const { ARTICLE_STATUS_TYPES } = wootConstants;
 
@@ -39,14 +52,14 @@ const route = useRoute();
 const store = useStore();
 const { t } = useI18n();
 
-const localArticles = ref(props.articles);
 const hoveredArticleId = ref(null);
 
 const dragEnabled = computed(() => {
+  const canReorder = props.articles?.length > 1 || props.totalPages > 1;
   return (
     props.isCategoryArticles &&
     !props.isSearching &&
-    localArticles.value?.length > 1 &&
+    canReorder &&
     props.selectedArticleIds.size === 0
   );
 });
@@ -63,6 +76,10 @@ const handleCardHover = (isHovered, id) => {
 
 const getCategoryById = useMapGetter('categories/categoryById');
 
+const getCategory = categoryId => {
+  return getCategoryById.value(categoryId) || { name: '', icon: '' };
+};
+
 const openArticle = id => {
   const { tab, categorySlug, locale } = route.params;
   if (props.isCategoryArticles) {
@@ -83,38 +100,25 @@ const openArticle = id => {
   }
 };
 
-const onReorder = async reorderedGroup => {
+const onReorder = async positionsHash => {
+  const [movedId] = Object.keys(positionsHash);
+  // A same-page reorder updates optimistically in the store, so it needs no
+  // refetch. Only a cross-page drop must refresh, to pull the moved article
+  // onto this page in its new spot.
+  const isCrossPage = !props.articles.some(
+    article => String(article.id) === movedId
+  );
   try {
     await store.dispatch('articles/reorder', {
-      reorderedGroup,
+      reorderedGroup: positionsHash,
       portalSlug: route.params.portalSlug,
     });
+    if (isCrossPage) emit('navigatePage', props.currentPage);
   } catch {
     useAlert(t('HELP_CENTER.REORDER_ARTICLE.API.ERROR_MESSAGE'));
   }
 };
 
-const onDragEnd = () => {
-  // Collect and sort existing positions, falling back to index+1 for null/0 values
-  const sortedArticlePositions = localArticles.value
-    .map((article, index) => article.position || index + 1)
-    .sort((a, b) => a - b);
-
-  const orderedArticles = localArticles.value.map(article => article.id);
-
-  // Create a map of article IDs to their new positions
-  const reorderedGroup = orderedArticles.reduce((obj, key, index) => {
-    obj[key] = sortedArticlePositions[index];
-    return obj;
-  }, {});
-
-  onReorder(reorderedGroup);
-};
-
-const getCategory = categoryId => {
-  return getCategoryById.value(categoryId) || { name: '', icon: '' };
-};
-
 const getStatusMessage = (status, isSuccess) => {
   const messageType = isSuccess ? 'SUCCESS' : 'ERROR';
   const statusMap = {
@@ -184,54 +188,46 @@ const updateArticle = ({ action, value, id }) => {
   const status = action !== 'delete' ? getArticleStatus(value) : null;
   handleArticleAction(action, { status, id });
 };
-
-// Watch for changes in the articles prop and update the localArticles ref
-watch(
-  () => props.articles,
-  newArticles => {
-    localArticles.value = newArticles;
-  },
-  { deep: true }
-);
 </script>
 
 <template>
-  <Draggable
-    v-model="localArticles"
+  <DraggableReorderList
+    :items="articles"
     :disabled="!dragEnabled"
-    item-key="id"
-    tag="ul"
-    ghost-class="article-ghost-class"
-    class="w-full h-full space-y-4"
-    @end="onDragEnd"
+    :current-page="currentPage"
+    :total-pages="totalPages"
+    @reorder="onReorder"
+    @navigate-page="page => emit('navigatePage', page)"
+    @dragging="value => emit('dragging', value)"
   >
-    <template #item="{ element }">
-      <li class="list-none rounded-2xl">
-        <ArticleCard
-          :id="element.id"
-          :key="element.id"
-          :title="element.title"
-          :status="element.status"
-          :author="element.author"
-          :category="getCategory(element.category.id)"
-          :views="element.views || 0"
-          :updated-at="element.updatedAt"
-          :is-selected="selectedArticleIds.has(element.id)"
-          selectable
-          :show-selection-control="shouldShowSelectionControl(element.id)"
-          :class="{ 'cursor-grab': dragEnabled }"
-          @open-article="openArticle"
-          @article-action="updateArticle"
-          @toggle-select="emit('toggleSelect', $event)"
-          @hover="isHovered => handleCardHover(isHovered, element.id)"
-        />
-      </li>
+    <template #item="{ item }">
+      <ArticleCard
+        :id="item.id"
+        :title="item.title"
+        :status="item.status"
+        :author="item.author"
+        :category="getCategory(item.category.id)"
+        :views="item.views || 0"
+        :updated-at="item.updatedAt"
+        :is-selected="selectedArticleIds.has(item.id)"
+        selectable
+        :show-selection-control="shouldShowSelectionControl(item.id)"
+        @open-article="openArticle"
+        @article-action="updateArticle"
+        @toggle-select="emit('toggleSelect', $event)"
+        @hover="isHovered => handleCardHover(isHovered, item.id)"
+      />
     </template>
-  </Draggable>
+    <template #ghost="{ item }">
+      <ArticleCard
+        :id="item.id"
+        :title="item.title"
+        :status="item.status"
+        :author="item.author"
+        :category="getCategory(item.category.id)"
+        :views="item.views || 0"
+        :updated-at="item.updatedAt"
+      />
+    </template>
+  </DraggableReorderList>
 </template>
-
-<style lang="scss" scoped>
-.article-ghost-class {
-  @apply opacity-50 bg-n-solid-1;
-}
-</style>
diff --git a/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticlesPage.vue b/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticlesPage.vue
index 66bcf6831..b5ae662e4 100644
--- a/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticlesPage.vue
+++ b/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticlesPage.vue
@@ -70,6 +70,7 @@ const isFeatureEnabledonAccount = useMapGetter(
 );
 
 const selectedArticleIds = ref(new Set());
+const isArticleDragging = ref(false);
 const deleteConfirmDialogRef = ref(null);
 const isCategoryMenuOpen = ref(false);
 const searchQuery = ref(route.query.search || '');
@@ -148,6 +149,8 @@ const articlesCount = computed(() => {
   return Number(countMap[tab] || countMap['']);
 });
 
+const totalPages = computed(() => Math.ceil(articlesCount.value / 25) || 1);
+
 const showArticleHeaderControls = computed(
   () => !props.isCategoryArticles && !isSwitchingPortal.value
 );
@@ -343,7 +346,7 @@ watch(
     </template>
     <template #content>
       <div
-        v-if="isLoading"
+        v-if="isLoading && !isArticleDragging"
         class="flex items-center justify-center py-10 text-n-slate-11"
       >
         <Spinner />
@@ -453,9 +456,13 @@ watch(
           :is-category-articles="isCategoryArticles"
           :is-searching="isSearching"
           :selected-article-ids="selectedArticleIds"
+          :current-page="Number(meta.currentPage)"
+          :total-pages="totalPages"
           class="relative z-0"
           @translate-article="handleTranslateArticle"
           @toggle-select="handleToggleSelect"
+          @navigate-page="handlePageChange"
+          @dragging="isArticleDragging = $event"
         />
       </template>
       <ArticleEmptyState
diff --git a/app/javascript/dashboard/components/Modal.vue b/app/javascript/dashboard/components/Modal.vue
index c8a23bf95..48d4e8d6b 100644
--- a/app/javascript/dashboard/components/Modal.vue
+++ b/app/javascript/dashboard/components/Modal.vue
@@ -123,6 +123,10 @@ onMounted(() => {
       a {
         @apply p-4;
       }
+
+      .ProseMirror a {
+        @apply p-0;
+      }
     }
   }
 }
diff --git a/app/javascript/dashboard/components/widgets/conversation/ConversationCard.vue b/app/javascript/dashboard/components/widgets/conversation/ConversationCard.vue
index 95ef53491..a5dec806d 100644
--- a/app/javascript/dashboard/components/widgets/conversation/ConversationCard.vue
+++ b/app/javascript/dashboard/components/widgets/conversation/ConversationCard.vue
@@ -57,7 +57,9 @@ const showMetaSection = computed(() => {
   );
 });
 
-const hasSlaPolicyId = computed(() => props.chat?.sla_policy_id);
+const hasSlaPolicyId = computed(
+  () => props.chat?.applied_sla?.id && !props.currentContact?.blocked
+);
 
 const showLabelsSection = computed(() => {
   return props.chat.labels?.length > 0 || hasSlaPolicyId.value;
diff --git a/app/javascript/dashboard/components/widgets/conversation/ConversationHeader.vue b/app/javascript/dashboard/components/widgets/conversation/ConversationHeader.vue
index ccd1a8aae..b1e3bc603 100644
--- a/app/javascript/dashboard/components/widgets/conversation/ConversationHeader.vue
+++ b/app/javascript/dashboard/components/widgets/conversation/ConversationHeader.vue
@@ -93,7 +93,9 @@ const hasMultipleInboxes = computed(
   () => store.getters['inboxes/getInboxes'].length > 1
 );
 
-const hasSlaPolicyId = computed(() => props.chat?.sla_policy_id);
+const hasSlaPolicyId = computed(
+  () => props.chat?.applied_sla?.id && !currentContact.value?.blocked
+);
 
 const copyConversationId = async () => {
   try {
diff --git a/app/javascript/dashboard/components/widgets/conversation/components/SLACardLabel.vue b/app/javascript/dashboard/components/widgets/conversation/components/SLACardLabel.vue
index bb6ee48d2..f5e2d4522 100644
--- a/app/javascript/dashboard/components/widgets/conversation/components/SLACardLabel.vue
+++ b/app/javascript/dashboard/components/widgets/conversation/components/SLACardLabel.vue
@@ -1,7 +1,7 @@
 <script setup>
 import { ref, computed, onMounted, onUnmounted, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
-import { evaluateSLAStatus } from '@chatwoot/utils';
+import { evaluateSLAStatus } from 'dashboard/helper/slaHelper';
 import SLAPopoverCard from './SLAPopoverCard.vue';
 
 const props = defineProps({
@@ -61,6 +61,7 @@ const updateSlaStatus = () => {
   slaStatus.value = evaluateSLAStatus({
     appliedSla: appliedSLA.value,
     chat: props.chat,
+    slaEvents: slaEvents.value || [],
   });
 };
 
diff --git a/app/javascript/dashboard/components/widgets/conversation/specs/ConversationCard.spec.js b/app/javascript/dashboard/components/widgets/conversation/specs/ConversationCard.spec.js
new file mode 100644
index 000000000..a5f45fc56
--- /dev/null
+++ b/app/javascript/dashboard/components/widgets/conversation/specs/ConversationCard.spec.js
@@ -0,0 +1,60 @@
+import { shallowMount } from '@vue/test-utils';
+import ConversationCard from '../ConversationCard.vue';
+
+const defaultChat = {
+  id: 1,
+  labels: [],
+  messages: [],
+  priority: null,
+  unread_count: 0,
+  timestamp: 1700000000,
+  created_at: 1700000000,
+};
+
+const mountComponent = (chat, currentContact = {}) =>
+  shallowMount(ConversationCard, {
+    props: {
+      chat: { ...defaultChat, ...chat },
+      currentContact: {
+        name: 'Jane Doe',
+        thumbnail: '',
+        availability_status: 'offline',
+        ...currentContact,
+      },
+      inbox: { id: 1 },
+    },
+    global: {
+      stubs: {
+        'fluent-icon': true,
+      },
+    },
+  });
+
+describe('ConversationCard', () => {
+  it('does not reserve the labels row when only a persisted SLA policy id is present', () => {
+    const wrapper = mountComponent({ sla_policy_id: 1, applied_sla: null });
+
+    expect(wrapper.findComponent({ name: 'CardLabels' }).exists()).toBe(false);
+  });
+
+  it('shows the labels row when an active applied SLA is present', () => {
+    const wrapper = mountComponent({
+      sla_policy_id: 1,
+      applied_sla: { id: 1 },
+    });
+
+    expect(wrapper.findComponent({ name: 'CardLabels' }).exists()).toBe(true);
+  });
+
+  it('does not reserve the labels row when the contact is blocked', () => {
+    const wrapper = mountComponent(
+      {
+        sla_policy_id: 1,
+        applied_sla: { id: 1 },
+      },
+      { blocked: true }
+    );
+
+    expect(wrapper.findComponent({ name: 'CardLabels' }).exists()).toBe(false);
+  });
+});
diff --git a/app/javascript/dashboard/composables/useCallSession.js b/app/javascript/dashboard/composables/useCallSession.js
index 354f3a7b3..275a6337d 100644
--- a/app/javascript/dashboard/composables/useCallSession.js
+++ b/app/javascript/dashboard/composables/useCallSession.js
@@ -161,6 +161,7 @@ const buildCallActions = ({ callsStore, whatsappSession, t }) => {
       return { conferenceSid: joinResponse?.conference_sid };
     } catch (error) {
       useAlert(error?.response?.data?.error || t('CONTACT_PANEL.CALL_FAILED'));
+      // 409 = the call already ended before accept landed (e.g. caller hung up mid-ring).
       if (error?.response?.status === 409) {
         TwilioVoiceClient.endClientCall();
         markDismissed(callSid);
diff --git a/app/javascript/dashboard/constants/billing.js b/app/javascript/dashboard/constants/billing.js
new file mode 100644
index 000000000..d372330f8
--- /dev/null
+++ b/app/javascript/dashboard/constants/billing.js
@@ -0,0 +1,35 @@
+// Single source of truth for billing currencies on the frontend.
+// Adding a currency = one entry in BILLING_CURRENCY_CONFIG, add the code to
+// SUPPORTED_BILLING_CURRENCIES, and add its label key under
+// BILLING_SETTINGS.CURRENCY.OPTIONS in the locale files.
+
+export const DEFAULT_BILLING_CURRENCY = 'usd';
+
+// Order here drives the order of the currency toggle in the UI.
+export const SUPPORTED_BILLING_CURRENCIES = ['usd', 'brl'];
+
+export const BILLING_CURRENCY_CONFIG = {
+  usd: {
+    code: 'usd',
+    intlLocale: 'en-US',
+    i18nLabelKey: 'BILLING_SETTINGS.CURRENCY.OPTIONS.USD',
+  },
+  brl: {
+    code: 'brl',
+    intlLocale: 'pt-BR',
+    i18nLabelKey: 'BILLING_SETTINGS.CURRENCY.OPTIONS.BRL',
+  },
+};
+
+export const getCurrencyConfig = code =>
+  BILLING_CURRENCY_CONFIG[(code || DEFAULT_BILLING_CURRENCY).toLowerCase()] ||
+  BILLING_CURRENCY_CONFIG[DEFAULT_BILLING_CURRENCY];
+
+export const formatCurrencyAmount = (amount, code, options = {}) => {
+  const { intlLocale, code: currencyCode } = getCurrencyConfig(code);
+  return new Intl.NumberFormat(intlLocale, {
+    style: 'currency',
+    currency: currencyCode.toUpperCase(),
+    ...options,
+  }).format(amount);
+};
diff --git a/app/javascript/dashboard/constants/editor.js b/app/javascript/dashboard/constants/editor.js
index cb0996136..8af56c5e2 100644
--- a/app/javascript/dashboard/constants/editor.js
+++ b/app/javascript/dashboard/constants/editor.js
@@ -188,6 +188,16 @@ export const ARTICLE_EDITOR_MENU_OPTIONS = [
   'insertTable',
 ];
 
+// [text](url) -> "text: url" (drop label if it equals the URL). Keep serializer
+// escapes; the re-parse renders them literally, unescaping would crash it.
+const flattenLink = (_match, text, url) => {
+  const cleanUrl = url
+    .trim()
+    .replace(/\s+["'(].*$/, '')
+    .replace(/^<|>$/g, '');
+  return text === cleanUrl ? cleanUrl : `${text}: ${cleanUrl}`;
+};
+
 /**
  * Markdown formatting patterns for stripping unsupported formatting.
  *
@@ -264,7 +274,12 @@ export const MARKDOWN_PATTERNS = [
   {
     type: 'link', // PM: link
     patterns: [
-      { pattern: /\[([^\]]+)\]\([^)]+\)/g, replacement: '$1' }, // [text](url) -> text
+      // Escape-aware label + URL captures so a \] or \) can't cut the match
+      // short and leave link markup that crashes the re-parse.
+      {
+        pattern: /\[((?:\\.|[^\]\\])*)\]\(((?:\\.|[^)\\])*)\)/g,
+        replacement: flattenLink,
+      },
       { pattern: /<([a-zA-Z][a-zA-Z0-9+.-]*:[^\s>]+)>/g, replacement: '$1' }, // <https://...>, <mailto:...>, <tel:...>, <ftp://...>, etc
       { pattern: /<([^\s@]+@[^\s@>]+)>/g, replacement: '$1' }, // <user@example.com> -> user@example.com
     ],
diff --git a/app/javascript/dashboard/helper/slaHelper.js b/app/javascript/dashboard/helper/slaHelper.js
new file mode 100644
index 000000000..9c69f9d0b
--- /dev/null
+++ b/app/javascript/dashboard/helper/slaHelper.js
@@ -0,0 +1,150 @@
+import { useCamelCase } from 'dashboard/composables/useTransformKeys';
+
+/**
+ * Formats seconds into a human-readable time string
+ * @param {number} seconds - The time in seconds (can be negative for overdue)
+ * @returns {string} Formatted time string like "2h 30m" or "1d 4h"
+ */
+const formatSLATime = seconds => {
+  const absSeconds = Math.abs(seconds);
+
+  const units = {
+    y: 31536000,
+    mo: 2592000,
+    d: 86400,
+    h: 3600,
+    m: 60,
+  };
+
+  if (absSeconds < 60) {
+    return '1m';
+  }
+
+  const parts = [];
+  let remaining = absSeconds;
+
+  Object.entries(units).forEach(([unit, value]) => {
+    if (parts.length >= 2) return;
+    const count = Math.floor(remaining / value);
+    if (count > 0) {
+      parts.push(`${count}${unit}`);
+      remaining -= count * value;
+    }
+  });
+
+  return parts.join(' ');
+};
+
+const toUnixTimestamp = value => {
+  if (!value || typeof value === 'number') return value;
+
+  const numericValue = Number(value);
+  if (!Number.isNaN(numericValue)) return numericValue;
+
+  const parsedTimestamp = Date.parse(value);
+  return Number.isNaN(parsedTimestamp)
+    ? value
+    : Math.floor(parsedTimestamp / 1000);
+};
+
+/**
+ * Evaluates SLA status using backend-computed due times
+ * @param {Object} params - Parameters object
+ * @param {Object} params.appliedSla - The applied SLA with due_at timestamps
+ * @param {Object} params.chat - The conversation object
+ * @param {Array} params.slaEvents - Recorded SLA miss events for this conversation
+ * @returns {Object} SLA status with type, threshold, icon, and isSlaMissed
+ */
+export const evaluateSLAStatus = ({ appliedSla, chat, slaEvents = [] }) => {
+  const emptyStatus = { type: '', threshold: '', icon: '', isSlaMissed: false };
+
+  if (!appliedSla || !chat) {
+    return emptyStatus;
+  }
+
+  const sla = useCamelCase(appliedSla);
+  const conversation = useCamelCase(chat);
+  const events = useCamelCase(slaEvents || []);
+  const currentTime = Math.floor(Date.now() / 1000);
+  const slaStatuses = [];
+
+  const dueAtByType = {
+    FRT: sla.slaFrtDueAt,
+    RT: sla.slaRtDueAt,
+  };
+  const slaTypes = ['FRT', 'NRT', 'RT'];
+
+  events.forEach(event => {
+    const type = event.eventType?.toUpperCase();
+    if (!slaTypes.includes(type)) return;
+
+    const missedAt =
+      type === 'NRT' ? event.createdAt : dueAtByType[type] || event.createdAt;
+    if (!missedAt) return;
+
+    slaStatuses.push({
+      type,
+      threshold: missedAt - currentTime,
+      icon: 'flame',
+      isSlaMissed: true,
+    });
+  });
+
+  const firstReplyCreatedAt = toUnixTimestamp(conversation.firstReplyCreatedAt);
+  const shouldCheckFirstResponse =
+    !firstReplyCreatedAt || firstReplyCreatedAt > sla.slaFrtDueAt;
+
+  // Check FRT - until first reply is made on time
+  if (sla.slaFrtDueAt && shouldCheckFirstResponse) {
+    const threshold = sla.slaFrtDueAt - currentTime;
+    slaStatuses.push({
+      type: 'FRT',
+      threshold,
+      icon: threshold <= 0 ? 'flame' : 'alarm',
+      isSlaMissed: threshold <= 0,
+    });
+  }
+
+  // Check NRT - only if first reply made and waiting for response
+  if (sla.slaNrtDueAt && firstReplyCreatedAt && conversation.waitingSince) {
+    const threshold = sla.slaNrtDueAt - currentTime;
+    slaStatuses.push({
+      type: 'NRT',
+      threshold,
+      icon: threshold <= 0 ? 'flame' : 'alarm',
+      isSlaMissed: threshold <= 0,
+    });
+  }
+
+  // Check RT - only if conversation is unresolved
+  if (sla.slaRtDueAt && conversation.status !== 'resolved') {
+    const threshold = sla.slaRtDueAt - currentTime;
+    slaStatuses.push({
+      type: 'RT',
+      threshold,
+      icon: threshold <= 0 ? 'flame' : 'alarm',
+      isSlaMissed: threshold <= 0,
+    });
+  }
+
+  if (slaStatuses.length === 0) {
+    return emptyStatus;
+  }
+
+  // Show existing breaches before upcoming deadlines, then pick the closest timer.
+  slaStatuses.sort((a, b) => {
+    if (a.isSlaMissed !== b.isSlaMissed) {
+      return a.isSlaMissed ? -1 : 1;
+    }
+
+    return Math.abs(a.threshold) - Math.abs(b.threshold);
+  });
+  const mostUrgent = slaStatuses[0];
+
+  return {
+    type: mostUrgent.type,
+    threshold: formatSLATime(mostUrgent.threshold),
+    icon: mostUrgent.icon,
+    isSlaMissed: mostUrgent.isSlaMissed,
+  };
+};
diff --git a/app/javascript/dashboard/helper/specs/editorHelper.spec.js b/app/javascript/dashboard/helper/specs/editorHelper.spec.js
index 7d32f63e0..220b9903e 100644
--- a/app/javascript/dashboard/helper/specs/editorHelper.spec.js
+++ b/app/javascript/dashboard/helper/specs/editorHelper.spec.js
@@ -1,4 +1,9 @@
-import { EditorState, EditorView } from '@chatwoot/prosemirror-schema';
+import {
+  EditorState,
+  EditorView,
+  buildMessageSchema,
+  MessageMarkdownTransformer,
+} from '@chatwoot/prosemirror-schema';
 import { FORMATTING } from 'dashboard/constants/editor';
 import { Schema } from 'prosemirror-model';
 import {
@@ -978,13 +983,77 @@ describe('stripUnsupportedFormatting', () => {
       );
     });
 
-    it('strips links but keeps text', () => {
+    it('keeps link text and URL when schema does not support links', () => {
       expect(
         stripUnsupportedFormatting(
           'Check [this link](https://example.com)',
           emptySchema
         )
-      ).toBe('Check this link');
+      ).toBe('Check this link: https://example.com');
+    });
+
+    it('drops the hidden link title when preserving the URL', () => {
+      expect(
+        stripUnsupportedFormatting(
+          'Check [docs](https://example.com "Docs")',
+          emptySchema
+        )
+      ).toBe('Check docs: https://example.com');
+
+      expect(
+        stripUnsupportedFormatting(
+          'Check [docs](<https://example.com> "Docs")',
+          emptySchema
+        )
+      ).toBe('Check docs: https://example.com');
+    });
+
+    // Output is re-parsed before sending, so assert the final text
+    // (strip + re-parse); the re-parse turns serializer escapes into literals.
+    describe('links round-trip through re-parse without crashing', () => {
+      const smsSchema = buildMessageSchema([], []); // no marks, no nodes
+      const sendAs = md =>
+        new MessageMarkdownTransformer(smsSchema).parse(
+          stripUnsupportedFormatting(md, smsSchema)
+        ).textContent;
+
+      it('keeps escaped parens/underscores anywhere in the URL', () => {
+        expect(
+          sendAs('See [wiki](https://en.wikipedia.org/wiki/Foo\\_\\(bar\\))')
+        ).toBe('See wiki: https://en.wikipedia.org/wiki/Foo_(bar)');
+        expect(sendAs('See [wiki](https://host/a\\_\\(b\\)c)')).toBe(
+          'See wiki: https://host/a_(b)c'
+        );
+      });
+
+      it('drops the label when it equals the URL even when escaped', () => {
+        expect(
+          sendAs(
+            '[www.example.com/Foo\\_\\(bar\\)](www.example.com/Foo\\_\\(bar\\))'
+          )
+        ).toBe('www.example.com/Foo_(bar)');
+      });
+
+      it('does not reintroduce emphasis from an escaped label', () => {
+        expect(sendAs('[Use \\_id\\_](https://example.com)')).toBe(
+          'Use _id_: https://example.com'
+        );
+      });
+
+      it('flattens a label containing an escaped closing bracket', () => {
+        expect(sendAs('[FAQ \\[v2\\]](https://example.com)')).toBe(
+          'FAQ [v2]: https://example.com'
+        );
+      });
+    });
+
+    it('leaves bare URLs untouched so channels can auto-link them', () => {
+      expect(
+        stripUnsupportedFormatting('Visit www.example.com now', emptySchema)
+      ).toBe('Visit www.example.com now');
+      expect(
+        stripUnsupportedFormatting('Visit <https://example.com>', emptySchema)
+      ).toBe('Visit https://example.com');
     });
 
     it('converts autolinks to plain URLs when schema does not support links', () => {
@@ -1049,7 +1118,7 @@ describe('stripUnsupportedFormatting', () => {
     it('handles complex content with multiple formatting types', () => {
       const content =
         '**Bold** and *italic* with `code` and [link](url)\n- list item';
-      const expected = 'Bold and italic with code and link\nlist item';
+      const expected = 'Bold and italic with code and link: url\nlist item';
       expect(stripUnsupportedFormatting(content, emptySchema)).toBe(expected);
     });
   });
diff --git a/app/javascript/dashboard/helper/specs/slaHelper.spec.js b/app/javascript/dashboard/helper/specs/slaHelper.spec.js
new file mode 100644
index 000000000..466112f7d
--- /dev/null
+++ b/app/javascript/dashboard/helper/specs/slaHelper.spec.js
@@ -0,0 +1,450 @@
+import { evaluateSLAStatus } from '../slaHelper';
+
+describe('#SLA Helpers', () => {
+  const currentTimestamp = 1700000000; // Fixed timestamp for testing
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(currentTimestamp * 1000);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('evaluateSLAStatus', () => {
+    describe('when inputs are invalid', () => {
+      it('returns empty status when appliedSla is null', () => {
+        const result = evaluateSLAStatus({ appliedSla: null, chat: {} });
+        expect(result).toEqual({
+          type: '',
+          threshold: '',
+          icon: '',
+          isSlaMissed: false,
+        });
+      });
+
+      it('returns empty status when chat is null', () => {
+        const result = evaluateSLAStatus({ appliedSla: {}, chat: null });
+        expect(result).toEqual({
+          type: '',
+          threshold: '',
+          icon: '',
+          isSlaMissed: false,
+        });
+      });
+    });
+
+    describe('FRT (First Response Time)', () => {
+      it('returns FRT status when first reply not made and within threshold', () => {
+        const appliedSla = { sla_frt_due_at: currentTimestamp + 3600 }; // 1 hour from now
+        const chat = { first_reply_created_at: null, status: 'open' };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('FRT');
+        expect(result.threshold).toBe('1h');
+        expect(result.icon).toBe('alarm');
+        expect(result.isSlaMissed).toBe(false);
+      });
+
+      it('returns missed FRT status when threshold is exceeded', () => {
+        const appliedSla = { sla_frt_due_at: currentTimestamp - 1800 }; // 30 min ago
+        const chat = { first_reply_created_at: null, status: 'open' };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('FRT');
+        expect(result.threshold).toBe('30m');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('does not return FRT when first reply was made before due time', () => {
+        const appliedSla = { sla_frt_due_at: currentTimestamp + 3600 };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 1000,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).not.toBe('FRT');
+      });
+
+      it('does not return FRT when first reply was made at due time', () => {
+        const appliedSla = {
+          sla_frt_due_at: currentTimestamp - 600,
+          sla_rt_due_at: currentTimestamp + 1800,
+        };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 600,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('RT');
+      });
+
+      it('returns missed FRT when first reply was made after due time', () => {
+        const appliedSla = {
+          sla_frt_due_at: currentTimestamp - 600,
+          sla_rt_due_at: currentTimestamp + 1800,
+        };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 300,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('FRT');
+        expect(result.threshold).toBe('10m');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('returns missed FRT when live first reply timestamp is an ISO string after due time', () => {
+        const appliedSla = {
+          sla_frt_due_at: currentTimestamp - 600,
+          sla_rt_due_at: currentTimestamp + 1800,
+        };
+        const chat = {
+          first_reply_created_at: new Date(
+            (currentTimestamp - 300) * 1000
+          ).toISOString(),
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('FRT');
+        expect(result.threshold).toBe('10m');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('uses the due time for a missed FRT event created after the deadline', () => {
+        const appliedSla = { sla_frt_due_at: currentTimestamp - 3600 };
+        const chat = { first_reply_created_at: null, status: 'open' };
+        const slaEvents = [
+          { event_type: 'frt', created_at: currentTimestamp - 1800 },
+        ];
+
+        const result = evaluateSLAStatus({ appliedSla, chat, slaEvents });
+
+        expect(result.type).toBe('FRT');
+        expect(result.threshold).toBe('1h');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+    });
+
+    describe('NRT (Next Response Time)', () => {
+      it('returns NRT status when waiting for response and within threshold', () => {
+        const appliedSla = { sla_nrt_due_at: currentTimestamp + 1800 }; // 30 min from now
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          waiting_since: currentTimestamp - 600,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('NRT');
+        expect(result.threshold).toBe('30m');
+        expect(result.icon).toBe('alarm');
+        expect(result.isSlaMissed).toBe(false);
+      });
+
+      it('returns missed NRT status when threshold is exceeded', () => {
+        const appliedSla = { sla_nrt_due_at: currentTimestamp - 900 }; // 15 min ago
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          waiting_since: currentTimestamp - 2700,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('NRT');
+        expect(result.threshold).toBe('15m');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('does not return NRT when not waiting for response', () => {
+        const appliedSla = { sla_nrt_due_at: currentTimestamp + 1800 };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          waiting_since: null,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).not.toBe('NRT');
+      });
+
+      it('returns missed NRT when a recorded NRT miss exists after response', () => {
+        const appliedSla = { sla_rt_due_at: currentTimestamp + 1800 };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          waiting_since: null,
+          status: 'open',
+        };
+        const slaEvents = [
+          { event_type: 'nrt', created_at: currentTimestamp - 900 },
+        ];
+
+        const result = evaluateSLAStatus({ appliedSla, chat, slaEvents });
+
+        expect(result.type).toBe('NRT');
+        expect(result.threshold).toBe('15m');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('uses the recorded event time for a missed NRT with a new active NRT timer', () => {
+        const appliedSla = {
+          sla_nrt_due_at: currentTimestamp + 300,
+          sla_rt_due_at: currentTimestamp + 1800,
+        };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          waiting_since: currentTimestamp - 60,
+          status: 'open',
+        };
+        const slaEvents = [
+          { event_type: 'nrt', created_at: currentTimestamp - 1800 },
+        ];
+
+        const result = evaluateSLAStatus({ appliedSla, chat, slaEvents });
+
+        expect(result.type).toBe('NRT');
+        expect(result.threshold).toBe('30m');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('does not return NRT when first reply not made', () => {
+        const appliedSla = { sla_nrt_due_at: currentTimestamp + 1800 };
+        const chat = {
+          first_reply_created_at: null,
+          waiting_since: currentTimestamp - 600,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).not.toBe('NRT');
+      });
+    });
+
+    describe('RT (Resolution Time)', () => {
+      it('returns RT status when conversation is open and within threshold', () => {
+        const appliedSla = { sla_rt_due_at: currentTimestamp + 7200 }; // 2 hours from now
+        const chat = {
+          first_reply_created_at: currentTimestamp - 3600,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('RT');
+        expect(result.threshold).toBe('2h');
+        expect(result.icon).toBe('alarm');
+        expect(result.isSlaMissed).toBe(false);
+      });
+
+      it.each(['pending', 'snoozed'])(
+        'returns RT status when conversation is %s and within threshold',
+        status => {
+          const appliedSla = { sla_rt_due_at: currentTimestamp + 7200 };
+          const chat = {
+            first_reply_created_at: currentTimestamp - 3600,
+            status,
+          };
+
+          const result = evaluateSLAStatus({ appliedSla, chat });
+
+          expect(result.type).toBe('RT');
+          expect(result.threshold).toBe('2h');
+          expect(result.icon).toBe('alarm');
+          expect(result.isSlaMissed).toBe(false);
+        }
+      );
+
+      it('returns missed RT status when threshold is exceeded', () => {
+        const appliedSla = { sla_rt_due_at: currentTimestamp - 3600 }; // 1 hour ago
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('RT');
+        expect(result.threshold).toBe('1h');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('uses the due time for a missed RT event created after the deadline', () => {
+        const appliedSla = { sla_rt_due_at: currentTimestamp - 3600 };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          status: 'open',
+        };
+        const slaEvents = [
+          { event_type: 'rt', created_at: currentTimestamp - 1800 },
+        ];
+
+        const result = evaluateSLAStatus({ appliedSla, chat, slaEvents });
+
+        expect(result.type).toBe('RT');
+        expect(result.threshold).toBe('1h');
+        expect(result.icon).toBe('flame');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('does not return RT when conversation is resolved', () => {
+        const appliedSla = { sla_rt_due_at: currentTimestamp + 7200 };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 3600,
+          status: 'resolved',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('');
+      });
+    });
+
+    describe('priority selection', () => {
+      it('returns most urgent SLA when multiple are active', () => {
+        const appliedSla = {
+          sla_frt_due_at: currentTimestamp + 7200, // 2h - less urgent
+          sla_nrt_due_at: currentTimestamp + 1800, // 30m - most urgent
+          sla_rt_due_at: currentTimestamp + 3600, // 1h
+        };
+        const chat = {
+          first_reply_created_at: null,
+          waiting_since: currentTimestamp - 600,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        // FRT is selected because first_reply_created_at is null
+        // NRT is not checked when first_reply_created_at is null
+        expect(result.type).toBe('RT');
+        expect(result.threshold).toBe('1h');
+      });
+
+      it('returns most urgent missed SLA over upcoming SLA', () => {
+        const appliedSla = {
+          sla_nrt_due_at: currentTimestamp - 300, // 5m overdue - most urgent by absolute value
+          sla_rt_due_at: currentTimestamp + 3600, // 1h remaining
+        };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 7200,
+          waiting_since: currentTimestamp - 2100,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('NRT');
+        expect(result.isSlaMissed).toBe(true);
+      });
+
+      it('returns an existing missed SLA over a closer upcoming SLA', () => {
+        const appliedSla = {
+          sla_frt_due_at: currentTimestamp - 7200, // 2h overdue
+          sla_rt_due_at: currentTimestamp + 300, // 5m remaining
+        };
+        const chat = {
+          first_reply_created_at: null,
+          status: 'open',
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.type).toBe('FRT');
+        expect(result.threshold).toBe('2h');
+        expect(result.isSlaMissed).toBe(true);
+      });
+    });
+
+    describe('time formatting', () => {
+      it('formats time in days and hours', () => {
+        const appliedSla = { sla_rt_due_at: currentTimestamp + 90000 }; // 25 hours
+        const chat = { status: 'open' };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.threshold).toBe('1d 1h');
+      });
+
+      it('formats time less than a minute as 1m', () => {
+        const appliedSla = { sla_frt_due_at: currentTimestamp + 30 }; // 30 seconds
+        const chat = { first_reply_created_at: null, status: 'open' };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.threshold).toBe('1m');
+      });
+
+      it('formats months correctly', () => {
+        const appliedSla = {
+          sla_rt_due_at: currentTimestamp + 2592000 + 86400,
+        }; // 1 month + 1 day
+        const chat = { status: 'open' };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result.threshold).toBe('1mo 1d');
+      });
+    });
+
+    describe('empty status scenarios', () => {
+      it('returns empty when no SLA thresholds are set', () => {
+        const appliedSla = {};
+        const chat = { status: 'open' };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result).toEqual({
+          type: '',
+          threshold: '',
+          icon: '',
+          isSlaMissed: false,
+        });
+      });
+
+      it('returns empty when all conditions are met', () => {
+        const appliedSla = {
+          sla_frt_due_at: currentTimestamp + 3600,
+          sla_nrt_due_at: currentTimestamp + 1800,
+          sla_rt_due_at: currentTimestamp + 7200,
+        };
+        const chat = {
+          first_reply_created_at: currentTimestamp - 3600, // FRT already hit
+          waiting_since: null, // Not waiting, so NRT not applicable
+          status: 'resolved', // RT not applicable
+        };
+
+        const result = evaluateSLAStatus({ appliedSla, chat });
+
+        expect(result).toEqual({
+          type: '',
+          threshold: '',
+          icon: '',
+          isSlaMissed: false,
+        });
+      });
+    });
+  });
+});
diff --git a/app/javascript/dashboard/helper/voice.js b/app/javascript/dashboard/helper/voice.js
index 224dce88a..4f5ad25fe 100644
--- a/app/javascript/dashboard/helper/voice.js
+++ b/app/javascript/dashboard/helper/voice.js
@@ -1,4 +1,7 @@
-import { CONTENT_TYPES } from 'dashboard/components-next/message/constants';
+import {
+  CONTENT_TYPES,
+  VOICE_CALL_STATUS,
+} from 'dashboard/components-next/message/constants';
 import { MESSAGE_TYPE } from 'shared/constants/messages';
 import { useCallsStore } from 'dashboard/stores/calls';
 import types from 'dashboard/store/mutation-types';
@@ -101,6 +104,7 @@ export function handleVoiceCallCreated(
     callSid,
     callId,
     provider,
+    status,
     callDirection,
     conversationId,
     inboxId,
@@ -108,6 +112,11 @@ export function handleVoiceCallCreated(
     senderId,
   } = extractCallData(message);
 
+  // A voice_call message can be created already terminal when the caller hangs
+  // up before connect. Only ring while the call is actually ringing; mirrors the
+  // guard in seedCallsFromHydratedMessages.
+  if (status !== VOICE_CALL_STATUS.RINGING) return;
+
   if (
     !shouldShowCall({
       callDirection,
diff --git a/app/javascript/dashboard/i18n/locale/en/report.json b/app/javascript/dashboard/i18n/locale/en/report.json
index 2ffa0ef11..0171b9620 100644
--- a/app/javascript/dashboard/i18n/locale/en/report.json
+++ b/app/javascript/dashboard/i18n/locale/en/report.json
@@ -121,6 +121,26 @@
       "CLEAR_FILTER": "Clear filter",
       "EMPTY_LIST": "No results found"
     },
+    "DRILLDOWN": {
+      "TITLE": "{metric} details",
+      "RESULT_COUNT_CONVERSATION": "{count} conversation | {count} conversations",
+      "RESULT_COUNT_MESSAGE": "{count} message | {count} messages",
+      "EMPTY": "No records found for this bar.",
+      "ERROR": "Could not load records. Please try again.",
+      "ADMIN_ONLY": "Only administrators can drill down into report records.",
+      "LOAD_MORE": "Load more",
+      "CLOSE": "Close details",
+      "PREVIOUS_BUCKET": "Previous bar",
+      "NEXT_BUCKET": "Next bar",
+      "UNKNOWN_CONTACT": "Unknown contact",
+      "UNKNOWN_INBOX": "Unknown inbox",
+      "UNASSIGNED_AGENT": "Unassigned",
+      "NO_MESSAGE_CONTENT": "No message content",
+      "MESSAGE_CREATED_AT": "Message created at {time}",
+      "EVENT_OCCURRED_AT": "Event occurred at {time}",
+      "INCOMING_MESSAGE": "Incoming message",
+      "OUTGOING_MESSAGE": "Outgoing message"
+    },
     "PAGINATION": {
       "RESULTS": "Showing {start} to {end} of {total} results",
       "PER_PAGE_TEMPLATE": "{size} / page"
diff --git a/app/javascript/dashboard/i18n/locale/en/settings.json b/app/javascript/dashboard/i18n/locale/en/settings.json
index 640b9c506..4caca05fb 100644
--- a/app/javascript/dashboard/i18n/locale/en/settings.json
+++ b/app/javascript/dashboard/i18n/locale/en/settings.json
@@ -467,7 +467,18 @@
       "TITLE": "Current Plan",
       "PLAN_NOTE": "You are currently subscribed to the **{plan}** plan with **{quantity}** licenses",
       "SEAT_COUNT": "Number of seats",
-      "RENEWS_ON": "Renews on"
+      "RENEWS_ON": "Renews on",
+      "CURRENCY": "Currency"
+    },
+    "CURRENCY": {
+      "SELECT": {
+        "TITLE": "Choose your billing currency",
+        "DESCRIPTION": "Select the currency you'd like to be billed in. This can't be changed once your subscription is created."
+      },
+      "OPTIONS": {
+        "USD": "US Dollar (USD)",
+        "BRL": "Brazilian Real (BRL)"
+      }
     },
     "VIEW_PRICING": "View Pricing",
     "MANAGE_SUBSCRIPTION": {
@@ -503,6 +514,7 @@
       "PURCHASE": "Purchase Credits",
       "LOADING": "Loading options...",
       "FETCH_ERROR": "Failed to load credit options. Please try again.",
+      "RETRY": "Retry",
       "PURCHASE_ERROR": "Failed to process purchase. Please try again.",
       "PURCHASE_SUCCESS": "Successfully added {credits} credits to your account",
       "CONFIRM": {
diff --git a/app/javascript/dashboard/routes/dashboard/settings/billing/Index.vue b/app/javascript/dashboard/routes/dashboard/settings/billing/Index.vue
index bcfa46193..521fa654b 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/billing/Index.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/billing/Index.vue
@@ -15,6 +15,8 @@ import PurchaseCreditsModal from './components/PurchaseCreditsModal.vue';
 import BaseSettingsHeader from '../components/BaseSettingsHeader.vue';
 import SettingsLayout from '../SettingsLayout.vue';
 import ButtonV4 from 'next/button/Button.vue';
+import { getCurrencyConfig } from 'dashboard/constants/billing';
+import { useI18n } from 'vue-i18n';
 
 const router = useRouter();
 const { currentAccount, isOnChatwootCloud } = useAccount();
@@ -29,6 +31,7 @@ const {
 
 const uiFlags = useMapGetter('accounts/getUIFlags');
 const store = useStore();
+const { t } = useI18n();
 
 const BILLING_REFRESH_ATTEMPTED = 'billing_refresh_attempted';
 
@@ -36,6 +39,10 @@ const BILLING_REFRESH_ATTEMPTED = 'billing_refresh_attempted';
 const isWaitingForBilling = ref(false);
 const purchaseCreditsModalRef = ref(null);
 
+// Currency selection shown to new accounts whose locale supports a non-USD currency.
+const currencySelectionRequired = ref(false);
+const currencyOptions = ref([]);
+
 const customAttributes = computed(() => {
   return currentAccount.value.custom_attributes || {};
 });
@@ -61,6 +68,13 @@ const subscribedQuantity = computed(() => {
   return customAttributes.value.subscribed_quantity;
 });
 
+const billingCurrency = computed(() => {
+  if (!customAttributes.value.billing_currency) return '';
+  return t(
+    getCurrencyConfig(customAttributes.value.billing_currency).i18nLabelKey
+  );
+});
+
 const subscriptionRenewsOn = computed(() => {
   if (!customAttributes.value.subscription_ends_on) return '';
   const endDate = new Date(customAttributes.value.subscription_ends_on);
@@ -78,7 +92,9 @@ const hasABillingPlan = computed(() => {
 
 const fetchAccountDetails = async () => {
   if (!hasABillingPlan.value) {
-    await store.dispatch('accounts/subscription');
+    const data = await store.dispatch('accounts/subscription');
+    currencySelectionRequired.value = !!data?.currency_selection_required;
+    currencyOptions.value = data?.currency_options || [];
   }
   // Always fetch limits for billing page to show credit usage
   fetchLimits();
@@ -97,6 +113,9 @@ const handleBillingPageLogic = async () => {
   // If cloud user, fetch account details first
   await fetchAccountDetails();
 
+  // Waiting on the user to pick a billing currency — don't auto-refresh.
+  if (currencySelectionRequired.value) return;
+
   // If still no billing plan after fetch
   if (!hasABillingPlan.value) {
     // If we haven't attempted refresh yet, do it once
@@ -118,6 +137,13 @@ const handleBillingPageLogic = async () => {
   }
 };
 
+const onSelectCurrency = async code => {
+  await store.dispatch('accounts/selectBillingCurrency', code);
+  currencySelectionRequired.value = false;
+  // Currency stored and customer creation kicked off — resume the standard wait flow.
+  await handleBillingPageLogic();
+};
+
 const onClickBillingPortal = () => {
   store.dispatch('accounts/checkout');
 };
@@ -148,7 +174,9 @@ onMounted(handleBillingPageLogic);
         ? $t('BILLING_SETTINGS.NO_BILLING_USER')
         : $t('ATTRIBUTES_MGMT.LOADING')
     "
-    :no-records-found="!hasABillingPlan && !isWaitingForBilling"
+    :no-records-found="
+      !hasABillingPlan && !isWaitingForBilling && !currencySelectionRequired
+    "
     :no-records-message="$t('BILLING_SETTINGS.NO_BILLING_USER')"
   >
     <template #header>
@@ -160,7 +188,30 @@ onMounted(handleBillingPageLogic);
       />
     </template>
     <template #body>
-      <section class="grid gap-4">
+      <section v-if="currencySelectionRequired" class="grid gap-4">
+        <BillingCard
+          :title="$t('BILLING_SETTINGS.CURRENCY.SELECT.TITLE')"
+          :description="$t('BILLING_SETTINGS.CURRENCY.SELECT.DESCRIPTION')"
+        >
+          <template #action>
+            <div class="flex gap-2">
+              <ButtonV4
+                v-for="code in currencyOptions"
+                :key="code"
+                sm
+                solid
+                blue
+                :is-loading="uiFlags.isCheckoutInProcess"
+                :disabled="uiFlags.isCheckoutInProcess"
+                @click="onSelectCurrency(code)"
+              >
+                {{ $t(getCurrencyConfig(code).i18nLabelKey) }}
+              </ButtonV4>
+            </div>
+          </template>
+        </BillingCard>
+      </section>
+      <section v-else class="grid gap-4">
         <BillingCard
           :title="$t('BILLING_SETTINGS.MANAGE_SUBSCRIPTION.TITLE')"
           :description="$t('BILLING_SETTINGS.MANAGE_SUBSCRIPTION.DESCRIPTION')"
@@ -188,6 +239,11 @@ onMounted(handleBillingPageLogic);
               :label="$t('BILLING_SETTINGS.CURRENT_PLAN.RENEWS_ON')"
               :value="subscriptionRenewsOn"
             />
+            <DetailItem
+              v-if="billingCurrency"
+              :label="$t('BILLING_SETTINGS.CURRENT_PLAN.CURRENCY')"
+              :value="billingCurrency"
+            />
           </div>
         </BillingCard>
         <BillingCard
diff --git a/app/javascript/dashboard/routes/dashboard/settings/billing/components/CreditPackageCard.vue b/app/javascript/dashboard/routes/dashboard/settings/billing/components/CreditPackageCard.vue
index d557e9a71..59cf07c18 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/billing/components/CreditPackageCard.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/billing/components/CreditPackageCard.vue
@@ -1,4 +1,6 @@
 <script setup>
+import { formatCurrencyAmount } from 'dashboard/constants/billing';
+
 defineProps({
   credits: {
     type: Number,
@@ -33,11 +35,7 @@ const formatCredits = credits => {
 };
 
 const formatAmount = (amount, currency) => {
-  return new Intl.NumberFormat('en-US', {
-    style: 'currency',
-    currency: currency.toUpperCase(),
-    minimumFractionDigits: 0,
-  }).format(amount);
+  return formatCurrencyAmount(amount, currency, { minimumFractionDigits: 0 });
 };
 </script>
 
diff --git a/app/javascript/dashboard/routes/dashboard/settings/billing/components/PurchaseCreditsModal.vue b/app/javascript/dashboard/routes/dashboard/settings/billing/components/PurchaseCreditsModal.vue
index 33f299b9b..ce59a8738 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/billing/components/PurchaseCreditsModal.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/billing/components/PurchaseCreditsModal.vue
@@ -4,20 +4,18 @@ import { useI18n } from 'vue-i18n';
 import { useAlert } from 'dashboard/composables';
 import Dialog from 'dashboard/components-next/dialog/Dialog.vue';
 import Button from 'dashboard/components-next/button/Button.vue';
+import Spinner from 'dashboard/components-next/spinner/Spinner.vue';
 import CreditPackageCard from './CreditPackageCard.vue';
 import EnterpriseAccountAPI from 'dashboard/api/enterprise/account';
+import {
+  formatCurrencyAmount,
+  DEFAULT_BILLING_CURRENCY,
+} from 'dashboard/constants/billing';
 
-const emit = defineEmits(['close', 'success']);
+const emit = defineEmits(['success']);
 
 const { t } = useI18n();
 
-const TOPUP_OPTIONS = [
-  { credits: 1000, amount: 20.0, currency: 'usd' },
-  { credits: 2500, amount: 50.0, currency: 'usd' },
-  { credits: 6000, amount: 100.0, currency: 'usd' },
-  { credits: 12000, amount: 200.0, currency: 'usd' },
-];
-
 const POPULAR_CREDITS_AMOUNT = 6000;
 const STEP_SELECT = 'select';
 const STEP_CONFIRM = 'confirm';
@@ -27,16 +25,20 @@ const selectedCredits = ref(null);
 const isLoading = ref(false);
 const currentStep = ref(STEP_SELECT);
 
+// Topup packages come from the backend for the account's billing currency.
+const topupOptions = ref([]);
+const optionsCurrency = ref(DEFAULT_BILLING_CURRENCY);
+const isFetchingOptions = ref(false);
+const fetchError = ref(false);
+
 const selectedOption = computed(() => {
-  return TOPUP_OPTIONS.find(o => o.credits === selectedCredits.value);
+  return topupOptions.value.find(o => o.credits === selectedCredits.value);
 });
 
 const formattedAmount = computed(() => {
   if (!selectedOption.value) return '';
-  return new Intl.NumberFormat('en-US', {
-    style: 'currency',
-    currency: selectedOption.value.currency.toUpperCase(),
-  }).format(selectedOption.value.amount);
+  const { amount, currency } = selectedOption.value;
+  return formatCurrencyAmount(amount, currency || optionsCurrency.value);
 });
 
 const formattedCredits = computed(() => {
@@ -64,24 +66,44 @@ const handlePackageSelect = credits => {
   selectedCredits.value = credits;
 };
 
-const open = () => {
-  const popularOption = TOPUP_OPTIONS.find(
+const selectDefaultOption = () => {
+  const popularOption = topupOptions.value.find(
     o => o.credits === POPULAR_CREDITS_AMOUNT
   );
-  selectedCredits.value = popularOption?.credits || TOPUP_OPTIONS[0]?.credits;
+  selectedCredits.value =
+    popularOption?.credits || topupOptions.value[0]?.credits || null;
+};
+
+const fetchOptions = async () => {
+  isFetchingOptions.value = true;
+  fetchError.value = false;
+  try {
+    const { data } = await EnterpriseAccountAPI.getTopupOptions();
+    topupOptions.value = data.options ?? [];
+    optionsCurrency.value = (
+      data.currency || DEFAULT_BILLING_CURRENCY
+    ).toLowerCase();
+    selectDefaultOption();
+  } catch {
+    fetchError.value = true;
+    topupOptions.value = [];
+  } finally {
+    isFetchingOptions.value = false;
+  }
+};
+
+const open = () => {
   currentStep.value = STEP_SELECT;
   isLoading.value = false;
+  selectedCredits.value = null;
   dialogRef.value?.open();
+  fetchOptions();
 };
 
 const close = () => {
   dialogRef.value?.close();
 };
 
-const handleClose = () => {
-  emit('close');
-};
-
 const goToConfirmStep = () => {
   if (!selectedOption.value) return;
   currentStep.value = STEP_CONFIRM;
@@ -127,32 +149,58 @@ defineExpose({ open, close });
     :width="dialogWidth"
     :show-confirm-button="false"
     :show-cancel-button="false"
-    @close="handleClose"
   >
     <!-- Step 1: Select Credits Package -->
-    <template v-if="currentStep === 'select'">
-      <div class="grid grid-cols-2 gap-4">
-        <CreditPackageCard
-          v-for="option in TOPUP_OPTIONS"
-          :key="option.credits"
-          name="credit-package"
-          :credits="option.credits"
-          :amount="option.amount"
-          :currency="option.currency"
-          :is-popular="option.credits === POPULAR_CREDITS_AMOUNT"
-          :is-selected="selectedCredits === option.credits"
-          @select="handlePackageSelect(option.credits)"
+    <template v-if="currentStep === STEP_SELECT">
+      <div
+        v-if="isFetchingOptions"
+        class="flex items-center justify-center gap-2 py-10"
+      >
+        <Spinner />
+        <span class="text-sm text-n-slate-11">{{
+          $t('BILLING_SETTINGS.TOPUP.LOADING')
+        }}</span>
+      </div>
+
+      <div
+        v-else-if="fetchError"
+        class="flex flex-col items-center justify-center gap-3 py-10"
+      >
+        <p class="text-sm text-n-slate-11">
+          {{ $t('BILLING_SETTINGS.TOPUP.FETCH_ERROR') }}
+        </p>
+        <Button
+          variant="faded"
+          color="slate"
+          :label="$t('BILLING_SETTINGS.TOPUP.RETRY')"
+          @click="fetchOptions"
         />
       </div>
 
-      <div class="p-4 mt-6 rounded-lg bg-n-solid-2 border border-n-weak">
-        <p class="text-sm text-n-slate-11">
-          <span class="font-semibold text-n-slate-12">{{
-            $t('BILLING_SETTINGS.TOPUP.NOTE_TITLE')
-          }}</span>
-          {{ $t('BILLING_SETTINGS.TOPUP.NOTE_DESCRIPTION') }}
-        </p>
-      </div>
+      <template v-else>
+        <div class="grid grid-cols-2 gap-4">
+          <CreditPackageCard
+            v-for="option in topupOptions"
+            :key="option.credits"
+            name="credit-package"
+            :credits="option.credits"
+            :amount="option.amount"
+            :currency="option.currency"
+            :is-popular="option.credits === POPULAR_CREDITS_AMOUNT"
+            :is-selected="selectedCredits === option.credits"
+            @select="handlePackageSelect(option.credits)"
+          />
+        </div>
+
+        <div class="p-4 mt-6 rounded-lg bg-n-solid-2 border border-n-weak">
+          <p class="text-sm text-n-slate-11">
+            <span class="font-semibold text-n-slate-12">{{
+              $t('BILLING_SETTINGS.TOPUP.NOTE_TITLE')
+            }}</span>
+            {{ $t('BILLING_SETTINGS.TOPUP.NOTE_DESCRIPTION') }}
+          </p>
+        </div>
+      </template>
     </template>
 
     <!-- Step 2: Confirm Purchase -->
@@ -178,7 +226,7 @@ defineExpose({ open, close });
     <template #footer>
       <!-- Step 1 Footer -->
       <div
-        v-if="currentStep === 'select'"
+        v-if="currentStep === STEP_SELECT"
         class="flex items-center justify-between w-full gap-3"
       >
         <Button
@@ -192,7 +240,7 @@ defineExpose({ open, close });
           color="blue"
           :label="$t('BILLING_SETTINGS.TOPUP.PURCHASE')"
           class="w-full"
-          :disabled="!selectedCredits"
+          :disabled="!selectedCredits || isFetchingOptions || fetchError"
           @click="goToConfirmStep"
         />
       </div>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue b/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue
index 7fd23ebb1..b2d0dae69 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue
@@ -149,9 +149,5 @@ export default {
 
 :deep(.ProseMirror-woot-style) {
   @apply min-h-[12.5rem];
-
-  p {
-    @apply text-base;
-  }
 }
 </style>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue b/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue
index 7a570a300..9980db58b 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue
@@ -153,9 +153,5 @@ export default {
 
 :deep(.ProseMirror-woot-style) {
   @apply min-h-[12.5rem];
-
-  p {
-    @apply text-base;
-  }
 }
 </style>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/BotReports.vue b/app/javascript/dashboard/routes/dashboard/settings/reports/BotReports.vue
index 03b7290d6..2a1cd18c8 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/reports/BotReports.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/BotReports.vue
@@ -101,6 +101,9 @@ export default {
       summary-fetching-key="getBotSummaryFetchingStatus"
       :group-by="groupBy"
       :report-keys="reportKeys"
+      :from="from"
+      :to="to"
+      :business-hours="businessHours"
     />
   </div>
 </template>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/Index.vue b/app/javascript/dashboard/routes/dashboard/settings/reports/Index.vue
index 9794d97e4..ea1e80e70 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/reports/Index.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/Index.vue
@@ -121,6 +121,11 @@ export default {
       show-group-by
       @filter-change="onFilterChange"
     />
-    <ReportContainer :group-by="groupBy" />
+    <ReportContainer
+      :group-by="groupBy"
+      :from="from"
+      :to="to"
+      :business-hours="businessHours"
+    />
   </div>
 </template>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/ReportContainer.vue b/app/javascript/dashboard/routes/dashboard/settings/reports/ReportContainer.vue
index c44ab58e5..ccd71b3a4 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/reports/ReportContainer.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/ReportContainer.vue
@@ -5,16 +5,38 @@ import { GROUP_BY_FILTER, METRIC_CHART } from './constants';
 import fromUnixTime from 'date-fns/fromUnixTime';
 import format from 'date-fns/format';
 import { formatTime } from '@chatwoot/utils';
+import { useAlert } from 'dashboard/composables';
 import ChartStats from './components/ChartElements/ChartStats.vue';
 import BarChart from 'shared/components/charts/BarChart.vue';
+import ReportDrilldownDrawer from './components/ReportDrilldownDrawer.vue';
 
 export default {
-  components: { ChartStats, BarChart },
+  components: { ChartStats, BarChart, ReportDrilldownDrawer },
   props: {
     groupBy: {
       type: Object,
       default: () => ({}),
     },
+    from: {
+      type: Number,
+      default: 0,
+    },
+    to: {
+      type: Number,
+      default: 0,
+    },
+    reportType: {
+      type: String,
+      default: 'account',
+    },
+    selectedItemId: {
+      type: [String, Number],
+      default: null,
+    },
+    businessHours: {
+      type: Boolean,
+      default: false,
+    },
     accountSummaryKey: {
       type: String,
       default: 'getAccountSummary',
@@ -42,10 +64,27 @@ export default {
     );
     return { calculateTrend, isAverageMetricType };
   },
+  data() {
+    return {
+      drilldownRequest: null,
+      drilldownMetric: null,
+      drilldownIndex: null,
+    };
+  },
   computed: {
     ...mapGetters({
       accountReport: 'getAccountReports',
+      currentRole: 'getCurrentRole',
     }),
+    isAdmin() {
+      return this.currentRole === 'administrator';
+    },
+    canDrilldownPrev() {
+      return this.findDrillableIndex(this.drilldownIndex - 1, -1) !== null;
+    },
+    canDrilldownNext() {
+      return this.findDrillableIndex(this.drilldownIndex + 1, 1) !== null;
+    },
     metrics() {
       const reportKeys = Object.keys(this.reportKeys);
       const infoText = {
@@ -139,6 +178,82 @@ export default {
 
       return options;
     },
+    isDrilldownEnabled() {
+      return !!(this.from && this.to);
+    },
+    onChartElementClick(metric, event) {
+      if (!this.isDrilldownEnabled()) return;
+
+      const dataPoint = this.accountReport.data[metric.KEY]?.[event.dataIndex];
+      if (!this.canOpenDrilldown(metric, dataPoint)) return;
+      if (!this.isAdmin) {
+        useAlert(this.$t('REPORT.DRILLDOWN.ADMIN_ONLY'));
+        return;
+      }
+
+      this.openDrilldownAt(metric, event.dataIndex);
+    },
+    openDrilldownAt(metric, dataIndex) {
+      const dataPoint = this.accountReport.data[metric.KEY]?.[dataIndex];
+      if (!this.canOpenDrilldown(metric, dataPoint)) return;
+
+      const labels = this.getCollection(metric).labels || [];
+
+      this.drilldownMetric = metric;
+      this.drilldownIndex = dataIndex;
+      this.drilldownRequest = {
+        metric: metric.KEY,
+        metricName: metric.NAME,
+        bucketLabel: labels[dataIndex],
+        bucketTimestamp: dataPoint.timestamp,
+        bucketValue: dataPoint.value,
+        isAverageMetric: this.isAverageMetricType(metric.KEY),
+        from: this.from,
+        to: this.to,
+        type: this.reportType,
+        id: this.selectedItemId,
+        groupBy: this.groupBy?.period,
+        businessHours: this.businessHours,
+      };
+    },
+    navigateDrilldown(direction) {
+      const nextIndex = this.findDrillableIndex(
+        this.drilldownIndex + direction,
+        direction
+      );
+      if (nextIndex === null) return;
+
+      this.openDrilldownAt(this.drilldownMetric, nextIndex);
+    },
+    findDrillableIndex(startIndex, step) {
+      if (!this.drilldownMetric) return null;
+
+      const data = this.accountReport.data[this.drilldownMetric.KEY] || [];
+      for (
+        let index = startIndex;
+        index >= 0 && index < data.length;
+        index += step
+      ) {
+        if (this.canOpenDrilldown(this.drilldownMetric, data[index]))
+          return index;
+      }
+
+      return null;
+    },
+    canOpenDrilldown(metric, dataPoint) {
+      if (!dataPoint) return false;
+
+      if (this.isAverageMetricType(metric.KEY)) {
+        return dataPoint.count > 0;
+      }
+
+      return dataPoint.value > 0;
+    },
+    closeDrilldown() {
+      this.drilldownRequest = null;
+      this.drilldownMetric = null;
+      this.drilldownIndex = null;
+    },
   },
 };
 </script>
@@ -168,6 +283,8 @@ export default {
             v-if="accountReport.data[metric.KEY].length"
             :collection="getCollection(metric)"
             :chart-options="getChartOptions(metric)"
+            :clickable="isDrilldownEnabled()"
+            @element-click="onChartElementClick(metric, $event)"
           />
           <span v-else class="text-sm text-n-slate-10">
             {{ $t('REPORT.NO_ENOUGH_DATA') }}
@@ -176,4 +293,23 @@ export default {
       </div>
     </div>
   </div>
+  <ReportDrilldownDrawer
+    :id="drilldownRequest?.id"
+    :open="!!drilldownRequest"
+    :metric="drilldownRequest?.metric"
+    :metric-name="drilldownRequest?.metricName"
+    :bucket-label="drilldownRequest?.bucketLabel"
+    :bucket-timestamp="drilldownRequest?.bucketTimestamp"
+    :bucket-value="drilldownRequest?.bucketValue"
+    :is-average-metric="drilldownRequest?.isAverageMetric"
+    :from="drilldownRequest?.from"
+    :to="drilldownRequest?.to"
+    :type="drilldownRequest?.type"
+    :group-by="drilldownRequest?.groupBy"
+    :business-hours="drilldownRequest?.businessHours"
+    :can-prev="canDrilldownPrev"
+    :can-next="canDrilldownNext"
+    @navigate="navigateDrilldown"
+    @close="closeDrilldown"
+  />
 </template>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/components/ReportDrilldownCard.vue b/app/javascript/dashboard/routes/dashboard/settings/reports/components/ReportDrilldownCard.vue
new file mode 100644
index 000000000..b9df2e900
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/components/ReportDrilldownCard.vue
@@ -0,0 +1,279 @@
+<script setup>
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRoute } from 'vue-router';
+import { formatTime } from '@chatwoot/utils';
+import format from 'date-fns/format';
+import fromUnixTime from 'date-fns/fromUnixTime';
+import Icon from 'dashboard/components-next/icon/Icon.vue';
+import TimeAgo from 'dashboard/components/ui/TimeAgo.vue';
+import { frontendURL, conversationUrl } from 'dashboard/helper/URLHelper';
+import { dynamicTime, shortTimestamp } from 'shared/helpers/timeHelper';
+
+const props = defineProps({
+  record: {
+    type: Object,
+    required: true,
+  },
+});
+
+const { t } = useI18n();
+const route = useRoute();
+
+const conversation = computed(() => props.record.conversation || {});
+const message = computed(() => props.record.message || {});
+const isMessageRecord = computed(() => props.record.record_type === 'message');
+const isEventBackedConversationRecord = computed(
+  () => !isMessageRecord.value && !!props.record.event_name
+);
+const conversationDisplayId = computed(() => conversation.value.display_id);
+const conversationNumber = computed(() => `#${conversationDisplayId.value}`);
+const messageDirection = computed(() => message.value.message_type);
+
+const formatTimestamp = timestamp => {
+  if (!timestamp) return '';
+
+  return format(fromUnixTime(timestamp), 'dd MMM yyyy, h:mm a');
+};
+
+const compactTimestamp = timestamp => {
+  if (!timestamp) return '';
+
+  return shortTimestamp(dynamicTime(timestamp)).trim();
+};
+
+const metricValue = computed(() => {
+  const value = props.record.metric_value;
+  if (value === null || value === undefined) return '';
+
+  return formatTime(value) || `${value}`;
+});
+
+const previewText = computed(() => {
+  if (message.value.content) return message.value.content;
+  if (conversation.value.last_message?.content) {
+    return conversation.value.last_message.content;
+  }
+
+  return t('REPORT.DRILLDOWN.NO_MESSAGE_CONTENT');
+});
+
+const showPreview = computed(() => {
+  return isMessageRecord.value || conversation.value.last_message;
+});
+
+const messageCreatedTooltip = computed(() =>
+  t('REPORT.DRILLDOWN.MESSAGE_CREATED_AT', {
+    time: formatTimestamp(message.value.created_at),
+  })
+);
+
+const eventOccurredTooltip = computed(() =>
+  t('REPORT.DRILLDOWN.EVENT_OCCURRED_AT', {
+    time: formatTimestamp(props.record.occurred_at),
+  })
+);
+
+const directionDetails = computed(() => {
+  const direction = messageDirection.value;
+  if (!direction) return null;
+
+  const isIncoming = direction === 'incoming';
+  return {
+    icon: isIncoming ? 'i-lucide-arrow-down-left' : 'i-lucide-arrow-up-right',
+    tooltip: isIncoming
+      ? t('REPORT.DRILLDOWN.INCOMING_MESSAGE')
+      : t('REPORT.DRILLDOWN.OUTGOING_MESSAGE'),
+  };
+});
+
+const conversationPath = computed(() => {
+  if (!conversationDisplayId.value) return '';
+
+  const path = conversationUrl({
+    accountId: route.params.accountId,
+    id: conversationDisplayId.value,
+  });
+  const params =
+    isMessageRecord.value && message.value.id
+      ? { messageId: message.value.id }
+      : null;
+
+  return frontendURL(path, params);
+});
+
+const contactPath = computed(() => {
+  if (!conversation.value.contact_id) return '';
+
+  return frontendURL(
+    `accounts/${route.params.accountId}/contacts/${conversation.value.contact_id}`
+  );
+});
+
+const inboxPath = computed(() => {
+  if (!conversation.value.inbox_id) return '';
+
+  return frontendURL(
+    `accounts/${route.params.accountId}/inbox/${conversation.value.inbox_id}`
+  );
+});
+
+const agentPath = computed(() => {
+  if (!conversation.value.assignee_id) return '';
+
+  return frontendURL(
+    `accounts/${route.params.accountId}/reports/agents/${conversation.value.assignee_id}`
+  );
+});
+
+const metadataItems = computed(() => [
+  {
+    key: 'contact',
+    icon: 'i-lucide-contact',
+    label:
+      conversation.value.contact_name || t('REPORT.DRILLDOWN.UNKNOWN_CONTACT'),
+    path: contactPath.value,
+  },
+  {
+    key: 'inbox',
+    icon: 'i-lucide-inbox',
+    label: conversation.value.inbox_name || t('REPORT.DRILLDOWN.UNKNOWN_INBOX'),
+    path: inboxPath.value,
+  },
+  {
+    key: 'agent',
+    icon: 'i-lucide-user-round',
+    label:
+      conversation.value.assignee_name ||
+      t('REPORT.DRILLDOWN.UNASSIGNED_AGENT'),
+    path: agentPath.value,
+  },
+]);
+
+const metadataAttributes = item => {
+  if (!item.path) return {};
+
+  return {
+    href: item.path,
+    target: '_blank',
+    rel: 'noopener noreferrer',
+  };
+};
+
+const metadataItemClass = item => [
+  'flex min-w-0 items-center gap-1 text-n-slate-10',
+  item.path ? 'group hover:text-n-blue-11 hover:underline' : '',
+];
+
+const metadataIconClass = item => [
+  'size-3 shrink-0 text-n-slate-9',
+  item.path ? 'group-hover:text-n-blue-11' : '',
+];
+
+const stopMetadataLinkClick = (event, item) => {
+  if (item.path) {
+    event.stopPropagation();
+  }
+};
+
+const openInNewTab = url => {
+  if (!url) return;
+
+  window.open(url, '_blank', 'noopener,noreferrer');
+};
+
+const openRecord = () => {
+  openInNewTab(conversationPath.value);
+};
+</script>
+
+<template>
+  <article
+    role="link"
+    tabindex="0"
+    class="cursor-pointer rounded-md border border-n-weak bg-n-solid-2 p-3 hover:bg-n-alpha-1 focus-visible:outline focus-visible:outline-2 focus-visible:outline-n-brand"
+    @click="openRecord"
+    @keydown.enter.self.prevent="openRecord"
+    @keydown.space.self.prevent="openRecord"
+  >
+    <div class="flex items-start justify-between gap-2">
+      <div class="min-w-0">
+        <div
+          class="flex items-center gap-2 text-sm font-medium leading-5 text-n-slate-12"
+        >
+          <span>{{ conversationNumber }}</span>
+          <span
+            v-if="conversation.status"
+            class="rounded bg-n-alpha-2 px-1.5 py-0.5 text-xs capitalize text-n-slate-11"
+          >
+            {{ conversation.status }}
+          </span>
+          <span
+            v-if="directionDetails"
+            v-tooltip.top="directionDetails.tooltip"
+            :aria-label="directionDetails.tooltip"
+            class="flex size-5 items-center justify-center rounded bg-n-alpha-2 text-n-slate-11"
+          >
+            <Icon :icon="directionDetails.icon" class="size-3" />
+          </span>
+          <span
+            v-if="metricValue"
+            class="rounded bg-n-alpha-2 px-1.5 py-0.5 text-xs text-n-slate-11"
+          >
+            {{ metricValue }}
+          </span>
+        </div>
+      </div>
+      <div
+        class="ms-2 flex shrink-0 items-center justify-end gap-1 text-end text-xs leading-4 text-n-slate-10"
+      >
+        <span
+          v-if="isMessageRecord"
+          v-tooltip.left="messageCreatedTooltip"
+          :aria-label="messageCreatedTooltip"
+          class="whitespace-nowrap"
+        >
+          {{ compactTimestamp(message.created_at) }}
+        </span>
+        <TimeAgo
+          v-else
+          :is-auto-refresh-enabled="false"
+          :conversation-id="conversation.id"
+          :last-activity-timestamp="conversation.last_activity_at"
+          :created-at-timestamp="conversation.created_at"
+          class="font-440 !text-xs !text-n-slate-10"
+        />
+        <span
+          v-if="isEventBackedConversationRecord"
+          v-tooltip.left="eventOccurredTooltip"
+          :aria-label="eventOccurredTooltip"
+          class="whitespace-nowrap rounded bg-n-alpha-2 px-1 py-0.5 text-[11px] leading-4 text-n-slate-10"
+        >
+          {{ compactTimestamp(record.occurred_at) }}
+        </span>
+      </div>
+    </div>
+
+    <p
+      v-if="showPreview"
+      class="mt-2 line-clamp-1 text-sm leading-5 text-n-slate-12"
+    >
+      {{ previewText }}
+    </p>
+
+    <div class="mt-2 grid grid-cols-3 gap-2">
+      <component
+        :is="item.path ? 'a' : 'span'"
+        v-for="item in metadataItems"
+        :key="item.key"
+        class="text-body-main"
+        v-bind="metadataAttributes(item)"
+        :class="metadataItemClass(item)"
+        @click="stopMetadataLinkClick($event, item)"
+      >
+        <Icon :icon="item.icon" :class="metadataIconClass(item)" />
+        <span class="truncate">{{ item.label }}</span>
+      </component>
+    </div>
+  </article>
+</template>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/components/ReportDrilldownDrawer.vue b/app/javascript/dashboard/routes/dashboard/settings/reports/components/ReportDrilldownDrawer.vue
new file mode 100644
index 000000000..f7c3bfd4b
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/components/ReportDrilldownDrawer.vue
@@ -0,0 +1,315 @@
+<script setup>
+import { computed, nextTick, onBeforeUnmount, ref, watch } from 'vue';
+import { useEventListener } from '@vueuse/core';
+import { useI18n } from 'vue-i18n';
+import { formatTime } from '@chatwoot/utils';
+import Button from 'dashboard/components-next/button/Button.vue';
+import Spinner from 'dashboard/components-next/spinner/Spinner.vue';
+import TeleportWithDirection from 'dashboard/components-next/TeleportWithDirection.vue';
+import { useReportDrilldown } from '../composables/useReportDrilldown';
+import ReportDrilldownCard from './ReportDrilldownCard.vue';
+
+const props = defineProps({
+  open: { type: Boolean, default: false },
+  metric: { type: String, default: '' },
+  metricName: { type: String, default: '' },
+  bucketLabel: { type: String, default: '' },
+  bucketTimestamp: { type: Number, default: null },
+  from: { type: Number, default: null },
+  to: { type: Number, default: null },
+  type: { type: String, default: 'account' },
+  id: { type: [String, Number], default: null },
+  groupBy: { type: String, default: '' },
+  businessHours: { type: Boolean, default: false },
+  bucketValue: { type: Number, default: null },
+  isAverageMetric: { type: Boolean, default: false },
+  canPrev: { type: Boolean, default: false },
+  canNext: { type: Boolean, default: false },
+});
+
+const emit = defineEmits(['close', 'navigate']);
+
+const { t } = useI18n();
+const drawerRef = ref(null);
+const {
+  records,
+  meta,
+  isFetching,
+  isFetchingMore,
+  hasError,
+  hasRecords,
+  hasMore,
+  open: openDrilldown,
+  close,
+  loadMore,
+} = useReportDrilldown();
+
+let previousActiveElement = null;
+
+const isOpen = computed(() => props.open);
+
+const title = computed(() => props.metricName || '');
+
+const bucketValue = computed(() => {
+  if (props.bucketValue === null) return '';
+
+  return props.isAverageMetric
+    ? formatTime(props.bucketValue)
+    : `${props.bucketValue}`;
+});
+
+// The headline stat already shows the conversation count for conversation-count
+// metrics (e.g. conversations_count), so the subtitle count would be redundant.
+const isStatConversationCount = computed(
+  () =>
+    !props.isAverageMetric &&
+    meta.value.record_type === 'conversation' &&
+    props.bucketValue === meta.value.conversation_count
+);
+
+const conversationCount = computed(() => {
+  if (!meta.value.conversation_count || isStatConversationCount.value)
+    return '';
+
+  return t('REPORT.DRILLDOWN.RESULT_COUNT_CONVERSATION', {
+    count: meta.value.conversation_count,
+  });
+});
+
+// Timing metrics (e.g. reply time) show a duration as the stat, so the underlying
+// message count adds context. Skip it when it just mirrors the conversation count
+// (e.g. first response time has one response message per conversation).
+const messageCount = computed(() => {
+  if (
+    !props.isAverageMetric ||
+    meta.value.record_type !== 'message' ||
+    !meta.value.total_count ||
+    meta.value.total_count === meta.value.conversation_count
+  ) {
+    return '';
+  }
+
+  return t('REPORT.DRILLDOWN.RESULT_COUNT_MESSAGE', {
+    count: meta.value.total_count,
+  });
+});
+
+const subtitle = computed(() =>
+  [props.bucketLabel, conversationCount.value, messageCount.value]
+    .filter(Boolean)
+    .join(' ⋅ ')
+);
+
+const restoreFocus = () => {
+  if (previousActiveElement?.isConnected) {
+    previousActiveElement.focus();
+  }
+  previousActiveElement = null;
+};
+
+const closeDrawer = () => {
+  close();
+  emit('close');
+  restoreFocus();
+};
+
+const recordKey = record =>
+  `${record.record_type}-${record.message?.id || record.conversation?.id}-${
+    record.occurred_at
+  }`;
+
+const rememberActiveElement = () => {
+  if (previousActiveElement) return;
+
+  previousActiveElement =
+    document.activeElement instanceof HTMLElement
+      ? document.activeElement
+      : null;
+};
+
+const focusDrawer = () => {
+  nextTick(() => drawerRef.value?.focus());
+};
+
+const fetchDrilldown = () => {
+  openDrilldown({
+    metric: props.metric,
+    bucketTimestamp: props.bucketTimestamp,
+    from: props.from,
+    to: props.to,
+    type: props.type,
+    id: props.id,
+    groupBy: props.groupBy,
+    businessHours: props.businessHours,
+  });
+};
+
+const navigate = direction => {
+  if (direction < 0 && !props.canPrev) return;
+  if (direction > 0 && !props.canNext) return;
+
+  emit('navigate', direction);
+};
+
+const onKeydown = event => {
+  if (!isOpen.value) return;
+
+  if (event.key === 'Escape') {
+    event.preventDefault();
+    event.stopPropagation();
+    closeDrawer();
+  } else if (event.key === 'ArrowLeft') {
+    navigate(-1);
+  } else if (event.key === 'ArrowRight') {
+    navigate(1);
+  }
+};
+
+useEventListener(document, 'keydown', onKeydown);
+
+watch(
+  () => props.open,
+  isDrawerOpen => {
+    if (!isDrawerOpen) {
+      close();
+      restoreFocus();
+      return;
+    }
+
+    rememberActiveElement();
+    fetchDrilldown();
+    focusDrawer();
+  },
+  { immediate: true }
+);
+
+watch(
+  () => [props.metric, props.bucketTimestamp],
+  () => {
+    if (props.open) fetchDrilldown();
+  }
+);
+
+onBeforeUnmount(() => {
+  restoreFocus();
+});
+</script>
+
+<template>
+  <TeleportWithDirection to="body">
+    <Transition name="report-drilldown-fade">
+      <div
+        v-if="isOpen"
+        class="fixed inset-0 z-50 bg-black/30"
+        role="presentation"
+        @click.self="closeDrawer"
+      >
+        <aside
+          ref="drawerRef"
+          class="fixed inset-y-0 end-0 flex w-full max-w-xl flex-col bg-n-solid-1 shadow-xl outline outline-1 outline-n-container"
+          role="dialog"
+          aria-modal="true"
+          :aria-label="title"
+          tabindex="-1"
+        >
+          <header
+            class="flex items-start justify-between gap-4 border-b border-n-weak px-6 py-5"
+          >
+            <div class="min-w-0">
+              <h2 class="truncate text-base font-medium text-n-slate-12">
+                {{ title }}
+              </h2>
+              <p
+                v-if="bucketValue"
+                class="mt-1 text-xl font-semibold text-n-slate-12"
+              >
+                {{ bucketValue }}
+              </p>
+              <div
+                class="text-sm text-n-slate-11"
+                :class="{
+                  'mt-2': bucketValue,
+                  'mt-1': !bucketValue,
+                }"
+              >
+                {{ subtitle }}
+              </div>
+            </div>
+            <div class="flex shrink-0 items-center gap-1">
+              <Button
+                ghost
+                slate
+                size="sm"
+                icon="i-ph-caret-left"
+                class="rtl:rotate-180"
+                :disabled="!canPrev"
+                :aria-label="$t('REPORT.DRILLDOWN.PREVIOUS_BUCKET')"
+                @click="navigate(-1)"
+              />
+              <Button
+                ghost
+                slate
+                size="sm"
+                icon="i-ph-caret-right"
+                class="rtl:rotate-180"
+                :disabled="!canNext"
+                :aria-label="$t('REPORT.DRILLDOWN.NEXT_BUCKET')"
+                @click="navigate(1)"
+              />
+              <Button
+                ghost
+                slate
+                size="sm"
+                icon="i-ph-x"
+                :aria-label="$t('REPORT.DRILLDOWN.CLOSE')"
+                @click="closeDrawer"
+              />
+            </div>
+          </header>
+
+          <div class="min-h-0 flex-1 overflow-y-auto px-5 py-3">
+            <div
+              v-if="isFetching"
+              class="flex h-40 items-center justify-center"
+            >
+              <Spinner />
+            </div>
+
+            <div
+              v-else-if="hasError"
+              class="flex h-40 items-center justify-center text-sm text-n-ruby-11"
+            >
+              {{ $t('REPORT.DRILLDOWN.ERROR') }}
+            </div>
+
+            <div
+              v-else-if="!hasRecords"
+              class="flex h-40 items-center justify-center text-sm text-n-slate-10"
+            >
+              {{ $t('REPORT.DRILLDOWN.EMPTY') }}
+            </div>
+
+            <div v-else class="flex flex-col gap-2">
+              <ReportDrilldownCard
+                v-for="record in records"
+                :key="recordKey(record)"
+                :record="record"
+              />
+
+              <Button
+                v-if="hasMore"
+                faded
+                slate
+                size="sm"
+                class="mx-auto mt-2"
+                :label="$t('REPORT.DRILLDOWN.LOAD_MORE')"
+                :is-loading="isFetchingMore"
+                @click="loadMore"
+              />
+            </div>
+          </div>
+        </aside>
+      </div>
+    </Transition>
+  </TeleportWithDirection>
+</template>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/components/WootReports.vue b/app/javascript/dashboard/routes/dashboard/settings/reports/components/WootReports.vue
index e54c9f53e..7b30ee128 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/reports/components/WootReports.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/components/WootReports.vue
@@ -69,6 +69,9 @@ export default {
     isAgentType() {
       return this.type === 'agent';
     },
+    selectedFilterId() {
+      return this.selectedFilter?.id || null;
+    },
     reportKeys() {
       return {
         CONVERSATIONS: 'conversations_count',
@@ -181,5 +184,10 @@ export default {
     v-if="filterItemsList.length"
     :group-by="groupBy"
     :report-keys="reportKeys"
+    :from="from"
+    :to="to"
+    :report-type="type"
+    :selected-item-id="selectedFilterId"
+    :business-hours="businessHours"
   />
 </template>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/components/specs/ReportDrilldownCard.spec.js b/app/javascript/dashboard/routes/dashboard/settings/reports/components/specs/ReportDrilldownCard.spec.js
new file mode 100644
index 000000000..7fda49a36
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/components/specs/ReportDrilldownCard.spec.js
@@ -0,0 +1,195 @@
+import { mount } from '@vue/test-utils';
+import ReportDrilldownCard from '../ReportDrilldownCard.vue';
+
+vi.mock('vue-router', () => ({
+  useRoute: () => ({
+    params: {
+      accountId: 1,
+    },
+  }),
+}));
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({
+    t: (key, params = {}) => {
+      if (key === 'REPORT.DRILLDOWN.MESSAGE_CREATED_AT') {
+        return `Message created at ${params.time}`;
+      }
+      if (key === 'REPORT.DRILLDOWN.EVENT_OCCURRED_AT') {
+        return `Event occurred at ${params.time}`;
+      }
+      if (key === 'REPORT.DRILLDOWN.INCOMING_MESSAGE') {
+        return 'Incoming message';
+      }
+      if (key === 'REPORT.DRILLDOWN.OUTGOING_MESSAGE') {
+        return 'Outgoing message';
+      }
+      return key;
+    },
+  }),
+}));
+
+vi.mock('shared/helpers/timeHelper', () => ({
+  dynamicTime: timestamp => {
+    const timestamps = {
+      1621103500: '2 minutes ago',
+      1621103400: '4 days ago',
+      1621103700: '4 days ago',
+    };
+    return timestamps[timestamp] || 'less than a minute ago';
+  },
+  shortTimestamp: time => {
+    const timestamps = {
+      '2 minutes ago': '2m',
+      '4 days ago': '4d',
+    };
+    return timestamps[time] || 'now';
+  },
+  dateFormat: timestamp => `date-${timestamp}`,
+}));
+
+describe('ReportDrilldownCard.vue', () => {
+  const record = {
+    record_type: 'message',
+    conversation: {
+      id: 10,
+      display_id: 42,
+      contact_id: 11,
+      contact_name: 'Jane',
+      inbox_id: 12,
+      inbox_name: 'Website',
+      assignee_id: 13,
+      assignee_name: 'Alex',
+      status: 'open',
+      created_at: 1621103400,
+      last_activity_at: 1621103700,
+      last_message: {
+        id: 100,
+        content: 'Latest reply',
+        message_type: 'outgoing',
+        created_at: 1621103600,
+      },
+    },
+    message: {
+      id: 99,
+      content: 'Need help',
+      message_type: 'incoming',
+      created_at: 1621103500,
+    },
+    metric_value: null,
+    occurred_at: 1621103500,
+  };
+
+  const mountCard = (props = {}) =>
+    mount(ReportDrilldownCard, {
+      props: {
+        record,
+        ...props,
+      },
+      global: {
+        mocks: {
+          $t: key => key,
+        },
+      },
+    });
+
+  beforeEach(() => {
+    vi.spyOn(window, 'open').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+  });
+
+  it('opens the card conversation link in a new tab', async () => {
+    const wrapper = mountCard();
+
+    expect(wrapper.text()).toContain('#42');
+    expect(wrapper.text()).toContain('Need help');
+    expect(wrapper.find('.i-lucide-arrow-down-left').exists()).toBe(true);
+    expect(wrapper.find('[aria-label="Incoming message"]').exists()).toBe(true);
+
+    await wrapper.find('[role="link"]').trigger('click');
+
+    expect(window.open).toHaveBeenCalledWith(
+      '/app/accounts/1/conversations/42?messageId=99',
+      '_blank',
+      'noopener,noreferrer'
+    );
+  });
+
+  it('renders only message created timestamp for message rows', () => {
+    const wrapper = mountCard();
+    const messageCreatedLabel = wrapper
+      .findAll('[aria-label]')
+      .map(timestamp => timestamp.attributes('aria-label'))
+      .find(label => label.includes('Message created at'));
+
+    expect(wrapper.text()).toContain('2m');
+    expect(wrapper.text()).not.toContain('4d • 4d');
+    expect(messageCreatedLabel).toContain('Message created at');
+  });
+
+  it('renders separate contact, inbox, and agent links', async () => {
+    const wrapper = mountCard();
+    const links = wrapper.findAll('a');
+
+    expect(links.map(link => link.attributes('href'))).toEqual([
+      '/app/accounts/1/contacts/11',
+      '/app/accounts/1/inbox/12',
+      '/app/accounts/1/reports/agents/13',
+    ]);
+    expect(links.every(link => link.attributes('target') === '_blank')).toBe(
+      true
+    );
+    expect(
+      links.every(link => link.classes().includes('text-n-slate-10'))
+    ).toBe(true);
+    expect(
+      links.every(link => !link.classes().includes('text-n-blue-11'))
+    ).toBe(true);
+    expect(wrapper.find('.i-lucide-contact').exists()).toBe(true);
+    expect(wrapper.find('.i-lucide-inbox').exists()).toBe(true);
+    expect(wrapper.find('.i-lucide-user-round').exists()).toBe(true);
+
+    await links[0].trigger('click');
+
+    expect(window.open).not.toHaveBeenCalled();
+  });
+
+  it('renders the last message for conversation rows', () => {
+    const wrapper = mountCard({
+      record: {
+        ...record,
+        record_type: 'conversation',
+        message: null,
+        occurred_at: 1621103500,
+      },
+    });
+
+    expect(wrapper.text()).toContain('Latest reply');
+    expect(wrapper.text()).toContain('4d • 4d');
+  });
+
+  it('renders event time alongside TimeAgo for event-backed conversation rows', () => {
+    const wrapper = mountCard({
+      record: {
+        ...record,
+        record_type: 'conversation',
+        message: null,
+        event_name: 'conversation_bot_handoff',
+        occurred_at: 1621103500,
+      },
+    });
+    const eventOccurredLabel = wrapper
+      .findAll('[aria-label]')
+      .map(timestamp => timestamp.attributes('aria-label'))
+      .find(label => label.includes('Event occurred at'));
+
+    expect(wrapper.text()).toContain('Latest reply');
+    expect(wrapper.text()).toContain('4d • 4d');
+    expect(wrapper.text()).toContain('2m');
+    expect(eventOccurredLabel).toContain('Event occurred at');
+  });
+});
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/components/specs/ReportDrilldownDrawer.spec.js b/app/javascript/dashboard/routes/dashboard/settings/reports/components/specs/ReportDrilldownDrawer.spec.js
new file mode 100644
index 000000000..10bc38bee
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/components/specs/ReportDrilldownDrawer.spec.js
@@ -0,0 +1,352 @@
+import { flushPromises, mount } from '@vue/test-utils';
+import { nextTick } from 'vue';
+import { formatTime } from '@chatwoot/utils';
+import ReportsAPI from 'dashboard/api/reports';
+import ReportDrilldownDrawer from '../ReportDrilldownDrawer.vue';
+
+vi.mock('dashboard/api/reports', () => ({
+  default: {
+    getDrilldown: vi.fn(),
+  },
+}));
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({
+    t: (key, params = {}) => {
+      if (key === 'REPORT.DRILLDOWN.TITLE') {
+        return `${params.metric} details`;
+      }
+      if (key === 'REPORT.DRILLDOWN.RESULT_COUNT_CONVERSATION') {
+        return `${params.count} conversations`;
+      }
+      if (key === 'REPORT.DRILLDOWN.RESULT_COUNT_MESSAGE') {
+        return `${params.count} messages`;
+      }
+      return key;
+    },
+  }),
+}));
+
+describe('ReportDrilldownDrawer.vue', () => {
+  const request = {
+    metric: 'incoming_messages_count',
+    metricName: 'Messages received',
+    bucketLabel: '20-May',
+    bucketTimestamp: 1621103400,
+    from: 1621103400,
+    to: 1621621800,
+    type: 'account',
+    groupBy: 'day',
+    businessHours: false,
+  };
+
+  const payload = [
+    {
+      record_type: 'message',
+      conversation: {
+        id: 10,
+        display_id: 42,
+        contact_id: 11,
+        contact_name: 'Jane',
+        inbox_id: 12,
+        inbox_name: 'Website',
+        assignee_id: 13,
+        assignee_name: 'Alex',
+        status: 'open',
+        created_at: 1621103400,
+        last_activity_at: 1621103700,
+        last_message: {
+          id: 100,
+          content: 'Latest reply',
+          message_type: 'outgoing',
+          created_at: 1621103600,
+        },
+      },
+      message: {
+        id: 99,
+        content: 'Need help',
+        message_type: 'incoming',
+        created_at: 1621103500,
+      },
+      metric_value: null,
+      occurred_at: 1621103500,
+    },
+  ];
+
+  const mountDrawer = options =>
+    mount(ReportDrilldownDrawer, {
+      props: { open: true, ...request, ...options?.props },
+      attachTo: options?.attachTo,
+      global: {
+        stubs: {
+          TeleportWithDirection: {
+            template: '<div><slot /></div>',
+          },
+          Transition: false,
+          Spinner: true,
+          Button: {
+            props: ['label'],
+            emits: ['click'],
+            template:
+              '<button @click="$emit(\'click\')">{{ label }}<slot /></button>',
+          },
+          ReportDrilldownCard: {
+            props: ['record'],
+            template:
+              '<div data-testid="drilldown-card">#{{ record.conversation.display_id }}</div>',
+          },
+        },
+        mocks: {
+          $t: key => key,
+        },
+      },
+    });
+
+  beforeEach(() => {
+    ReportsAPI.getDrilldown.mockResolvedValue({
+      data: {
+        meta: {
+          total_count: 1,
+          current_page: 1,
+          record_type: 'message',
+          conversation_count: 1,
+        },
+        payload,
+      },
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+  });
+
+  it('loads and renders drilldown cards for the request', async () => {
+    const wrapper = mountDrawer();
+    await flushPromises();
+
+    expect(ReportsAPI.getDrilldown).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metric: 'incoming_messages_count',
+        bucketTimestamp: 1621103400,
+        page: 1,
+      })
+    );
+    expect(wrapper.text()).toContain('Messages received');
+    expect(wrapper.text()).toContain('1 conversations');
+    expect(wrapper.find('[data-testid="drilldown-card"]').text()).toBe('#42');
+  });
+
+  it('shows the bucket aggregate value for average metrics', async () => {
+    const wrapper = mountDrawer({
+      props: {
+        metric: 'avg_first_response_time',
+        metricName: 'First response time',
+        isAverageMetric: true,
+        bucketValue: 2580,
+      },
+    });
+    await flushPromises();
+
+    expect(wrapper.text()).toContain(formatTime(2580));
+  });
+
+  it('shows both conversation and message counts when they differ (reply time)', async () => {
+    ReportsAPI.getDrilldown.mockResolvedValue({
+      data: {
+        meta: {
+          total_count: 8,
+          current_page: 1,
+          record_type: 'message',
+          conversation_count: 5,
+        },
+        payload,
+      },
+    });
+    const wrapper = mountDrawer({
+      props: {
+        metric: 'reply_time',
+        isAverageMetric: true,
+        bucketValue: 2580,
+      },
+    });
+    await flushPromises();
+
+    expect(wrapper.text()).toContain('5 conversations');
+    expect(wrapper.text()).toContain('8 messages');
+  });
+
+  it('hides the message count when it matches the conversation count (first response time)', async () => {
+    ReportsAPI.getDrilldown.mockResolvedValue({
+      data: {
+        meta: {
+          total_count: 5,
+          current_page: 1,
+          record_type: 'message',
+          conversation_count: 5,
+        },
+        payload,
+      },
+    });
+    const wrapper = mountDrawer({
+      props: {
+        metric: 'avg_first_response_time',
+        isAverageMetric: true,
+        bucketValue: 2580,
+      },
+    });
+    await flushPromises();
+
+    expect(wrapper.text()).toContain('5 conversations');
+    expect(wrapper.text()).not.toContain('messages');
+  });
+
+  it('shows the plain count as the bucket value for count metrics', async () => {
+    const wrapper = mountDrawer({ props: { bucketValue: 128 } });
+    await flushPromises();
+
+    expect(wrapper.text()).toContain('128');
+    expect(wrapper.text()).not.toContain(formatTime(128));
+  });
+
+  it('hides the redundant subtitle count for conversation-count metrics', async () => {
+    ReportsAPI.getDrilldown.mockResolvedValue({
+      data: {
+        meta: {
+          total_count: 5,
+          current_page: 1,
+          record_type: 'conversation',
+          conversation_count: 5,
+        },
+        payload,
+      },
+    });
+    const wrapper = mountDrawer({
+      props: { metric: 'conversations_count', bucketValue: 5 },
+    });
+    await flushPromises();
+
+    expect(wrapper.text()).toContain('5');
+    expect(wrapper.text()).not.toContain('conversations');
+  });
+
+  it('keeps the subtitle count when it differs from the stat value', async () => {
+    ReportsAPI.getDrilldown.mockResolvedValue({
+      data: {
+        meta: {
+          total_count: 8,
+          current_page: 1,
+          record_type: 'conversation',
+          conversation_count: 5,
+        },
+        payload,
+      },
+    });
+    const wrapper = mountDrawer({
+      props: { metric: 'resolutions_count', bucketValue: 8 },
+    });
+    await flushPromises();
+
+    expect(wrapper.text()).toContain('5 conversations');
+  });
+
+  it('anchors the drawer to the inline-end edge so it flips in RTL', async () => {
+    const wrapper = mountDrawer();
+    await flushPromises();
+
+    const drawer = wrapper.get('[role="dialog"]');
+    expect(drawer.classes()).toContain('end-0');
+    expect(drawer.classes()).not.toContain('right-0');
+  });
+
+  it('flips the navigation caret icons in RTL', async () => {
+    const wrapper = mountDrawer({ props: { canPrev: true, canNext: true } });
+    await flushPromises();
+
+    expect(
+      wrapper.get('[aria-label="REPORT.DRILLDOWN.PREVIOUS_BUCKET"]').classes()
+    ).toContain('rtl:rotate-180');
+    expect(
+      wrapper.get('[aria-label="REPORT.DRILLDOWN.NEXT_BUCKET"]').classes()
+    ).toContain('rtl:rotate-180');
+  });
+
+  it('emits close when the drawer close button is clicked', async () => {
+    const wrapper = mountDrawer();
+    await flushPromises();
+
+    await wrapper.get('[aria-label="REPORT.DRILLDOWN.CLOSE"]').trigger('click');
+
+    expect(wrapper.emitted('close')).toBeTruthy();
+  });
+
+  it('emits navigate when the next button is clicked', async () => {
+    const wrapper = mountDrawer({ props: { canNext: true } });
+    await flushPromises();
+
+    await wrapper
+      .get('[aria-label="REPORT.DRILLDOWN.NEXT_BUCKET"]')
+      .trigger('click');
+
+    expect(wrapper.emitted('navigate')).toStrictEqual([[1]]);
+  });
+
+  it('does not emit navigate past the available range', async () => {
+    const wrapper = mountDrawer({ props: { canPrev: false } });
+    await flushPromises();
+
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowLeft' }));
+
+    expect(wrapper.emitted('navigate')).toBeUndefined();
+  });
+
+  it('moves focus into the drawer when opened', async () => {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    const wrapper = mountDrawer({ attachTo: target });
+    await flushPromises();
+    await nextTick();
+
+    expect(document.activeElement).toBe(
+      wrapper.find('[role="dialog"]').element
+    );
+
+    wrapper.unmount();
+    target.remove();
+  });
+
+  it('closes on Escape even when focus is outside the drawer', async () => {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    const wrapper = mountDrawer({ attachTo: target });
+    await flushPromises();
+
+    document.body.focus();
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }));
+
+    expect(wrapper.emitted('close')).toBeTruthy();
+
+    wrapper.unmount();
+    target.remove();
+  });
+
+  it('restores focus to the previously focused element when closed', async () => {
+    const opener = document.createElement('button');
+    const target = document.createElement('div');
+    document.body.appendChild(opener);
+    document.body.appendChild(target);
+    opener.focus();
+
+    const wrapper = mountDrawer({ attachTo: target });
+    await flushPromises();
+    await nextTick();
+
+    await wrapper.get('[aria-label="REPORT.DRILLDOWN.CLOSE"]').trigger('click');
+
+    expect(document.activeElement).toBe(opener);
+
+    wrapper.unmount();
+    target.remove();
+    opener.remove();
+  });
+});
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/composables/specs/useReportDrilldown.spec.js b/app/javascript/dashboard/routes/dashboard/settings/reports/composables/specs/useReportDrilldown.spec.js
new file mode 100644
index 000000000..b83742b9b
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/composables/specs/useReportDrilldown.spec.js
@@ -0,0 +1,124 @@
+import { flushPromises, mount } from '@vue/test-utils';
+import ReportsAPI from 'dashboard/api/reports';
+import { useReportDrilldown } from '../useReportDrilldown';
+
+vi.mock('dashboard/api/reports', () => ({
+  default: {
+    getDrilldown: vi.fn(),
+  },
+}));
+
+const deferredPromise = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+
+  return { promise, resolve, reject };
+};
+
+const drilldownRequest = overrides => ({
+  metric: 'conversations_count',
+  bucketTimestamp: 1,
+  from: 1621103400,
+  to: 1621621800,
+  type: 'account',
+  groupBy: 'day',
+  businessHours: false,
+  ...overrides,
+});
+
+describe('useReportDrilldown', () => {
+  const mountComposable = () =>
+    mount({
+      setup() {
+        return useReportDrilldown();
+      },
+      template: '<div />',
+    });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('does not request drilldown again for an identical active request', async () => {
+    const request = deferredPromise();
+    ReportsAPI.getDrilldown.mockReturnValue(request.promise);
+
+    const wrapper = mountComposable();
+    wrapper.vm.open(drilldownRequest());
+    wrapper.vm.open(drilldownRequest());
+
+    expect(ReportsAPI.getDrilldown).toHaveBeenCalledTimes(1);
+  });
+
+  it('aborts an in-flight request when a newer request is opened', async () => {
+    const firstRequest = deferredPromise();
+    const secondRequest = deferredPromise();
+    let firstSignal;
+
+    ReportsAPI.getDrilldown
+      .mockImplementationOnce(({ signal }) => {
+        firstSignal = signal;
+        return firstRequest.promise;
+      })
+      .mockReturnValueOnce(secondRequest.promise);
+
+    const wrapper = mountComposable();
+    wrapper.vm.open(drilldownRequest({ bucketTimestamp: 1 }));
+    wrapper.vm.open(drilldownRequest({ bucketTimestamp: 2 }));
+
+    expect(firstSignal.aborted).toBe(true);
+  });
+
+  it('passes an abort signal to drilldown requests', async () => {
+    const request = deferredPromise();
+    ReportsAPI.getDrilldown.mockReturnValue(request.promise);
+
+    const wrapper = mountComposable();
+    wrapper.vm.open(drilldownRequest());
+
+    expect(ReportsAPI.getDrilldown).toHaveBeenCalledWith(
+      expect.objectContaining({
+        page: 1,
+        signal: expect.any(AbortSignal),
+      })
+    );
+  });
+
+  it('ignores stale responses when a newer request is opened first', async () => {
+    const firstRequest = deferredPromise();
+    const secondRequest = deferredPromise();
+    ReportsAPI.getDrilldown
+      .mockReturnValueOnce(firstRequest.promise)
+      .mockReturnValueOnce(secondRequest.promise);
+
+    const wrapper = mountComposable();
+    wrapper.vm.open(drilldownRequest({ bucketTimestamp: 1 }));
+    wrapper.vm.open(drilldownRequest({ bucketTimestamp: 2 }));
+
+    secondRequest.resolve({
+      data: {
+        meta: { current_page: 1, total_count: 1 },
+        payload: [{ id: 'second' }],
+      },
+    });
+    await flushPromises();
+
+    expect(wrapper.vm.records).toEqual([{ id: 'second' }]);
+    expect(wrapper.vm.meta).toEqual({ current_page: 1, total_count: 1 });
+
+    firstRequest.resolve({
+      data: {
+        meta: { current_page: 1, total_count: 1 },
+        payload: [{ id: 'first' }],
+      },
+    });
+    await flushPromises();
+
+    expect(wrapper.vm.records).toEqual([{ id: 'second' }]);
+    expect(wrapper.vm.meta).toEqual({ current_page: 1, total_count: 1 });
+  });
+});
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/composables/useReportDrilldown.js b/app/javascript/dashboard/routes/dashboard/settings/reports/composables/useReportDrilldown.js
new file mode 100644
index 000000000..7c37cd9cc
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/composables/useReportDrilldown.js
@@ -0,0 +1,138 @@
+import { computed, ref } from 'vue';
+import ReportsAPI from 'dashboard/api/reports';
+
+export function useReportDrilldown() {
+  const activeRequest = ref(null);
+  const records = ref([]);
+  const meta = ref({});
+  const isFetching = ref(false);
+  const isFetchingMore = ref(false);
+  const hasError = ref(false);
+  let requestToken = 0;
+  let activeRequestController = null;
+  let activeRequestFingerprint = null;
+
+  const hasRecords = computed(() => records.value.length > 0);
+  const hasMore = computed(() => {
+    return records.value.length < (meta.value.total_count || 0);
+  });
+
+  const isCurrentRequest = token =>
+    token === requestToken && !!activeRequest.value;
+
+  const requestFingerprint = request =>
+    JSON.stringify({
+      metric: request.metric,
+      bucketTimestamp: request.bucketTimestamp,
+      from: request.from,
+      to: request.to,
+      type: request.type,
+      id: request.id,
+      groupBy: request.groupBy,
+      businessHours: request.businessHours,
+    });
+
+  const abortActiveRequest = () => {
+    if (!activeRequestController) return;
+
+    activeRequestController.abort();
+    activeRequestController = null;
+  };
+
+  const isAbortError = error =>
+    error?.name === 'AbortError' ||
+    error?.name === 'CanceledError' ||
+    error?.code === 'ERR_CANCELED';
+
+  const fetchPage = async (page, token = requestToken) => {
+    if (!activeRequest.value) return;
+
+    const request = activeRequest.value;
+    const controller = new AbortController();
+    const loadingState = page === 1 ? isFetching : isFetchingMore;
+    activeRequestController = controller;
+    loadingState.value = true;
+    hasError.value = false;
+
+    try {
+      const response = await ReportsAPI.getDrilldown({
+        ...request,
+        page,
+        signal: controller.signal,
+      });
+      if (!isCurrentRequest(token)) return;
+
+      meta.value = response.data.meta || {};
+      records.value =
+        page === 1
+          ? response.data.payload || []
+          : [...records.value, ...(response.data.payload || [])];
+    } catch (error) {
+      if (!isCurrentRequest(token) || isAbortError(error)) return;
+
+      hasError.value = true;
+    } finally {
+      if (activeRequestController === controller) {
+        activeRequestController = null;
+      }
+
+      if (isCurrentRequest(token)) {
+        loadingState.value = false;
+      }
+    }
+  };
+
+  const open = async request => {
+    const fingerprint = requestFingerprint(request);
+    if (activeRequestFingerprint === fingerprint) return;
+
+    abortActiveRequest();
+    requestToken += 1;
+    activeRequestFingerprint = fingerprint;
+    activeRequest.value = request;
+    records.value = [];
+    meta.value = {};
+    hasError.value = false;
+    isFetchingMore.value = false;
+    await fetchPage(1, requestToken);
+  };
+
+  const close = () => {
+    abortActiveRequest();
+    requestToken += 1;
+    activeRequestFingerprint = null;
+    activeRequest.value = null;
+    records.value = [];
+    meta.value = {};
+    hasError.value = false;
+    isFetching.value = false;
+    isFetchingMore.value = false;
+  };
+
+  const loadMore = () => {
+    if (
+      !activeRequest.value ||
+      !hasMore.value ||
+      isFetching.value ||
+      isFetchingMore.value
+    ) {
+      return;
+    }
+
+    fetchPage((meta.value.current_page || 1) + 1, requestToken);
+  };
+
+  return {
+    activeRequest,
+    records,
+    meta,
+    isFetching,
+    isFetchingMore,
+    hasError,
+    hasRecords,
+    hasMore,
+    open,
+    close,
+    loadMore,
+  };
+}
diff --git a/app/javascript/dashboard/routes/dashboard/settings/reports/specs/ReportContainer.spec.js b/app/javascript/dashboard/routes/dashboard/settings/reports/specs/ReportContainer.spec.js
new file mode 100644
index 000000000..b45102611
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/settings/reports/specs/ReportContainer.spec.js
@@ -0,0 +1,179 @@
+import { shallowMount } from '@vue/test-utils';
+import { useAlert } from 'dashboard/composables';
+import ReportContainer from '../ReportContainer.vue';
+
+vi.mock('dashboard/composables', () => ({
+  useAlert: vi.fn(),
+}));
+
+vi.mock('dashboard/composables/useReportMetrics', () => ({
+  useReportMetrics: () => ({
+    calculateTrend: () => 0,
+    isAverageMetricType: key =>
+      ['avg_first_response_time', 'avg_resolution_time', 'reply_time'].includes(
+        key
+      ),
+  }),
+}));
+
+describe('ReportContainer.vue', () => {
+  const mountComponent = ({
+    dataPoint = { value: 2, timestamp: 1621103400 },
+    data,
+    reportKey = 'conversations_count',
+    role = 'administrator',
+  } = {}) =>
+    shallowMount(ReportContainer, {
+      props: {
+        from: 1621103400,
+        to: 1621621800,
+        groupBy: { period: 'day' },
+        reportType: 'inbox',
+        selectedItemId: 1,
+        businessHours: true,
+        reportKeys: {
+          CONVERSATIONS: reportKey,
+        },
+      },
+      global: {
+        mocks: {
+          $t: key => key,
+          $store: {
+            getters: {
+              getAccountReports: {
+                isFetching: {
+                  [reportKey]: false,
+                },
+                data: {
+                  [reportKey]: data || [dataPoint],
+                },
+              },
+              getCurrentRole: role,
+            },
+          },
+        },
+        stubs: {
+          ChartStats: true,
+          ReportDrilldownDrawer: {
+            name: 'ReportDrilldownDrawer',
+            props: [
+              'open',
+              'metric',
+              'metricName',
+              'bucketLabel',
+              'bucketTimestamp',
+              'bucketValue',
+              'isAverageMetric',
+              'from',
+              'to',
+              'type',
+              'id',
+              'groupBy',
+              'businessHours',
+              'canPrev',
+              'canNext',
+            ],
+            emits: ['navigate', 'close'],
+            template: '<div />',
+          },
+          BarChart: {
+            name: 'BarChart',
+            props: ['collection', 'chartOptions', 'clickable'],
+            emits: ['elementClick'],
+            template:
+              '<button data-test-id="bar-chart" @click="$emit(\'elementClick\', { dataIndex: 0, label: \'20-May\', value: 2 })" />',
+          },
+        },
+      },
+    });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('opens a drilldown request with report context when a non-zero bar is clicked', async () => {
+    const wrapper = mountComponent();
+
+    await wrapper.find('[data-test-id="bar-chart"]').trigger('click');
+
+    const drawer = wrapper.findComponent({ name: 'ReportDrilldownDrawer' });
+    expect(drawer.props('open')).toBe(true);
+    expect(drawer.props()).toMatchObject({
+      metric: 'conversations_count',
+      metricName: 'REPORT.METRICS.CONVERSATIONS.NAME',
+      bucketLabel: '15-May',
+      bucketTimestamp: 1621103400,
+      from: 1621103400,
+      to: 1621621800,
+      type: 'inbox',
+      id: 1,
+      groupBy: 'day',
+      businessHours: true,
+    });
+  });
+
+  it('shows an alert and does not open drilldown for non-admin users', async () => {
+    const wrapper = mountComponent({ role: 'agent' });
+
+    await wrapper.find('[data-test-id="bar-chart"]').trigger('click');
+
+    expect(useAlert).toHaveBeenCalledWith('REPORT.DRILLDOWN.ADMIN_ONLY');
+    expect(
+      wrapper.findComponent({ name: 'ReportDrilldownDrawer' }).props('open')
+    ).toBe(false);
+  });
+
+  it('does not open drilldown for zero-value count bars', async () => {
+    const wrapper = mountComponent({
+      dataPoint: { value: 0, timestamp: 1621103400 },
+    });
+
+    await wrapper.find('[data-test-id="bar-chart"]').trigger('click');
+
+    expect(
+      wrapper.findComponent({ name: 'ReportDrilldownDrawer' }).props('open')
+    ).toBe(false);
+  });
+
+  it('opens average metric drilldown when the bucket has contributing records', async () => {
+    const wrapper = mountComponent({
+      reportKey: 'avg_first_response_time',
+      dataPoint: { value: 90, count: 2, timestamp: 1621103400 },
+    });
+
+    await wrapper.find('[data-test-id="bar-chart"]').trigger('click');
+
+    const drawer = wrapper.findComponent({ name: 'ReportDrilldownDrawer' });
+    expect(drawer.props('open')).toBe(true);
+    expect(drawer.props()).toMatchObject({
+      metric: 'avg_first_response_time',
+      bucketTimestamp: 1621103400,
+    });
+  });
+
+  it('navigates to adjacent drillable buckets within the report range', async () => {
+    const wrapper = mountComponent({
+      data: [
+        { value: 2, timestamp: 1621103400 },
+        { value: 0, timestamp: 1621189800 },
+        { value: 5, timestamp: 1621276200 },
+      ],
+    });
+
+    await wrapper.find('[data-test-id="bar-chart"]').trigger('click');
+
+    const drawer = wrapper.findComponent({ name: 'ReportDrilldownDrawer' });
+    // Opened on the first bucket: no previous, but a later drillable bucket exists.
+    expect(drawer.props('bucketTimestamp')).toBe(1621103400);
+    expect(drawer.props('canPrev')).toBe(false);
+    expect(drawer.props('canNext')).toBe(true);
+
+    // Skips the zero-value middle bucket and lands on the last drillable one.
+    drawer.vm.$emit('navigate', 1);
+    await wrapper.vm.$nextTick();
+
+    expect(drawer.props('bucketTimestamp')).toBe(1621276200);
+    expect(drawer.props('canPrev')).toBe(true);
+    expect(drawer.props('canNext')).toBe(false);
+  });
+});
diff --git a/app/javascript/dashboard/store/modules/accounts.js b/app/javascript/dashboard/store/modules/accounts.js
index 68fd37010..603290564 100644
--- a/app/javascript/dashboard/store/modules/accounts.js
+++ b/app/javascript/dashboard/store/modules/accounts.js
@@ -144,7 +144,20 @@ export const actions = {
   subscription: async ({ commit }) => {
     commit(types.default.SET_ACCOUNT_UI_FLAG, { isCheckoutInProcess: true });
     try {
-      await EnterpriseAccountAPI.subscription();
+      const response = await EnterpriseAccountAPI.subscription();
+      return response.data;
+    } catch (error) {
+      throwErrorMessage(error);
+      return null;
+    } finally {
+      commit(types.default.SET_ACCOUNT_UI_FLAG, { isCheckoutInProcess: false });
+    }
+  },
+
+  selectBillingCurrency: async ({ commit }, currency) => {
+    commit(types.default.SET_ACCOUNT_UI_FLAG, { isCheckoutInProcess: true });
+    try {
+      await EnterpriseAccountAPI.selectBillingCurrency(currency);
     } catch (error) {
       throwErrorMessage(error);
     } finally {
diff --git a/app/javascript/dashboard/store/modules/helpCenterArticles/actions.js b/app/javascript/dashboard/store/modules/helpCenterArticles/actions.js
index 85449b174..7dd42e749 100644
--- a/app/javascript/dashboard/store/modules/helpCenterArticles/actions.js
+++ b/app/javascript/dashboard/store/modules/helpCenterArticles/actions.js
@@ -157,11 +157,13 @@ export const actions = {
     // Update positions in the store immediately so subsequent mutations preserve correct positions
     commit(types.SET_ARTICLE_POSITIONS, reorderedGroup);
     try {
-      await articlesAPI.reorderArticles({
+      const { data } = await articlesAPI.reorderArticles({
         portalSlug,
         reorderedGroup,
         categorySlug,
       });
+      // Adopt the backend's re-spaced positions so the next reorder isn't computed from stale local values.
+      if (data?.positions) commit(types.SET_ARTICLE_POSITIONS, data.positions);
     } catch (error) {
       commit(types.SET_ARTICLE_POSITIONS, oldPositions);
       throw error;
diff --git a/app/javascript/dashboard/store/modules/helpCenterArticles/specs/action.spec.js b/app/javascript/dashboard/store/modules/helpCenterArticles/specs/action.spec.js
index 064345694..6517f44fd 100644
--- a/app/javascript/dashboard/store/modules/helpCenterArticles/specs/action.spec.js
+++ b/app/javascript/dashboard/store/modules/helpCenterArticles/specs/action.spec.js
@@ -314,6 +314,25 @@ describe('#actions', () => {
       );
     });
 
+    it('adopts the backend re-spaced positions when the response returns them', async () => {
+      const serverPositions = { 1: 10, 2: 30, 3: 20 };
+      axios.post.mockResolvedValue({ data: { positions: serverPositions } });
+
+      await actions.reorder(
+        { commit, state },
+        {
+          portalSlug: 'test-portal',
+          categorySlug: 'test-category',
+          reorderedGroup: { 3: 25 },
+        }
+      );
+
+      expect(commit).toHaveBeenCalledWith(
+        types.default.SET_ARTICLE_POSITIONS,
+        serverPositions
+      );
+    });
+
     it('rolls back positions and throws when API call fails', async () => {
       axios.post.mockRejectedValue({ message: 'Network error' });
       const reorderedGroup = { 1: 1, 2: 2 };
diff --git a/app/javascript/shared/components/charts/BarChart.vue b/app/javascript/shared/components/charts/BarChart.vue
index dd01e586d..5baa856e8 100644
--- a/app/javascript/shared/components/charts/BarChart.vue
+++ b/app/javascript/shared/components/charts/BarChart.vue
@@ -19,8 +19,14 @@ const props = defineProps({
     type: Object,
     default: () => ({}),
   },
+  clickable: {
+    type: Boolean,
+    default: false,
+  },
 });
 
+const emit = defineEmits(['elementClick']);
+
 ChartJS.register(Title, Tooltip, BarElement, CategoryScale, LinearScale);
 
 const fontFamily =
@@ -67,8 +73,39 @@ const defaultChartOptions = {
   },
 };
 
+const handleClick = (event, elements, chart) => {
+  props.chartOptions.onClick?.(event, elements, chart);
+
+  if (!props.clickable || !elements.length) return;
+
+  const { datasetIndex, index } = elements[0];
+  const dataset = props.collection.datasets?.[datasetIndex] || {};
+
+  emit('elementClick', {
+    datasetIndex,
+    dataIndex: index,
+    dataset,
+    label: props.collection.labels?.[index],
+    value: dataset.data?.[index],
+  });
+};
+
+const handleHover = (event, elements, chart) => {
+  props.chartOptions.onHover?.(event, elements, chart);
+
+  if (!event?.native?.target) return;
+
+  event.native.target.style.cursor =
+    props.clickable && elements.length ? 'pointer' : 'default';
+};
+
 const options = computed(() => {
-  return { ...defaultChartOptions, ...props.chartOptions };
+  return {
+    ...defaultChartOptions,
+    ...props.chartOptions,
+    onClick: handleClick,
+    onHover: handleHover,
+  };
 });
 </script>
 
diff --git a/app/javascript/shared/components/specs/BarChart.spec.js b/app/javascript/shared/components/specs/BarChart.spec.js
new file mode 100644
index 000000000..dc2774ace
--- /dev/null
+++ b/app/javascript/shared/components/specs/BarChart.spec.js
@@ -0,0 +1,52 @@
+import { shallowMount } from '@vue/test-utils';
+import BarChart from '../charts/BarChart.vue';
+
+vi.mock('vue-chartjs', () => ({
+  Bar: {
+    name: 'Bar',
+    props: ['data', 'options'],
+    template: '<canvas />',
+  },
+}));
+
+describe('BarChart.vue', () => {
+  it('emits the clicked chart element when clickable', () => {
+    const wrapper = shallowMount(BarChart, {
+      props: {
+        clickable: true,
+        collection: {
+          labels: ['20-May'],
+          datasets: [{ type: 'bar', data: [3] }],
+        },
+      },
+    });
+
+    const options = wrapper.findComponent({ name: 'Bar' }).props('options');
+    options.onClick({}, [{ datasetIndex: 0, index: 0 }], {});
+
+    expect(wrapper.emitted('elementClick')[0][0]).toEqual({
+      datasetIndex: 0,
+      dataIndex: 0,
+      dataset: { type: 'bar', data: [3] },
+      label: '20-May',
+      value: 3,
+    });
+  });
+
+  it('does not emit when chart is not clickable', () => {
+    const wrapper = shallowMount(BarChart, {
+      props: {
+        clickable: false,
+        collection: {
+          labels: ['20-May'],
+          datasets: [{ type: 'bar', data: [3] }],
+        },
+      },
+    });
+
+    const options = wrapper.findComponent({ name: 'Bar' }).props('options');
+    options.onClick({}, [{ datasetIndex: 0, index: 0 }], {});
+
+    expect(wrapper.emitted('elementClick')).toBeUndefined();
+  });
+});
diff --git a/app/models/article.rb b/app/models/article.rb
index a04ca05fe..9d1247e8b 100644
--- a/app/models/article.rb
+++ b/app/models/article.rb
@@ -137,15 +137,41 @@ class Article < ApplicationRecord
   end
 
   def self.update_positions(portal:, positions_hash:)
-    return if positions_hash.blank?
+    return {} if positions_hash.blank?
+
+    moved_ids = positions_hash.keys.map(&:to_i)
 
     transaction do
       positions_hash.each do |article_id, new_position|
         portal.articles.find(article_id).update!(position: new_position)
       end
+      # Re-space touched categories to clean gaps and return the final positions
+      rebalance_positions(portal, moved_ids)
     end
   end
 
+  def self.rebalance_positions(portal, moved_ids)
+    category_ids = portal.articles.where(id: moved_ids).distinct.pluck(:category_id).compact
+    category_ids.each_with_object({}) do |category_id, positions|
+      resequence_category(portal, category_id, moved_ids, positions)
+    end
+  end
+
+  def self.resequence_category(portal, category_id, moved_ids, positions)
+    ordered = portal.articles.where(category_id: category_id)
+                    .sort_by { |article| [article.position || 0, moved_ids.include?(article.id) ? 1 : 0, article.id] }
+    return if ordered.length < 2 # a lone article can't collide, leave it as-is
+
+    ordered.each_with_index do |article, index|
+      new_position = (index + 1) * 10
+      positions[article.id] = new_position
+      next if article.position == new_position
+
+      article.update_column(:position, new_position) # rubocop:disable Rails/SkipsModelValidations
+    end
+  end
+  private_class_method :rebalance_positions, :resequence_category
+
   private
 
   def category_id_changed_action
diff --git a/app/policies/account_policy.rb b/app/policies/account_policy.rb
index bd7b3cefe..18b8216f7 100644
--- a/app/policies/account_policy.rb
+++ b/app/policies/account_policy.rb
@@ -23,6 +23,10 @@ class AccountPolicy < ApplicationPolicy
     @account_user.administrator?
   end
 
+  def select_billing_currency?
+    @account_user.administrator?
+  end
+
   def checkout?
     @account_user.administrator?
   end
@@ -34,4 +38,8 @@ class AccountPolicy < ApplicationPolicy
   def topup_checkout?
     @account_user.administrator?
   end
+
+  def topup_options?
+    @account_user.administrator?
+  end
 end
diff --git a/app/services/reports/drilldown_timestamp_validator.rb b/app/services/reports/drilldown_timestamp_validator.rb
new file mode 100644
index 000000000..d6371c2d9
--- /dev/null
+++ b/app/services/reports/drilldown_timestamp_validator.rb
@@ -0,0 +1,53 @@
+module Reports::DrilldownTimestampValidator
+  extend TimezoneHelper
+
+  TIMESTAMP_PARAMS = %i[bucket_timestamp since until].freeze
+  DEFAULT_GROUP_BY = V2::Reports::DrilldownBuilder::DEFAULT_GROUP_BY
+  SUPPORTED_GROUP_BY = V2::Reports::DrilldownBuilder::SUPPORTED_GROUP_BY
+
+  module_function
+
+  def valid?(params)
+    timestamps = TIMESTAMP_PARAMS.index_with { |param| integer_param(params[param]) }
+    return false if timestamps.values.any?(&:nil?)
+    return false unless timestamps[:since] < timestamps[:until]
+
+    bucket_overlaps_requested_range?(params, timestamps)
+  end
+
+  def integer_param(value)
+    return unless value.to_s.match?(/\A\d+\z/)
+
+    value.to_i
+  end
+
+  def bucket_overlaps_requested_range?(params, timestamps)
+    bucket_start = Time.zone.at(timestamps[:bucket_timestamp]).in_time_zone(timezone(params))
+    bucket_end = bucket_end_for(bucket_start, group_by(params))
+    requested_start = Time.zone.at(timestamps[:since])
+    requested_end = Time.zone.at(timestamps[:until])
+
+    bucket_start < requested_end && bucket_end > requested_start
+  rescue ArgumentError, RangeError
+    false
+  end
+
+  def bucket_end_for(bucket_start, group_by)
+    {
+      'hour' => bucket_start + 1.hour,
+      'day' => bucket_start + 1.day,
+      'week' => bucket_start + 1.week,
+      'month' => bucket_start + 1.month,
+      'year' => bucket_start + 1.year
+    }.fetch(group_by)
+  end
+
+  def group_by(params)
+    group = params[:group_by].to_s
+    SUPPORTED_GROUP_BY.include?(group) ? group : DEFAULT_GROUP_BY
+  end
+
+  def timezone(params)
+    timezone_name_from_offset(params[:timezone_offset])
+  end
+end
diff --git a/app/views/api/v1/conversations/partials/_conversation.json.jbuilder b/app/views/api/v1/conversations/partials/_conversation.json.jbuilder
index 4cb13f543..5fdd4ecee 100644
--- a/app/views/api/v1/conversations/partials/_conversation.json.jbuilder
+++ b/app/views/api/v1/conversations/partials/_conversation.json.jbuilder
@@ -58,5 +58,6 @@ json.last_non_activity_message conversation.messages.where(account_id: conversat
 json.last_activity_at conversation.last_activity_at.to_i
 json.priority conversation.priority
 json.waiting_since conversation.waiting_since.to_i.to_i
-json.sla_policy_id conversation.sla_policy_id
+sla_applicable = !conversation.respond_to?(:sla_applicable?) || conversation.sla_applicable?
+json.sla_policy_id sla_applicable ? conversation.sla_policy_id : nil
 json.partial! 'enterprise/api/v1/conversations/partials/conversation', conversation: conversation if ChatwootApp.enterprise?
diff --git a/app/views/api/v1/models/_account.json.jbuilder b/app/views/api/v1/models/_account.json.jbuilder
index 02b3480d5..95beee1fa 100644
--- a/app/views/api/v1/models/_account.json.jbuilder
+++ b/app/views/api/v1/models/_account.json.jbuilder
@@ -6,6 +6,7 @@ if resource.custom_attributes.present?
     json.subscribed_quantity resource.custom_attributes['subscribed_quantity']
     json.subscription_status resource.custom_attributes['subscription_status']
     json.subscription_ends_on resource.custom_attributes['subscription_ends_on']
+    json.billing_currency resource.billing_currency if resource.respond_to?(:billing_currency) && Enterprise::Billing::Currencies.enabled?
     json.website resource.custom_attributes['website'] if resource.custom_attributes['website'].present?
     json.industry resource.custom_attributes['industry'] if resource.custom_attributes['industry'].present?
     json.company_size resource.custom_attributes['company_size'] if resource.custom_attributes['company_size'].present?
diff --git a/config/initializers/rack_attack.rb b/config/initializers/rack_attack.rb
index ca818c080..e08a6a6e1 100644
--- a/config/initializers/rack_attack.rb
+++ b/config/initializers/rack_attack.rb
@@ -224,8 +224,30 @@ class Rack::Attack
     match_data[:account_id] if match_data.present?
   end
 
+  reports_api_user_level_limit = ENV.fetch('RATE_LIMIT_REPORTS_API_USER_LEVEL', '100').to_i
+  reports_drilldown_api_user_level_limit = ENV.fetch(
+    'RATE_LIMIT_REPORTS_DRILLDOWN_API_USER_LEVEL',
+    [(reports_api_user_level_limit / 10), 1].max
+  ).to_i
+
+  # Throttle drilldown requests by individual user (based on uid)
+  throttle('/api/v2/accounts/:account_id/reports/drilldown/user',
+           limit: reports_drilldown_api_user_level_limit, period: 1.minute) do |req|
+    match_data = %r{\A/api/v2/accounts/(?<account_id>\d+)/reports/drilldown\z}.match(req.path_without_extensions)
+    next unless match_data.present? && req.get?
+
+    # Extract user identification (uid for web, api_access_token for API requests)
+    user_uid = req.get_header('HTTP_UID')
+    api_access_token = req.get_header('HTTP_API_ACCESS_TOKEN') || req.get_header('api_access_token')
+
+    # Use uid if present, otherwise fallback to api_access_token for tracking
+    user_identifier = user_uid.presence || api_access_token.presence
+
+    "#{user_identifier}:#{match_data[:account_id]}" if user_identifier.present?
+  end
+
   # Throttle by individual user (based on uid)
-  throttle('/api/v2/accounts/:account_id/reports/user', limit: ENV.fetch('RATE_LIMIT_REPORTS_API_USER_LEVEL', '100').to_i, period: 1.minute) do |req|
+  throttle('/api/v2/accounts/:account_id/reports/user', limit: reports_api_user_level_limit, period: 1.minute) do |req|
     match_data = %r{/api/v2/accounts/(?<account_id>\d+)/reports}.match(req.path)
     # Extract user identification (uid for web, api_access_token for API requests)
     user_uid = req.get_header('HTTP_UID')
diff --git a/config/installation_config.yml b/config/installation_config.yml
index 43fc6bb97..cfe64767f 100644
--- a/config/installation_config.yml
+++ b/config/installation_config.yml
@@ -253,6 +253,17 @@
   display_title: 'Cloud Plans'
   value:
   description: 'Config to store stripe plans for cloud'
+- name: CAPTAIN_TOPUP_OPTIONS
+  display_title: 'Captain Topup Options'
+  value: {}
+  description: 'Currency-keyed AI credit top-up packages, e.g. {"usd":[{"credits":1000,"amount":20.0}],"brl":[{"credits":1000,"amount":100.0}]}'
+  type: code
+- name: ENABLE_MULTI_CURRENCY_BILLING
+  display_title: 'Enable Multi-currency Billing'
+  value: false
+  locked: false
+  description: 'Bill new accounts in their local currency (e.g. BRL) and show currency-aware credit top-ups; when off, everyone is billed in USD'
+  type: boolean
 - name: MARKETING_CONVERSION_TRACKING_CONFIG
   value:
   display_title: 'Marketing Conversion Tracking Config'
diff --git a/config/locales/en.yml b/config/locales/en.yml
index 22d3630af..7aafbef0a 100644
--- a/config/locales/en.yml
+++ b/config/locales/en.yml
@@ -134,6 +134,7 @@ en:
         not_supported: 'Reauthorization is not supported for this type of WhatsApp channel.'
       calls:
         not_enabled: 'Calling is not enabled for this inbox'
+        already_ended: 'This call has already ended'
         no_recording: 'No recording file provided'
         no_message: 'Call has no associated message'
         sdp_offer_required: 'sdp_offer is required'
@@ -172,6 +173,9 @@ en:
       invalid_token: Invalid or expired MFA token
       invalid_credentials: Invalid credentials or verification code
       feature_unavailable: MFA feature is not available. Please configure encryption keys.
+    billing:
+      invalid_currency: Invalid billing currency
+      currency_locked: Billing currency cannot be changed after billing has been set up
     topup:
       credits_required: Credits amount is required
       invalid_credits: Invalid credits amount
diff --git a/config/routes.rb b/config/routes.rb
index 64e1df440..e0a1a8e50 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -501,6 +501,7 @@ Rails.application.routes.draw do
               get :conversations
               get :conversations_summary
               get :conversation_traffic
+              get :drilldown
               get :bot_metrics
               get :inbox_label_matrix
               get :first_response_time_distribution
@@ -527,9 +528,11 @@ Rails.application.routes.draw do
             member do
               post :checkout
               post :subscription
+              post :select_billing_currency
               get :limits
               post :toggle_deletion
               post :topup_checkout
+              get :topup_options
             end
           end
         end
diff --git a/enterprise/app/controllers/api/v1/accounts/applied_slas_controller.rb b/enterprise/app/controllers/api/v1/accounts/applied_slas_controller.rb
index e195686a3..1ca3c015e 100644
--- a/enterprise/app/controllers/api/v1/accounts/applied_slas_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/applied_slas_controller.rb
@@ -47,7 +47,7 @@ class Api::V1::Accounts::AppliedSlasController < Api::V1::Accounts::EnterpriseAc
   end
 
   def set_applied_slas
-    initial_query = Current.account.applied_slas.includes(:conversation)
+    initial_query = Current.account.applied_slas.with_sla_applicable_conversation.includes(:conversation)
     @applied_slas = apply_filters(initial_query)
   end
 
diff --git a/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb b/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb
index 0301d428b..a0627ce49 100644
--- a/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb
@@ -13,6 +13,7 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
               Voice::CallErrors::AlreadyAccepted,
               Voice::CallErrors::CallFailed,
               with: :render_call_error
+  rescue_from Voice::CallErrors::CallAlreadyEnded, with: :render_call_ended
   rescue_from Voice::CallErrors::NoCallPermission, with: :render_permission_request
 
   def show; end
@@ -105,9 +106,14 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
 
   def create_outbound_call
     contact_phone = @conversation.contact.phone_number.delete('+')
+    # Claim for the caller only if unassigned at trigger time (before the round-trip); wins over auto-assignment.
+    claim_for_caller = @conversation.assignee_id.nil?
+
     result = provider_service.initiate_call(contact_phone, params[:sdp_offer])
     provider_call_id = result.dig('calls', 0, 'id') || result['call_id']
 
+    @conversation.with_lock { @conversation.update!(assignee: Current.user) } if claim_for_caller
+
     Current.account.calls.create!(
       provider: :whatsapp, inbox: @conversation.inbox, conversation: @conversation, contact: @conversation.contact,
       provider_call_id: provider_call_id, direction: :outgoing, status: 'ringing',
@@ -190,4 +196,9 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
   def render_call_error(error)
     render_could_not_create_error(error.message)
   end
+
+  # 409 (not 422) so the FE can tell "already ended" from a generic failure and dismiss the ringing UI.
+  def render_call_ended
+    render json: { error: I18n.t('errors.whatsapp.calls.already_ended') }, status: :conflict
+  end
 end
diff --git a/enterprise/app/controllers/enterprise/api/v1/accounts_controller.rb b/enterprise/app/controllers/enterprise/api/v1/accounts_controller.rb
index d176db597..621a508e4 100644
--- a/enterprise/app/controllers/enterprise/api/v1/accounts_controller.rb
+++ b/enterprise/app/controllers/enterprise/api/v1/accounts_controller.rb
@@ -2,13 +2,24 @@ class Enterprise::Api::V1::AccountsController < Api::BaseController
   include BillingHelper
   before_action :fetch_account
   before_action :check_authorization
-  before_action :check_cloud_env, only: [:limits, :toggle_deletion]
+  before_action :check_cloud_env, only: [:limits, :toggle_deletion, :topup_options]
 
   def subscription
-    if stripe_customer_id.blank? && @account.custom_attributes['is_creating_customer'].blank?
-      @account.update(custom_attributes: { is_creating_customer: true })
-      Enterprise::CreateStripeCustomerJob.perform_later(@account)
-    end
+    return render json: currency_selection_payload if @account.billing_currency_selection_required?
+
+    ensure_stripe_customer
+    head :no_content
+  end
+
+  def select_billing_currency
+    return render_could_not_create_error(I18n.t('errors.billing.currency_locked')) if currency_locked?
+    return render_could_not_create_error(I18n.t('errors.billing.invalid_currency')) unless @account.billing_currency_selection_required?
+
+    currency = Enterprise::Billing::Currencies.normalize(params[:currency])
+    return render_could_not_create_error(I18n.t('errors.billing.invalid_currency')) unless Enterprise::Billing::Currencies.supported?(currency)
+
+    @account.update!(custom_attributes: @account.custom_attributes.merge('billing_currency' => currency))
+    ensure_stripe_customer
     head :no_content
   end
 
@@ -71,12 +82,32 @@ class Enterprise::Api::V1::AccountsController < Api::BaseController
     render_could_not_create_error(e.message)
   end
 
+  def topup_options
+    service = Enterprise::Billing::TopupCheckoutService.new(account: @account)
+    render json: { id: @account.id, currency: @account.billing_currency, options: service.available_options }
+  end
+
   private
 
   def check_cloud_env
     render json: { error: 'Not found' }, status: :not_found unless ChatwootApp.chatwoot_cloud?
   end
 
+  def ensure_stripe_customer
+    return if stripe_customer_id.present? || @account.custom_attributes['is_creating_customer'].present?
+
+    @account.update!(custom_attributes: @account.custom_attributes.merge('is_creating_customer' => true))
+    Enterprise::CreateStripeCustomerJob.perform_later(@account)
+  end
+
+  def currency_selection_payload
+    {
+      currency_selection_required: true,
+      currency_options: Enterprise::Billing::Currencies::SUPPORTED,
+      suggested_currency: Enterprise::Billing::Currencies.for_locale(@account.locale)
+    }
+  end
+
   def default_limits
     {
       'conversation' => {},
@@ -98,6 +129,12 @@ class Enterprise::Api::V1::AccountsController < Api::BaseController
     @account.custom_attributes['stripe_customer_id']
   end
 
+  # Currency is fixed once a customer exists or creation is already in flight,
+  # so a second click can't bill a different currency than setup started with.
+  def currency_locked?
+    stripe_customer_id.present? || @account.custom_attributes['is_creating_customer'].present?
+  end
+
   def mark_for_deletion
     reason = 'manual_deletion'
 
diff --git a/enterprise/app/finders/enterprise/conversation_finder.rb b/enterprise/app/finders/enterprise/conversation_finder.rb
index 24e6b493d..a28eaf5f9 100644
--- a/enterprise/app/finders/enterprise/conversation_finder.rb
+++ b/enterprise/app/finders/enterprise/conversation_finder.rb
@@ -1,5 +1,7 @@
 module Enterprise::ConversationFinder
   def conversations_base_query
-    current_account.feature_enabled?('sla') ? super.includes(:applied_sla, :sla_events) : super
+    return super unless current_account.feature_enabled?('sla')
+
+    super.includes(:applied_sla, :sla_events, inbox: :working_hours)
   end
 end
diff --git a/enterprise/app/jobs/onboarding/help_center_article_writer_job.rb b/enterprise/app/jobs/onboarding/help_center_article_writer_job.rb
index 68c218a19..c684bd632 100644
--- a/enterprise/app/jobs/onboarding/help_center_article_writer_job.rb
+++ b/enterprise/app/jobs/onboarding/help_center_article_writer_job.rb
@@ -1,6 +1,21 @@
 class Onboarding::HelpCenterArticleWriterJob < ApplicationJob
   queue_as :low
 
+  # Catch-all so no exception type can wedge the generation in "generating".
+  # Declared FIRST because ActiveJob searches rescue handlers bottom-to-top:
+  # this puts StandardError at the bottom of the search order, so the specific
+  # retry_on/discard_on handlers declared below match first for their types.
+  #
+  # Without this, any error that isn't FirecrawlError or ArticleBuildFailed
+  # (e.g. ActiveRecord::RecordInvalid, SSL errors) falls through to ActiveJob's
+  # default retries, exhausts them, and lands in the dead set without ever
+  # calling finalize -> state stays "generating" at total - 1 until the 7-day
+  # Redis TTL expires. on_writer_failure logs the error, so code bugs are still
+  # visible; it just also progresses the state.
+  discard_on StandardError do |job, error|
+    job.send(:on_writer_failure, error)
+  end
+
   retry_on Firecrawl::FirecrawlError, wait: :polynomially_longer, attempts: 3 do |job, error|
     job.send(:on_writer_failure, error)
   end
diff --git a/enterprise/app/jobs/sla/process_account_applied_slas_job.rb b/enterprise/app/jobs/sla/process_account_applied_slas_job.rb
index d8786565c..4eb2d182b 100644
--- a/enterprise/app/jobs/sla/process_account_applied_slas_job.rb
+++ b/enterprise/app/jobs/sla/process_account_applied_slas_job.rb
@@ -2,7 +2,7 @@ class Sla::ProcessAccountAppliedSlasJob < ApplicationJob
   queue_as :medium
 
   def perform(account)
-    account.applied_slas.where(sla_status: %w[active active_with_misses]).each do |applied_sla|
+    account.applied_slas.with_sla_applicable_conversation.where(sla_status: %w[active active_with_misses]).each do |applied_sla|
       Sla::ProcessAppliedSlaJob.perform_later(applied_sla)
     end
   end
diff --git a/enterprise/app/models/applied_sla.rb b/enterprise/app/models/applied_sla.rb
index 112f9deea..cab812b36 100644
--- a/enterprise/app/models/applied_sla.rb
+++ b/enterprise/app/models/applied_sla.rb
@@ -40,10 +40,13 @@ class AppliedSla < ApplicationRecord
                                         joins(:conversation).where(conversations: { assignee_id: assigned_agent_id }) if assigned_agent_id.present?
                                       }
   scope :missed, -> { where(sla_status: %i[missed active_with_misses]) }
+  scope :with_sla_applicable_conversation, -> { where(conversation_id: Conversation.with_sla_applicable_contact.select(:id)) }
 
   after_update_commit :push_conversation_event
 
   def push_event_data
+    sla_due_at_values = due_at_values
+
     {
       id: id,
       sla_id: sla_policy_id,
@@ -55,10 +58,65 @@ class AppliedSla < ApplicationRecord
       sla_first_response_time_threshold: sla_policy.first_response_time_threshold,
       sla_next_response_time_threshold: sla_policy.next_response_time_threshold,
       sla_only_during_business_hours: sla_policy.only_during_business_hours,
-      sla_resolution_time_threshold: sla_policy.resolution_time_threshold
+      sla_resolution_time_threshold: sla_policy.resolution_time_threshold,
+      sla_frt_due_at: sla_due_at_values[:frt],
+      sla_nrt_due_at: sla_due_at_values[:nrt],
+      sla_rt_due_at: sla_due_at_values[:rt]
     }
   end
 
+  def due_at_values
+    working_hours_by_day_cache = conversation.inbox.working_hours.index_by(&:day_of_week) if sla_policy.only_during_business_hours?
+
+    {
+      frt: frt_due_at(working_hours_by_day_cache: working_hours_by_day_cache),
+      nrt: nrt_due_at(working_hours_by_day_cache: working_hours_by_day_cache),
+      rt: rt_due_at(working_hours_by_day_cache: working_hours_by_day_cache)
+    }
+  end
+
+  def frt_due_at(working_hours_by_day_cache: nil)
+    return nil if sla_policy.first_response_time_threshold.blank?
+
+    calculate_due_at(
+      conversation.created_at,
+      sla_policy.first_response_time_threshold,
+      working_hours_by_day_cache: working_hours_by_day_cache
+    )
+  end
+
+  def nrt_due_at(working_hours_by_day_cache: nil)
+    return nil if sla_policy.next_response_time_threshold.blank?
+    return nil if conversation.waiting_since.blank?
+
+    calculate_due_at(
+      conversation.waiting_since,
+      sla_policy.next_response_time_threshold,
+      working_hours_by_day_cache: working_hours_by_day_cache
+    )
+  end
+
+  def rt_due_at(working_hours_by_day_cache: nil)
+    return nil if sla_policy.resolution_time_threshold.blank?
+
+    calculate_due_at(
+      conversation.created_at,
+      sla_policy.resolution_time_threshold,
+      working_hours_by_day_cache: working_hours_by_day_cache
+    )
+  end
+
+  def calculate_due_at(start_time, threshold_seconds, working_hours_by_day_cache: nil)
+    return (start_time + threshold_seconds.to_i.seconds).to_i unless sla_policy.only_during_business_hours?
+
+    Sla::BusinessHoursService.new(
+      inbox: conversation.inbox,
+      start_time: start_time,
+      threshold_seconds: threshold_seconds,
+      working_hours_by_day_cache: working_hours_by_day_cache
+    ).deadline.to_i
+  end
+
   private
 
   def push_conversation_event
diff --git a/enterprise/app/models/enterprise/account.rb b/enterprise/app/models/enterprise/account.rb
index 9b451a23c..fcfe90777 100644
--- a/enterprise/app/models/enterprise/account.rb
+++ b/enterprise/app/models/enterprise/account.rb
@@ -68,6 +68,30 @@ module Enterprise::Account
     saml_settings&.saml_enabled? || false
   end
 
+  def billing_currency
+    # Feature off => everyone is billed in USD (legacy behaviour).
+    return Enterprise::Billing::Currencies::DEFAULT unless Enterprise::Billing::Currencies.enabled?
+
+    stored = custom_attributes&.dig('billing_currency')
+    return Enterprise::Billing::Currencies.normalize(stored) if Enterprise::Billing::Currencies.supported?(stored)
+
+    # Existing Stripe customers stay on USD (webhook backfills the real currency);
+    # only brand-new accounts infer from locale, so existing pt_BR users aren't charged BRL.
+    return Enterprise::Billing::Currencies::DEFAULT if custom_attributes&.dig('stripe_customer_id').present?
+
+    Enterprise::Billing::Currencies.for_locale(locale)
+  end
+
+  # New accounts whose locale maps to a non-USD currency get to pick USD or that
+  # currency before the Stripe customer is created; everyone else proceeds in USD.
+  def billing_currency_selection_required?
+    return false unless Enterprise::Billing::Currencies.enabled?
+    return false if custom_attributes&.dig('stripe_customer_id').present?
+    return false if Enterprise::Billing::Currencies.supported?(custom_attributes&.dig('billing_currency'))
+
+    Enterprise::Billing::Currencies.for_locale(locale) != Enterprise::Billing::Currencies::DEFAULT
+  end
+
   private
 
   def sync_assignment_features
diff --git a/enterprise/app/models/enterprise/concerns/article.rb b/enterprise/app/models/enterprise/concerns/article.rb
index 9482313fd..6be262fef 100644
--- a/enterprise/app/models/enterprise/concerns/article.rb
+++ b/enterprise/app/models/enterprise/concerns/article.rb
@@ -67,7 +67,7 @@ module Enterprise::Concerns::Article
       { role: 'system', content: article_to_search_terms_prompt },
       { role: 'user', content: "title: #{title} \n description: #{description} \n content: #{content}" }
     ]
-    headers = { 'Content-Type' => 'application/json', 'Authorization' => "Bearer #{ENV.fetch('OPENAI_API_KEY', nil)}" }
+    headers = { 'Content-Type' => 'application/json', 'Authorization' => "Bearer #{openai_api_key}" }
     body = { model: 'gpt-4o', messages: messages, response_format: { type: 'json_object' } }.to_json
     Rails.logger.info "Requesting Chat GPT with body: #{body}"
     response = HTTParty.post(openai_api_url, headers: headers, body: body)
@@ -77,8 +77,12 @@ module Enterprise::Concerns::Article
 
   private
 
+  def openai_api_key
+    InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_API_KEY')&.value.presence || raise(I18n.t('captain.api_key_missing'))
+  end
+
   def openai_api_url
-    endpoint = InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_ENDPOINT')&.value || 'https://api.openai.com/'
+    endpoint = InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_ENDPOINT')&.value.presence || 'https://api.openai.com/'
     endpoint = endpoint.chomp('/')
     "#{endpoint}/v1/chat/completions"
   end
diff --git a/enterprise/app/models/enterprise/concerns/conversation.rb b/enterprise/app/models/enterprise/concerns/conversation.rb
index 0f7595e0d..a075704d1 100644
--- a/enterprise/app/models/enterprise/concerns/conversation.rb
+++ b/enterprise/app/models/enterprise/concerns/conversation.rb
@@ -7,10 +7,16 @@ module Enterprise::Concerns::Conversation
     has_many :sla_events, dependent: :destroy_async
     has_many :calls, dependent: :destroy_async
     has_many :captain_responses, class_name: 'Captain::AssistantResponse', dependent: :nullify, as: :documentable
+    scope :with_sla_applicable_contact, -> { left_joins(:contact).where(contacts: { blocked: [false, nil] }) }
+
     before_validation :validate_sla_policy, if: -> { sla_policy_id_changed? }
     around_save :ensure_applied_sla_is_created, if: -> { sla_policy_id_changed? }
   end
 
+  def sla_applicable?
+    !contact&.blocked?
+  end
+
   private
 
   def validate_sla_policy
@@ -20,6 +26,11 @@ module Enterprise::Concerns::Conversation
       return
     end
 
+    unless sla_applicable?
+      errors.add(:sla_policy, 'cannot be assigned to conversations with blocked contacts')
+      return
+    end
+
     if changes[:sla_policy_id].first.present?
       errors.add(:sla_policy, 'conversation already has a different sla')
       return
diff --git a/enterprise/app/presenters/enterprise/conversations/event_data_presenter.rb b/enterprise/app/presenters/enterprise/conversations/event_data_presenter.rb
index 9ec0a1875..142ce4dc2 100644
--- a/enterprise/app/presenters/enterprise/conversations/event_data_presenter.rb
+++ b/enterprise/app/presenters/enterprise/conversations/event_data_presenter.rb
@@ -1,13 +1,13 @@
 module Enterprise::Conversations::EventDataPresenter
   def push_data
-    if account.feature_enabled?('sla')
-      super.merge(
-        applied_sla: applied_sla&.push_event_data,
-        sla_events: sla_events.map(&:push_event_data),
-        sla_policy_id: sla_policy_id
-      )
-    else
-      super
-    end
+    return super unless account.feature_enabled?('sla')
+
+    sla_applicable = sla_applicable?
+
+    super.merge(
+      applied_sla: sla_applicable ? applied_sla&.push_event_data : nil,
+      sla_events: sla_applicable ? sla_events.map(&:push_event_data) : [],
+      sla_policy_id: sla_applicable ? sla_policy_id : nil
+    )
   end
 end
diff --git a/enterprise/app/services/enterprise/action_service.rb b/enterprise/app/services/enterprise/action_service.rb
index f0c3bbf9f..c841f5054 100644
--- a/enterprise/app/services/enterprise/action_service.rb
+++ b/enterprise/app/services/enterprise/action_service.rb
@@ -5,6 +5,7 @@ module Enterprise::ActionService
     sla_policy = @account.sla_policies.find_by(id: sla_policy_id.first)
     return if sla_policy.nil?
     return if @conversation.sla_policy.present?
+    return unless @conversation.sla_applicable?
 
     Rails.logger.info "SLA:: Adding SLA #{sla_policy.id} to conversation: #{@conversation.id}"
     @conversation.update!(sla_policy_id: sla_policy.id)
diff --git a/enterprise/app/services/enterprise/billing/create_stripe_customer_service.rb b/enterprise/app/services/enterprise/billing/create_stripe_customer_service.rb
index 79e5ee258..7a2e587fd 100644
--- a/enterprise/app/services/enterprise/billing/create_stripe_customer_service.rb
+++ b/enterprise/app/services/enterprise/billing/create_stripe_customer_service.rb
@@ -1,4 +1,6 @@
 class Enterprise::Billing::CreateStripeCustomerService
+  include BillingHelper
+
   pattr_initialize [:account!]
 
   DEFAULT_QUANTITY = 2
@@ -21,13 +23,22 @@ class Enterprise::Billing::CreateStripeCustomerService
 
   def prepare_customer_id
     customer_id = account.custom_attributes['stripe_customer_id']
-    if customer_id.blank?
-      customer = Stripe::Customer.create({ name: account.name, email: billing_email })
-      customer_id = customer.id
-    end
+    customer_id = Stripe::Customer.create(customer_params).id if customer_id.blank?
     customer_id
   end
 
+  # Only currencies that need a country override (e.g. BRL/PIX) set address/locale; usd keeps Stripe defaults.
+  def customer_params
+    params = { name: account.name, email: billing_email }
+    country = Enterprise::Billing::Currencies.country_for(account.billing_currency)
+    return params if country.blank?
+
+    params.merge(
+      address: { country: country },
+      preferred_locales: [Enterprise::Billing::Currencies.preferred_locale_for(account.billing_currency)]
+    )
+  end
+
   def default_quantity
     default_plan['default_quantity'] || DEFAULT_QUANTITY
   end
@@ -37,13 +48,11 @@ class Enterprise::Billing::CreateStripeCustomerService
   end
 
   def default_plan
-    installation_config = InstallationConfig.find_by(name: 'CHATWOOT_CLOUD_PLANS')
-    @default_plan ||= installation_config.value.first
+    @default_plan ||= Enterprise::Billing::PlanConfiguration.default_plan
   end
 
   def price_id
-    price_ids = default_plan['price_ids']
-    price_ids.first
+    Enterprise::Billing::PlanConfiguration.price_id_for(default_plan, account.billing_currency)
   end
 
   def active_subscription
@@ -60,7 +69,7 @@ class Enterprise::Billing::CreateStripeCustomerService
   end
 
   def default_plan_subscription?(subscription)
-    default_plan['price_ids'].include?(subscription['plan']['id'])
+    Enterprise::Billing::PlanConfiguration.plan_contains_product_id?(default_plan, subscription['plan']['product'])
   end
 
   def build_custom_attributes(customer_id, subscription)
@@ -71,14 +80,14 @@ class Enterprise::Billing::CreateStripeCustomerService
       'plan_name' => default_plan['name'],
       'subscribed_quantity' => subscription['quantity'],
       'subscription_status' => subscription['status'],
-      'subscription_ends_on' => subscription_ends_on(subscription)
+      'subscription_ends_on' => subscription_ends_on(subscription),
+      'billing_currency' => billing_currency_for(subscription)
     )
   end
 
-  def subscription_ends_on(subscription)
-    period_end = subscription['current_period_end']
-    return if period_end.blank?
-
-    Time.zone.at(period_end)
+  # Persist the currency Stripe actually billed, read straight from the price; the
+  # requested currency may lack a configured price and fall back to usd.
+  def billing_currency_for(subscription)
+    Enterprise::Billing::Currencies.to_supported(subscription['plan']['currency'])
   end
 end
diff --git a/enterprise/app/services/enterprise/billing/currencies.rb b/enterprise/app/services/enterprise/billing/currencies.rb
new file mode 100644
index 000000000..46fb9ecd9
--- /dev/null
+++ b/enterprise/app/services/enterprise/billing/currencies.rb
@@ -0,0 +1,55 @@
+# Supported billing currencies and their Stripe/locale mappings.
+module Enterprise::Billing::Currencies
+  DEFAULT = 'usd'.freeze
+
+  SUPPORTED = %w[usd brl].freeze
+
+  FEATURE_CONFIG = 'ENABLE_MULTI_CURRENCY_BILLING'.freeze
+
+  # Account locale label (e.g. 'pt_BR') => default currency; unlisted falls back to DEFAULT.
+  LOCALE_DEFAULTS = {
+    'pt_BR' => 'brl'
+  }.freeze
+
+  # Billing country override per currency; absent currencies (e.g. usd) keep Stripe's default.
+  COUNTRY_BY_CURRENCY = {
+    'brl' => 'BR'
+  }.freeze
+
+  # Preferred Stripe/checkout locale per currency; absent currencies keep Stripe's default.
+  PREFERRED_LOCALE_BY_CURRENCY = {
+    'brl' => 'pt-BR'
+  }.freeze
+
+  module_function
+
+  # Master switch for the whole multi-currency feature; off => everyone is billed in USD.
+  def enabled?
+    GlobalConfigService.load(FEATURE_CONFIG, 'false').to_s != 'false'
+  end
+
+  def normalize(code)
+    code.to_s.strip.downcase.presence
+  end
+
+  def supported?(code)
+    SUPPORTED.include?(normalize(code))
+  end
+
+  # Map arbitrary input to a supported code, else DEFAULT.
+  def to_supported(code)
+    supported?(code) ? normalize(code) : DEFAULT
+  end
+
+  def for_locale(locale)
+    LOCALE_DEFAULTS.fetch(locale.to_s, DEFAULT)
+  end
+
+  def country_for(code)
+    COUNTRY_BY_CURRENCY[to_supported(code)]
+  end
+
+  def preferred_locale_for(code)
+    PREFERRED_LOCALE_BY_CURRENCY[to_supported(code)]
+  end
+end
diff --git a/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb b/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb
index 8342343e9..add6dbd08 100644
--- a/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb
+++ b/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb
@@ -1,4 +1,6 @@
 class Enterprise::Billing::HandleStripeEventService
+  include BillingHelper
+
   CLOUD_PLANS_CONFIG = 'CHATWOOT_CLOUD_PLANS'.freeze
   CAPTAIN_CLOUD_PLAN_LIMITS = 'CAPTAIN_CLOUD_PLAN_LIMITS'.freeze
 
@@ -65,11 +67,19 @@ class Enterprise::Billing::HandleStripeEventService
         'plan_name' => plan['name'],
         'subscribed_quantity' => subscription['quantity'],
         'subscription_status' => subscription['status'],
-        'subscription_ends_on' => Time.zone.at(subscription['current_period_end'])
+        'subscription_ends_on' => subscription_ends_on(subscription),
+        'billing_currency' => billing_currency_for(subscription, plan)
       )
     )
   end
 
+  # Paid subscriptions define the currency; the free/default plan keeps the stored preference.
+  def billing_currency_for(subscription, plan)
+    return account.billing_currency if plan['name'] == Enterprise::Billing::PlanConfiguration.default_plan&.dig('name')
+
+    Enterprise::Billing::Currencies.to_supported(subscription['plan']['currency'])
+  end
+
   def track_marketing_plan_activation(previous_plan_name, current_plan_name)
     subscription_plan = subscription['plan']
 
@@ -161,8 +171,8 @@ class Enterprise::Billing::HandleStripeEventService
     @account ||= Account.where("custom_attributes->>'stripe_customer_id' = ?", subscription.customer).first
   end
 
-  def find_plan(plan_id)
-    cloud_plans.find { |config| config['product_id'].include?(plan_id) }
+  def find_plan(product_id)
+    Enterprise::Billing::PlanConfiguration.find_plan_by_product_id(product_id)
   end
 
   def previous_plan_name
@@ -171,8 +181,4 @@ class Enterprise::Billing::HandleStripeEventService
 
     find_plan(stripe_plan['product'])&.dig('name')
   end
-
-  def cloud_plans
-    @cloud_plans ||= InstallationConfig.find_by(name: CLOUD_PLANS_CONFIG)&.value || []
-  end
 end
diff --git a/enterprise/app/services/enterprise/billing/plan_configuration.rb b/enterprise/app/services/enterprise/billing/plan_configuration.rb
new file mode 100644
index 000000000..25683cbc0
--- /dev/null
+++ b/enterprise/app/services/enterprise/billing/plan_configuration.rb
@@ -0,0 +1,46 @@
+# Resolves Stripe price ids from CHATWOOT_CLOUD_PLANS per currency.
+# A plan's `price_ids` may be a currency-keyed Hash, or a legacy Array (treated as usd).
+module Enterprise::Billing::PlanConfiguration
+  CLOUD_PLANS_CONFIG = 'CHATWOOT_CLOUD_PLANS'.freeze
+
+  module_function
+
+  def plans
+    InstallationConfig.find_by(name: CLOUD_PLANS_CONFIG)&.value || []
+  end
+
+  def default_plan
+    plans.first
+  end
+
+  # Handles both shapes during migration; once all configs are currency-keyed Hashes, drop the Array branch.
+  def price_ids_by_currency(plan)
+    raw = plan && plan['price_ids']
+    case raw
+    when Hash then raw.transform_keys { |key| Enterprise::Billing::Currencies.normalize(key) }
+    when Array then { Enterprise::Billing::Currencies::DEFAULT => raw }
+    else {}
+    end
+  end
+
+  # Price id for `plan` in `currency`, falling back to usd then any configured price.
+  # The multi-step fallback is migration-era safety; once configs settle on one format we can simplify this.
+  def price_id_for(plan, currency)
+    by_currency = price_ids_by_currency(plan)
+    code = Enterprise::Billing::Currencies.to_supported(currency)
+
+    (by_currency[code].presence ||
+     by_currency[Enterprise::Billing::Currencies::DEFAULT].presence ||
+     by_currency.values.flatten.compact).first
+  end
+
+  # Match by product id, not price id: production has prices that aren't enumerated
+  # in our config but share a product, so product matching still resolves the plan.
+  def plan_contains_product_id?(plan, product_id)
+    Array(plan && plan['product_id']).include?(product_id)
+  end
+
+  def find_plan_by_product_id(product_id)
+    plans.find { |plan| plan_contains_product_id?(plan, product_id) }
+  end
+end
diff --git a/enterprise/app/services/enterprise/billing/topup_checkout_service.rb b/enterprise/app/services/enterprise/billing/topup_checkout_service.rb
index 00e2b1646..58eac1b4d 100644
--- a/enterprise/app/services/enterprise/billing/topup_checkout_service.rb
+++ b/enterprise/app/services/enterprise/billing/topup_checkout_service.rb
@@ -3,15 +3,15 @@ class Enterprise::Billing::TopupCheckoutService
 
   class Error < StandardError; end
 
-  TOPUP_OPTIONS = [
-    { credits: 1000, amount: 20.0, currency: 'usd' },
-    { credits: 2500, amount: 50.0, currency: 'usd' },
-    { credits: 6000, amount: 100.0, currency: 'usd' },
-    { credits: 12_000, amount: 200.0, currency: 'usd' }
-  ].freeze
+  TOPUP_OPTIONS_CONFIG = 'CAPTAIN_TOPUP_OPTIONS'.freeze
 
   pattr_initialize [:account!]
 
+  # Topup packages for the account's billing currency (used by the controller).
+  def available_options
+    topup_options
+  end
+
   def create_checkout_session(credits:)
     topup_option = validate_and_find_topup_option(credits)
     charge_customer(topup_option, credits)
@@ -100,6 +100,20 @@ class Enterprise::Billing::TopupCheckoutService
   end
 
   def find_topup_option(credits)
-    TOPUP_OPTIONS.find { |opt| opt[:credits] == credits.to_i }
+    topup_options.find { |opt| opt[:credits] == credits.to_i }
+  end
+
+  def topup_options
+    # Label rows with the currency they were configured under, so a DEFAULT fallback can't relabel USD amounts and undercharge.
+    options = configured_options
+    currency = options[account.billing_currency].present? ? account.billing_currency : Enterprise::Billing::Currencies::DEFAULT
+    rows = options[currency].presence || []
+    rows.map { |opt| { credits: opt['credits'].to_i, amount: opt['amount'].to_f, currency: currency } }
+  end
+
+  def configured_options
+    config = InstallationConfig.find_by(name: TOPUP_OPTIONS_CONFIG)&.value
+    config = JSON.parse(config) if config.is_a?(String)
+    config || {}
   end
 end
diff --git a/enterprise/app/services/sla/business_hours_service.rb b/enterprise/app/services/sla/business_hours_service.rb
new file mode 100644
index 000000000..658738241
--- /dev/null
+++ b/enterprise/app/services/sla/business_hours_service.rb
@@ -0,0 +1,108 @@
+class Sla::BusinessHoursService
+  pattr_initialize [:inbox!, :start_time!, :threshold_seconds!, { working_hours_by_day_cache: nil }]
+
+  def deadline
+    return start_time + threshold_seconds.seconds unless should_apply_business_hours?
+
+    calculate_deadline_with_business_hours
+  end
+
+  private
+
+  def should_apply_business_hours?
+    inbox.working_hours_enabled? && open_days?
+  end
+
+  def open_days?
+    working_hours_by_day.values.any? { |working_hour| !working_hour.closed_all_day? }
+  end
+
+  def calculate_deadline_with_business_hours
+    @remaining_seconds = threshold_seconds.to_i
+    @current_time = start_time.in_time_zone(timezone)
+
+    process_remaining_seconds while @remaining_seconds.positive?
+
+    @current_time
+  end
+
+  def process_remaining_seconds
+    working_hour = working_hour_for(@current_time)
+
+    if closed_day?(working_hour)
+      @current_time = next_business_day_start(@current_time)
+      return
+    end
+
+    # If adjust moved to next day, return early to re-fetch correct working hours
+    return unless adjust_current_time_to_business_hours(working_hour)
+
+    consume_available_seconds(working_hour)
+  end
+
+  def closed_day?(working_hour)
+    working_hour.nil? || working_hour.closed_all_day?
+  end
+
+  # Returns true if current_time was adjusted within the same day, false if moved to next day
+  def adjust_current_time_to_business_hours(working_hour)
+    day_open_time = time_on_date(@current_time, working_hour.open_hour, working_hour.open_minutes)
+    day_close_time = day_close_time_for(working_hour)
+
+    if @current_time < day_open_time
+      @current_time = day_open_time
+      true
+    elsif @current_time >= day_close_time
+      @current_time = next_business_day_start(@current_time)
+      false
+    else
+      true
+    end
+  end
+
+  def consume_available_seconds(working_hour)
+    day_close_time = day_close_time_for(working_hour)
+    available_seconds = (day_close_time - @current_time).to_i
+
+    if @remaining_seconds <= available_seconds
+      @current_time += @remaining_seconds.seconds
+      @remaining_seconds = 0
+    else
+      @remaining_seconds -= available_seconds
+      @current_time = next_business_day_start(@current_time)
+    end
+  end
+
+  def day_close_time_for(working_hour)
+    return @current_time.beginning_of_day + 1.day if working_hour.open_all_day?
+
+    time_on_date(@current_time, working_hour.close_hour, working_hour.close_minutes)
+  end
+
+  def working_hour_for(time)
+    working_hours_by_day[time.wday]
+  end
+
+  def working_hours_by_day
+    @working_hours_by_day ||= working_hours_by_day_cache || inbox.working_hours.index_by(&:day_of_week)
+  end
+
+  def next_business_day_start(current_time)
+    next_day = (current_time + 1.day).beginning_of_day
+    7.times do
+      working_hour = working_hour_for(next_day)
+      return time_on_date(next_day, working_hour.open_hour, working_hour.open_minutes) if working_hour && !working_hour.closed_all_day?
+
+      next_day += 1.day
+    end
+    next_day
+  end
+
+  def time_on_date(date, hour, minutes)
+    date.change(hour: hour, min: minutes, sec: 0)
+  end
+
+  def timezone
+    inbox.timezone || 'UTC'
+  end
+end
diff --git a/enterprise/app/services/sla/evaluate_applied_sla_service.rb b/enterprise/app/services/sla/evaluate_applied_sla_service.rb
index 2da350289..2adf3ad9f 100644
--- a/enterprise/app/services/sla/evaluate_applied_sla_service.rb
+++ b/enterprise/app/services/sla/evaluate_applied_sla_service.rb
@@ -2,106 +2,103 @@ class Sla::EvaluateAppliedSlaService
   pattr_initialize [:applied_sla!]
 
   def perform
-    check_sla_thresholds
+    return unless conversation.sla_applicable?
 
-    # We will calculate again in the next iteration
-    return unless applied_sla.conversation.resolved?
+    check_frt
+    check_nrt
+    check_rt
 
-    # after conversation is resolved, we will check if the SLA was hit or missed
-    handle_hit_sla(applied_sla)
+    return unless conversation.resolved?
+
+    handle_hit_sla
   end
 
   private
 
-  def check_sla_thresholds
-    [:first_response_time_threshold, :next_response_time_threshold, :resolution_time_threshold].each do |threshold|
-      next if applied_sla.sla_policy.send(threshold).blank?
+  delegate :conversation, :sla_policy, to: :applied_sla
 
-      send("check_#{threshold}", applied_sla, applied_sla.conversation, applied_sla.sla_policy)
+  def check_frt
+    return if sla_policy.first_response_time_threshold.blank?
+    return if frt_was_hit?
+    return if within_threshold?(applied_sla.frt_due_at)
+
+    handle_missed_sla('frt')
+  end
+
+  def check_nrt
+    return if sla_policy.next_response_time_threshold.blank?
+    return if conversation.first_reply_created_at.blank?
+    return if conversation.waiting_since.blank?
+    return if within_threshold?(applied_sla.nrt_due_at)
+
+    handle_missed_sla('nrt')
+  end
+
+  def check_rt
+    return if sla_policy.resolution_time_threshold.blank?
+    return if conversation.resolved?
+    return if within_threshold?(applied_sla.rt_due_at)
+
+    handle_missed_sla('rt')
+  end
+
+  def within_threshold?(due_at)
+    Time.zone.now.to_i < due_at
+  end
+
+  def frt_was_hit?
+    return false if applied_sla.frt_due_at.blank?
+    return false if conversation.first_reply_created_at.blank?
+
+    conversation.first_reply_created_at.to_i <= applied_sla.frt_due_at
+  end
+
+  def handle_missed_sla(type)
+    meta = type == 'nrt' ? { message_id: last_incoming_message_id } : {}
+    return if already_missed?(type, meta)
+
+    create_sla_event(type, meta)
+    log_miss(type)
+    applied_sla.update!(sla_status: 'active_with_misses') unless applied_sla.active_with_misses?
+  end
+
+  def handle_hit_sla
+    if applied_sla.active?
+      applied_sla.update!(sla_status: 'hit')
+      log_result('hit')
+    else
+      applied_sla.update!(sla_status: 'missed')
+      log_result('missed')
     end
   end
 
-  def still_within_threshold?(threshold)
-    Time.zone.now.to_i < threshold
-  end
-
-  def check_first_response_time_threshold(applied_sla, conversation, sla_policy)
-    threshold = conversation.created_at.to_i + sla_policy.first_response_time_threshold.to_i
-    return if first_reply_was_within_threshold?(conversation, threshold)
-    return if still_within_threshold?(threshold)
-
-    handle_missed_sla(applied_sla, 'frt')
-  end
-
-  def first_reply_was_within_threshold?(conversation, threshold)
-    conversation.first_reply_created_at.present? && conversation.first_reply_created_at.to_i <= threshold
-  end
-
-  def check_next_response_time_threshold(applied_sla, conversation, sla_policy)
-    # still waiting for first reply, so covered under first response time threshold
-    return if conversation.first_reply_created_at.blank?
-    # Waiting on customer response, no need to check next response time threshold
-    return if conversation.waiting_since.blank?
-
-    threshold = conversation.waiting_since.to_i + sla_policy.next_response_time_threshold.to_i
-    return if still_within_threshold?(threshold)
-
-    handle_missed_sla(applied_sla, 'nrt')
-  end
-
-  def get_last_message_id(conversation)
-    # TODO: refactor the method to fetch last message without reply
-    conversation.messages.where(message_type: :incoming).last&.id
-  end
-
-  def already_missed?(applied_sla, type, meta = {})
+  def already_missed?(type, meta)
     SlaEvent.exists?(applied_sla: applied_sla, event_type: type, meta: meta)
   end
 
-  def check_resolution_time_threshold(applied_sla, conversation, sla_policy)
-    return if conversation.resolved?
-
-    threshold = conversation.created_at.to_i + sla_policy.resolution_time_threshold.to_i
-    return if still_within_threshold?(threshold)
-
-    handle_missed_sla(applied_sla, 'rt')
+  def last_incoming_message_id
+    Message.where(account_id: conversation.account_id, conversation_id: conversation.id, message_type: :incoming).last&.id
   end
 
-  def handle_missed_sla(applied_sla, type, meta = {})
-    meta = { message_id: get_last_message_id(applied_sla.conversation) } if type == 'nrt'
-    return if already_missed?(applied_sla, type, meta)
-
-    create_sla_event(applied_sla, type, meta)
-    Rails.logger.warn "SLA #{type} missed for conversation #{applied_sla.conversation.id} " \
-                      "in account #{applied_sla.account_id} " \
-                      "for sla_policy #{applied_sla.sla_policy.id}"
-
-    applied_sla.update!(sla_status: 'active_with_misses') if applied_sla.sla_status != 'active_with_misses'
-  end
-
-  def handle_hit_sla(applied_sla)
-    if applied_sla.active?
-      applied_sla.update!(sla_status: 'hit')
-      Rails.logger.info "SLA hit for conversation #{applied_sla.conversation.id} " \
-                        "in account #{applied_sla.account_id} " \
-                        "for sla_policy #{applied_sla.sla_policy.id}"
-    else
-      applied_sla.update!(sla_status: 'missed')
-      Rails.logger.info "SLA missed for conversation #{applied_sla.conversation.id} " \
-                        "in account #{applied_sla.account_id} " \
-                        "for sla_policy #{applied_sla.sla_policy.id}"
-    end
-  end
-
-  def create_sla_event(applied_sla, event_type, meta = {})
+  def create_sla_event(event_type, meta)
     SlaEvent.create!(
       applied_sla: applied_sla,
-      conversation: applied_sla.conversation,
+      conversation: conversation,
       event_type: event_type,
       meta: meta,
       account: applied_sla.account,
-      inbox: applied_sla.conversation.inbox,
-      sla_policy: applied_sla.sla_policy
+      inbox: conversation.inbox,
+      sla_policy: sla_policy
     )
   end
+
+  def log_miss(type)
+    Rails.logger.warn "SLA #{type} missed for conversation #{conversation.id} " \
+                      "in account #{applied_sla.account_id} for sla_policy #{sla_policy.id}"
+  end
+
+  def log_result(result)
+    Rails.logger.info "SLA #{result} for conversation #{conversation.id} " \
+                      "in account #{applied_sla.account_id} for sla_policy #{sla_policy.id}"
+  end
 end
diff --git a/enterprise/app/services/voice/outbound_call_builder.rb b/enterprise/app/services/voice/outbound_call_builder.rb
index 30a74099e..c58407a3f 100644
--- a/enterprise/app/services/voice/outbound_call_builder.rb
+++ b/enterprise/app/services/voice/outbound_call_builder.rb
@@ -17,10 +17,19 @@ class Voice::OutboundCallBuilder
     raise ArgumentError, 'Contact phone number required' if contact.phone_number.blank?
     raise ArgumentError, 'Agent required' if user.blank?
 
+    # Claim for the caller if a reused conversation is unassigned at trigger time; wins over auto-assignment.
+    # New conversations set the assignee at creation instead (see create_conversation!).
+    claim_for_caller = @existing_conversation && @existing_conversation.assignee_id.nil?
+
     ActiveRecord::Base.transaction do
       contact_inbox = ensure_contact_inbox!
       conversation = @existing_conversation || create_conversation!(contact_inbox)
+      # Dial before locking so the Twilio round-trip doesn't hold the conversation row lock.
       call_sid = initiate_call!
+      if claim_for_caller
+        @existing_conversation.lock!
+        @existing_conversation.update!(assignee: user)
+      end
       call = create_call!(conversation, call_sid)
       message = Voice::CallMessageBuilder.new(call).perform!
       call.update!(message_id: message.id)
@@ -44,6 +53,7 @@ class Voice::OutboundCallBuilder
       contact_inbox_id: contact_inbox.id,
       inbox_id: inbox.id,
       contact_id: contact.id,
+      assignee_id: user.id,
       status: :open
     )
   end
diff --git a/enterprise/app/services/whatsapp/call_service.rb b/enterprise/app/services/whatsapp/call_service.rb
index 362af33cb..bd0dd6ae5 100644
--- a/enterprise/app/services/whatsapp/call_service.rb
+++ b/enterprise/app/services/whatsapp/call_service.rb
@@ -48,9 +48,10 @@ class Whatsapp::CallService
   private
 
   def transition_to_in_progress!
-    # Order matters: in_progress and terminal both make ringing? false, so we have to
-    # branch on in_progress? first to surface the distinct AlreadyAccepted state.
+    # in_progress and terminal both make ringing? false; branch in order to surface the
+    # distinct AlreadyAccepted / CallAlreadyEnded states (caller can hang up mid-ring).
     raise Voice::CallErrors::AlreadyAccepted, 'Call already accepted by another agent' if call.in_progress?
+    raise Voice::CallErrors::CallAlreadyEnded, 'Call already ended' if call.terminal?
     raise Voice::CallErrors::NotRinging, 'Call is not in ringing state' unless call.ringing?
 
     forward_answer_to_meta!
diff --git a/enterprise/app/services/whatsapp/incoming_call_service.rb b/enterprise/app/services/whatsapp/incoming_call_service.rb
index f6185050d..11b35d95a 100644
--- a/enterprise/app/services/whatsapp/incoming_call_service.rb
+++ b/enterprise/app/services/whatsapp/incoming_call_service.rb
@@ -1,6 +1,9 @@
 class Whatsapp::IncomingCallService
   pattr_initialize [:inbox!, :params!]
 
+  # Lifespan of a terminate-before-connect tombstone; the paired connect arrives within ~1s.
+  TERMINATE_TOMBSTONE_TTL = 60
+
   def perform
     return unless inbox.channel.voice_enabled?
 
@@ -79,16 +82,32 @@ class Whatsapp::IncomingCallService
     end
 
     sdp_offer = payload.dig(:session, :sdp)
+    call = build_inbound_call(payload, sdp_offer)
+
+    return if call.terminal? # terminated before pickup; no ringing widget to surface
+
+    update_conversation(call)
+    broadcast_incoming(call, sdp_offer)
+  end
+
+  # If a terminate already arrived (caller hung up before pickup), finalize it in the
+  # SAME transaction as the build so the message's after_create_commit fires (at outer
+  # commit) already terminal, never `ringing` — agents aren't rung for a dead call.
+  def build_inbound_call(payload, sdp_offer)
+    ActiveRecord::Base.transaction do
+      call = Voice::InboundCallBuilder.perform!(inbox: inbox, from_number: "+#{payload[:from]}", call_sid: payload[:id],
+                                                provider: :whatsapp, extra_meta: inbound_extra_meta(payload, sdp_offer))
+      tombstone = consume_terminate_tombstone(payload[:id])
+      finalize_terminate(call, tombstone['duration'], tombstone['terminate_reason']) if tombstone
+      call
+    end
+  end
+
+  def inbound_extra_meta(payload, sdp_offer)
     extra_meta = { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
     name = caller_profile_name(payload)
     extra_meta['contact_name'] = name if name.present?
-
-    call = Voice::InboundCallBuilder.perform!(
-      inbox: inbox, from_number: "+#{payload[:from]}", call_sid: payload[:id],
-      provider: :whatsapp, extra_meta: extra_meta
-    )
-    update_conversation(call)
-    broadcast_incoming(call, sdp_offer)
+    extra_meta
   end
 
   # Match strictly on wa_id (== calls[].from): in a batched payload missing this
@@ -122,23 +141,24 @@ class Whatsapp::IncomingCallService
   def handle_terminate(payload)
     call = Call.whatsapp.find_by(provider_call_id: payload[:id])
     if call.nil?
-      # No row yet means either an out-of-order terminate (rare in practice — Meta
-      # delivery is FIFO) or, more dangerously, an outbound terminate landing in
-      # the window between the controller's Meta API call and Call.create!.
-      # Materialising as inbound here would collide with the unique
-      # (provider, provider_call_id) index. Skip; controller commits seal it.
-      Rails.logger.warn "[WHATSAPP CALL] Terminate for unknown call #{payload[:id]}; skipping"
+      # Terminate overtook its connect (Meta isn't strictly ordered); tombstone it for the
+      # connect handler to consume. An outbound tombstone just expires unused.
+      record_terminate_tombstone(payload)
       return
     end
 
+    finalize_terminate(call, payload[:duration], payload[:terminate_reason])
+  end
+
+  def finalize_terminate(call, duration, reason)
+    duration = duration&.to_i
+    reason = reason.to_s
     call.with_lock do
       # Webhook retries can re-deliver terminate after we've already finalized the
       # call; don't recompute status or a duration=0 retry can flip a completed
       # short call back to no_answer.
       next if call.terminal?
 
-      duration = payload[:duration]&.to_i
-      reason = payload[:terminate_reason].to_s
       status = derive_terminate_status(call, duration, reason)
       meta = (call.meta || {}).merge('ended_at' => Time.zone.now.to_i)
       update_call!(call, status, duration_seconds: duration, end_reason: reason, meta: meta)
@@ -146,6 +166,28 @@ class Whatsapp::IncomingCallService
     end
   end
 
+  def record_terminate_tombstone(payload)
+    Redis::Alfred.setex(
+      terminate_tombstone_key(payload[:id]),
+      { 'duration' => payload[:duration], 'terminate_reason' => payload[:terminate_reason] }.to_json,
+      TERMINATE_TOMBSTONE_TTL
+    )
+    Rails.logger.info "[WHATSAPP CALL] Terminate before connect for #{payload[:id]}; tombstoned"
+  end
+
+  def consume_terminate_tombstone(provider_call_id)
+    key = terminate_tombstone_key(provider_call_id)
+    raw = Redis::Alfred.get(key)
+    return nil if raw.blank?
+
+    Redis::Alfred.delete(key)
+    JSON.parse(raw)
+  end
+
+  def terminate_tombstone_key(provider_call_id)
+    format(Redis::Alfred::WHATSAPP_CALL_TERMINATE_TOMBSTONE, call_id: provider_call_id)
+  end
+
   # Provider-reported failures trump the answered/no_answer heuristic. An
   # in_progress call that Meta later terminates with a failure reason would
   # otherwise be recorded as 'completed' purely because it had been accepted.
diff --git a/enterprise/app/views/api/v1/models/_applied_sla.json.jbuilder b/enterprise/app/views/api/v1/models/_applied_sla.json.jbuilder
index e7f1c49fc..c00782622 100644
--- a/enterprise/app/views/api/v1/models/_applied_sla.json.jbuilder
+++ b/enterprise/app/views/api/v1/models/_applied_sla.json.jbuilder
@@ -9,3 +9,7 @@ json.sla_first_response_time_threshold resource.sla_policy.first_response_time_t
 json.sla_next_response_time_threshold resource.sla_policy.next_response_time_threshold
 json.sla_only_during_business_hours resource.sla_policy.only_during_business_hours
 json.sla_resolution_time_threshold resource.sla_policy.resolution_time_threshold
+sla_due_at_values = resource.due_at_values
+json.sla_frt_due_at sla_due_at_values[:frt]
+json.sla_nrt_due_at sla_due_at_values[:nrt]
+json.sla_rt_due_at sla_due_at_values[:rt]
diff --git a/enterprise/app/views/enterprise/api/v1/conversations/partials/_conversation.json.jbuilder b/enterprise/app/views/enterprise/api/v1/conversations/partials/_conversation.json.jbuilder
index 5a390a68b..741a4d58b 100644
--- a/enterprise/app/views/enterprise/api/v1/conversations/partials/_conversation.json.jbuilder
+++ b/enterprise/app/views/enterprise/api/v1/conversations/partials/_conversation.json.jbuilder
@@ -1,10 +1,15 @@
 if conversation.account.feature_enabled?('sla')
-  json.applied_sla do
-    json.partial! 'api/v1/models/applied_sla', formats: [:json], resource: conversation.applied_sla if conversation.applied_sla.present?
-  end
-  json.sla_events do
-    json.array! conversation.sla_events do |sla_event|
-      json.partial! 'api/v1/models/sla_event', formats: [:json], sla_event: sla_event
+  if conversation.sla_applicable?
+    json.applied_sla do
+      json.partial! 'api/v1/models/applied_sla', formats: [:json], resource: conversation.applied_sla if conversation.applied_sla.present?
     end
+    json.sla_events do
+      json.array! conversation.sla_events do |sla_event|
+        json.partial! 'api/v1/models/sla_event', formats: [:json], sla_event: sla_event
+      end
+    end
+  else
+    json.applied_sla nil
+    json.sla_events []
   end
 end
diff --git a/enterprise/lib/voice/call_errors.rb b/enterprise/lib/voice/call_errors.rb
index 6b53ddbdc..e45edf0c0 100644
--- a/enterprise/lib/voice/call_errors.rb
+++ b/enterprise/lib/voice/call_errors.rb
@@ -8,4 +8,5 @@ module Voice::CallErrors
   class CallFailed < StandardError; end
   class NotRinging < StandardError; end
   class AlreadyAccepted < StandardError; end
+  class CallAlreadyEnded < StandardError; end
 end
diff --git a/lib/redis/redis_keys.rb b/lib/redis/redis_keys.rb
index bc7fb551e..6d503df22 100644
--- a/lib/redis/redis_keys.rb
+++ b/lib/redis/redis_keys.rb
@@ -58,6 +58,8 @@ module Redis::RedisKeys
   # Check if a message create with same source-id is in progress?
   MESSAGE_SOURCE_KEY = 'MESSAGE_SOURCE_KEY::%<id>s'.freeze
   OPENAI_CONVERSATION_KEY = 'OPEN_AI_CONVERSATION_KEY::V1::%<event_name>s::%<conversation_id>d::%<updated_at>d'.freeze
+  # Bridges a WhatsApp call `terminate` that overtook its `connect` so the later connect can finalize it.
+  WHATSAPP_CALL_TERMINATE_TOMBSTONE = 'WHATSAPP_CALL_TERMINATE_TOMBSTONE::%<call_id>s'.freeze
 
   ## Sempahores / Locks
   # We don't want to process messages from the same sender concurrently to prevent creating double conversations
diff --git a/lib/tasks/apply_sla.rake b/lib/tasks/apply_sla.rake
index 70adf8cf3..162a372bb 100644
--- a/lib/tasks/apply_sla.rake
+++ b/lib/tasks/apply_sla.rake
@@ -62,7 +62,9 @@ namespace :sla do
       exit(1)
     end
 
-    conversations = account.conversations.where(sla_policy_id: nil).order(id: :desc).limit(batch_size)
+    conversations = account.conversations.where(sla_policy_id: nil)
+    conversations = conversations.with_sla_applicable_contact if conversations.respond_to?(:with_sla_applicable_contact)
+    conversations = conversations.order(id: :desc).limit(batch_size)
     total_count = conversations.count
 
     if total_count.zero?
diff --git a/spec/builders/v2/reports/drilldown_builder_spec.rb b/spec/builders/v2/reports/drilldown_builder_spec.rb
new file mode 100644
index 000000000..babeabc58
--- /dev/null
+++ b/spec/builders/v2/reports/drilldown_builder_spec.rb
@@ -0,0 +1,230 @@
+require 'rails_helper'
+
+RSpec.describe V2::Reports::DrilldownBuilder do
+  subject(:drilldown) { described_class.new(account, params).build }
+
+  let(:account) { create(:account) }
+  let(:inbox) { create(:inbox, account: account) }
+  let(:current_time) { Time.zone.parse('2026-05-20 12:00') }
+  let(:bucket_start) { current_time.beginning_of_day }
+  let(:bucket_end) { bucket_start + 1.day }
+  let(:metric) { 'conversations_count' }
+  let(:params) do
+    {
+      metric: metric,
+      type: filter_type,
+      id: filter_id,
+      since: bucket_start.to_i.to_s,
+      until: bucket_end.to_i.to_s,
+      bucket_timestamp: bucket_start.to_i.to_s,
+      group_by: 'day',
+      timezone_offset: '0',
+      business_hours: false
+    }
+  end
+  let(:filter_type) { :account }
+  let(:filter_id) { nil }
+
+  before do
+    travel_to current_time
+  end
+
+  describe '#build' do
+    context 'with conversation count metric' do
+      it 'returns conversations created in the clicked bucket' do
+        conversation = create(
+          :conversation,
+          account: account,
+          inbox: inbox,
+          created_at: bucket_start + 2.hours,
+          last_activity_at: bucket_start + 4.hours
+        )
+        last_message = create(
+          :message,
+          account: account,
+          inbox: inbox,
+          conversation: conversation,
+          message_type: :incoming,
+          content: 'Latest customer note',
+          created_at: bucket_start + 3.hours
+        )
+        conversation.update!(last_activity_at: bucket_start + 4.hours)
+        create(:conversation, account: account, inbox: inbox, created_at: bucket_start - 1.hour)
+
+        expect(drilldown[:meta]).to include(metric: 'conversations_count', record_type: 'conversation', total_count: 1)
+        expect(drilldown[:meta][:bucket]).to eq({ since: bucket_start.to_i, until: bucket_end.to_i })
+        expect(drilldown[:payload].first[:conversation][:display_id]).to eq(conversation.display_id)
+        expect(drilldown[:payload].first[:conversation][:created_at]).to eq(
+          (bucket_start + 2.hours).to_i
+        )
+        expect(drilldown[:payload].first[:conversation][:last_activity_at]).to eq(
+          (bucket_start + 4.hours).to_i
+        )
+        expect(drilldown[:payload].first[:conversation][:last_message][:id]).to eq(last_message.id)
+        expect(drilldown[:payload].first[:conversation][:last_message][:content]).to eq('Latest customer note')
+      end
+
+      it 'loads latest messages in one query for the page conversations' do
+        first_conversation = create(:conversation, account: account, inbox: inbox, created_at: bucket_start + 2.hours)
+        second_conversation = create(:conversation, account: account, inbox: inbox, created_at: bucket_start + 3.hours)
+        first_message = create(:message, account: account, inbox: inbox, conversation: first_conversation, created_at: bucket_start + 4.hours)
+        second_message = create(:message, account: account, inbox: inbox, conversation: second_conversation, created_at: bucket_start + 5.hours)
+
+        message_queries = []
+        subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |_name, _started, _finished, _unique_id, payload|
+          message_queries << payload[:sql] if payload[:sql].match?(/\ASELECT .*FROM "messages"/m) && !payload[:cached]
+        end
+
+        payload = drilldown[:payload]
+
+        expect(payload.map { |row| row[:conversation][:last_message][:id] }).to contain_exactly(
+          first_message.id,
+          second_message.id
+        )
+        expect(message_queries.size).to eq(1)
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+
+      context 'when filtering by agent' do
+        let(:metric) { 'conversations_count' }
+        let(:filter_type) { :agent }
+        let(:filter_id) { agent.id }
+        let(:agent) { create(:user, account: account) }
+        let(:other_agent) { create(:user, account: account) }
+
+        it 'returns only conversations assigned to the selected agent' do
+          conversation = create(:conversation, account: account, inbox: inbox, assignee: agent, created_at: bucket_start + 2.hours)
+          create(:conversation, account: account, inbox: inbox, assignee: other_agent, created_at: bucket_start + 3.hours)
+
+          expect(drilldown[:meta][:total_count]).to eq(1)
+          expect(drilldown[:payload].first[:conversation][:id]).to eq(conversation.id)
+        end
+      end
+    end
+
+    context 'with message count metric' do
+      let(:metric) { 'incoming_messages_count' }
+
+      it 'returns messages created in the clicked bucket' do
+        conversation = create(:conversation, account: account, inbox: inbox)
+        message = create(:message, account: account, inbox: inbox, conversation: conversation,
+                                   message_type: :incoming, content: 'Need help', created_at: bucket_start + 1.hour)
+        create(:message, account: account, inbox: inbox, conversation: conversation,
+                         message_type: :outgoing, created_at: bucket_start + 2.hours)
+
+        expect(drilldown[:meta]).to include(record_type: 'message', total_count: 1)
+        expect(drilldown[:payload].first[:record_type]).to eq('message')
+        expect(drilldown[:payload].first[:message][:id]).to eq(message.id)
+        expect(drilldown[:payload].first[:message][:content]).to eq('Need help')
+      end
+    end
+
+    context 'with first response time metric' do
+      let(:metric) { 'avg_first_response_time' }
+      let(:agent) { create(:user, account: account) }
+
+      it 'infers the related outgoing message and uses the selected metric value' do
+        conversation = create(:conversation, account: account, inbox: inbox)
+        message = create(:message, account: account, inbox: inbox, conversation: conversation,
+                                   sender: agent, message_type: :outgoing, created_at: bucket_start + 2.hours)
+        create(:reporting_event, account: account, inbox: inbox, conversation: conversation, user: agent,
+                                 name: 'first_response', value: 120, value_in_business_hours: 45,
+                                 created_at: bucket_start + 2.hours, event_end_time: message.created_at)
+
+        params[:business_hours] = true
+
+        expect(drilldown[:meta]).to include(record_type: 'message', total_count: 1)
+        expect(drilldown[:payload].first[:record_type]).to eq('message')
+        expect(drilldown[:payload].first[:message][:id]).to eq(message.id)
+        expect(drilldown[:payload].first[:metric_value]).to eq(45)
+      end
+
+      it 'loads inferred and latest messages in two queries for the page events' do
+        first_conversation = create(:conversation, account: account, inbox: inbox)
+        second_conversation = create(:conversation, account: account, inbox: inbox)
+        first_message = create(:message, account: account, inbox: inbox, conversation: first_conversation,
+                                         sender: agent, message_type: :outgoing, created_at: bucket_start + 2.hours)
+        second_message = create(:message, account: account, inbox: inbox, conversation: second_conversation,
+                                          sender: agent, message_type: :outgoing, created_at: bucket_start + 3.hours)
+        create(:reporting_event, account: account, inbox: inbox, conversation: first_conversation, user: agent,
+                                 name: 'first_response', value: 120, created_at: bucket_start + 2.hours,
+                                 event_end_time: first_message.created_at)
+        create(:reporting_event, account: account, inbox: inbox, conversation: second_conversation, user: agent,
+                                 name: 'first_response', value: 90, created_at: bucket_start + 3.hours,
+                                 event_end_time: second_message.created_at)
+
+        message_queries = []
+        subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |_name, _started, _finished, _unique_id, payload|
+          message_queries << payload[:sql] if payload[:sql].match?(/\ASELECT .*FROM "messages"/m) && !payload[:cached]
+        end
+
+        payload = drilldown[:payload]
+
+        expect(payload.map { |row| row[:message][:id] }).to contain_exactly(
+          first_message.id,
+          second_message.id
+        )
+        expect(message_queries.size).to eq(2)
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      end
+
+      it 'falls back to the conversation when no matching message is found' do
+        conversation = create(:conversation, account: account, inbox: inbox)
+        create(:reporting_event, account: account, inbox: inbox, conversation: conversation, user: agent,
+                                 name: 'first_response', value: 120, created_at: bucket_start + 2.hours,
+                                 event_end_time: bucket_start + 2.hours)
+
+        expect(drilldown[:payload].first[:record_type]).to eq('conversation')
+        expect(drilldown[:payload].first[:conversation][:id]).to eq(conversation.id)
+      end
+    end
+
+    context 'with bot handoff count metric' do
+      let(:metric) { 'bot_handoffs_count' }
+
+      it 'returns one row per handoff conversation' do
+        first_conversation = create(:conversation, account: account, inbox: inbox)
+        second_conversation = create(:conversation, account: account, inbox: inbox)
+
+        create(:reporting_event, account: account, inbox: inbox, conversation: first_conversation,
+                                 name: 'conversation_bot_handoff', created_at: bucket_start + 1.hour)
+        create(:reporting_event, account: account, inbox: inbox, conversation: first_conversation,
+                                 name: 'conversation_bot_handoff', created_at: bucket_start + 2.hours)
+        create(:reporting_event, account: account, inbox: inbox, conversation: second_conversation,
+                                 name: 'conversation_bot_handoff', created_at: bucket_start + 3.hours)
+
+        expect(drilldown[:meta][:total_count]).to eq(2)
+        expect(drilldown[:payload].map { |row| row[:conversation][:id] }).to contain_exactly(
+          first_conversation.id,
+          second_conversation.id
+        )
+        expect(drilldown[:payload].pluck(:event_name)).to all(eq('conversation_bot_handoff'))
+      end
+    end
+
+    context 'with bot resolution count metric' do
+      let(:metric) { 'bot_resolutions_count' }
+
+      before do
+        params[:until] = (bucket_start + 2.days).to_i.to_s
+      end
+
+      it 'excludes conversations with handoffs anywhere in the selected report range' do
+        resolved_conversation = create(:conversation, account: account, inbox: inbox)
+        handed_off_conversation = create(:conversation, account: account, inbox: inbox)
+
+        create(:reporting_event, account: account, inbox: inbox, conversation: resolved_conversation,
+                                 name: 'conversation_bot_resolved', created_at: bucket_start + 1.hour)
+        create(:reporting_event, account: account, inbox: inbox, conversation: handed_off_conversation,
+                                 name: 'conversation_bot_resolved', created_at: bucket_start + 2.hours)
+        create(:reporting_event, account: account, inbox: inbox, conversation: handed_off_conversation,
+                                 name: 'conversation_bot_handoff', created_at: bucket_start + 1.day)
+
+        expect(drilldown[:meta][:total_count]).to eq(1)
+        expect(drilldown[:payload].first[:conversation][:id]).to eq(resolved_conversation.id)
+      end
+    end
+  end
+end
diff --git a/spec/controllers/api/v2/accounts/report_controller_spec.rb b/spec/controllers/api/v2/accounts/report_controller_spec.rb
index 6202946a1..044a22d7a 100644
--- a/spec/controllers/api/v2/accounts/report_controller_spec.rb
+++ b/spec/controllers/api/v2/accounts/report_controller_spec.rb
@@ -233,6 +233,107 @@ RSpec.describe 'Reports API', type: :request do
     end
   end
 
+  describe 'GET /api/v2/accounts/:account_id/reports/drilldown' do
+    let(:params) do
+      super().merge(
+        metric: 'conversations_count',
+        type: :account,
+        since: start_of_today.to_s,
+        until: end_of_today.to_s,
+        bucket_timestamp: start_of_today.to_s,
+        group_by: 'day'
+      )
+    end
+
+    context 'when it is an unauthenticated user' do
+      it 'returns unauthorized' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown"
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when it is an authenticated user' do
+      it 'returns unauthorized for agents' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params,
+            headers: agent.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+
+      it 'returns drilldown records for the selected bucket' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params,
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:success)
+        json_response = response.parsed_body
+
+        expect(json_response['meta']['metric']).to eq('conversations_count')
+        expect(json_response['meta']['record_type']).to eq('conversation')
+        expect(json_response['meta']['total_count']).to eq(10)
+        expect(json_response['payload'].first['conversation']).to include('display_id', 'contact_name', 'inbox_name')
+      end
+
+      it 'returns unprocessable entity for missing bucket timestamp' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params.except(:bucket_timestamp),
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+
+      it 'returns unprocessable entity for invalid bucket timestamp' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params.merge(bucket_timestamp: 'abc'),
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+
+      it 'returns unprocessable entity for bucket timestamp outside the requested range' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params.merge(bucket_timestamp: end_of_today.to_s),
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+
+      it 'returns drilldown records for a partial first weekly bucket' do
+        range_start = Time.zone.local(2026, 5, 20, 12)
+        range_end = Time.zone.local(2026, 5, 27, 12)
+        week_start = range_start.beginning_of_week(:sunday)
+
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params.merge(
+              since: range_start.to_i.to_s,
+              until: range_end.to_i.to_s,
+              bucket_timestamp: week_start.to_i.to_s,
+              group_by: 'week'
+            ),
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:success)
+      end
+
+      it 'returns unprocessable entity for unsupported drilldown type' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params.merge(type: :unsupported),
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+    end
+  end
+
   describe 'GET /api/v2/accounts/:account_id/reports/agents' do
     context 'when it is an unauthenticated user' do
       it 'returns unauthorized' do
diff --git a/spec/enterprise/controllers/api/v1/accounts/applied_slas_controller_spec.rb b/spec/enterprise/controllers/api/v1/accounts/applied_slas_controller_spec.rb
index 299b8ac7a..e4b2bfe70 100644
--- a/spec/enterprise/controllers/api/v1/accounts/applied_slas_controller_spec.rb
+++ b/spec/enterprise/controllers/api/v1/accounts/applied_slas_controller_spec.rb
@@ -37,6 +37,21 @@ RSpec.describe 'Applied SLAs API', type: :request do
         expect(body).to include('hit_rate' => '0.0%')
       end
 
+      it 'excludes conversations with blocked contacts from metrics' do
+        create(:applied_sla, sla_policy: sla_policy1, conversation: conversation1, sla_status: 'missed')
+        create(:applied_sla, sla_policy: sla_policy1, conversation: conversation2, sla_status: 'missed')
+        conversation2.contact.update!(blocked: true)
+
+        get "/api/v1/accounts/#{account.id}/applied_slas/metrics",
+            headers: administrator.create_new_auth_token
+        expect(response).to have_http_status(:success)
+        body = JSON.parse(response.body)
+
+        expect(body).to include('total_applied_slas' => 1)
+        expect(body).to include('number_of_sla_misses' => 1)
+        expect(body).to include('hit_rate' => '0.0%')
+      end
+
       it 'filters sla metrics based on a date range' do
         create(:applied_sla, sla_policy: sla_policy1, conversation: conversation1, created_at: 10.days.ago)
         create(:applied_sla, sla_policy: sla_policy1, conversation: conversation2, created_at: 3.days.ago)
@@ -129,6 +144,22 @@ RSpec.describe 'Applied SLAs API', type: :request do
         csv_data = CSV.parse(response.body)
         csv_data.reject! { |row| row.all?(&:nil?) }
         expect(csv_data.size).to eq(3)
+        conversation_ids = csv_data.drop(1).map { |row| row[0].to_i }
+        expect(conversation_ids).to contain_exactly(conversation1.display_id, conversation2.display_id)
+      end
+
+      it 'excludes conversations with blocked contacts from the CSV file' do
+        create(:applied_sla, sla_policy: sla_policy1, conversation: conversation1, sla_status: 'missed')
+        create(:applied_sla, sla_policy: sla_policy1, conversation: conversation2, sla_status: 'missed')
+        conversation2.contact.update!(blocked: true)
+
+        get "/api/v1/accounts/#{account.id}/applied_slas/download",
+            headers: administrator.create_new_auth_token
+
+        expect(response).to have_http_status(:success)
+        csv_data = CSV.parse(response.body)
+        csv_data.reject! { |row| row.all?(&:nil?) }
+        expect(csv_data.size).to eq(2)
         expect(csv_data[1][0].to_i).to eq(conversation1.display_id)
       end
     end
@@ -156,6 +187,21 @@ RSpec.describe 'Applied SLAs API', type: :request do
         expect(body['meta']).to include('count' => 1)
       end
 
+      it 'excludes conversations with blocked contacts' do
+        create(:applied_sla, sla_policy: sla_policy1, conversation: conversation1, sla_status: 'missed')
+        create(:applied_sla, sla_policy: sla_policy1, conversation: conversation2, sla_status: 'missed')
+        conversation2.contact.update!(blocked: true)
+
+        get "/api/v1/accounts/#{account.id}/applied_slas",
+            headers: administrator.create_new_auth_token
+        expect(response).to have_http_status(:success)
+        body = JSON.parse(response.body)
+
+        expect(body['payload'].size).to eq(1)
+        expect(body['payload'].first['conversation']['id']).to eq(conversation1.display_id)
+        expect(body['meta']).to include('count' => 1)
+      end
+
       it 'filters applied slas based on a date range' do
         create(:applied_sla, sla_policy: sla_policy1, conversation: conversation1, created_at: 10.days.ago, sla_status: 'missed')
         create(:applied_sla, sla_policy: sla_policy1, conversation: conversation2, created_at: 3.days.ago, sla_status: 'missed')
diff --git a/spec/enterprise/controllers/api/v1/accounts/conversations_controller_spec.rb b/spec/enterprise/controllers/api/v1/accounts/conversations_controller_spec.rb
index 472dc959b..7d053eccf 100644
--- a/spec/enterprise/controllers/api/v1/accounts/conversations_controller_spec.rb
+++ b/spec/enterprise/controllers/api/v1/accounts/conversations_controller_spec.rb
@@ -18,6 +18,21 @@ RSpec.describe 'Conversations API', type: :request do
       expect(response.parsed_body['sla_events'].first['id']).to eq(sla_event.id)
     end
 
+    it 'returns cleared SLA data when the contact is blocked' do
+      account.enable_features!('sla')
+      conversation = create(:conversation, account: account)
+      applied_sla = create(:applied_sla, conversation: conversation)
+      create(:sla_event, conversation: conversation, applied_sla: applied_sla)
+      conversation.contact.update!(blocked: true)
+
+      get "/api/v1/accounts/#{account.id}/conversations/#{conversation.display_id}", headers: administrator.create_new_auth_token
+
+      expect(response).to have_http_status(:ok)
+      expect(response.parsed_body['sla_policy_id']).to be_nil
+      expect(response.parsed_body['applied_sla']).to be_nil
+      expect(response.parsed_body['sla_events']).to eq([])
+    end
+
     it 'does not return SLA data for the conversation if the feature is disabled' do
       account.disable_features!('sla')
       conversation = create(:conversation, account: account)
diff --git a/spec/enterprise/controllers/api/v1/accounts/whatsapp_calls_controller_spec.rb b/spec/enterprise/controllers/api/v1/accounts/whatsapp_calls_controller_spec.rb
index 500255983..a66249d5a 100644
--- a/spec/enterprise/controllers/api/v1/accounts/whatsapp_calls_controller_spec.rb
+++ b/spec/enterprise/controllers/api/v1/accounts/whatsapp_calls_controller_spec.rb
@@ -58,6 +58,15 @@ RSpec.describe 'WhatsApp Calls API', type: :request do
 
       expect(response).to have_http_status(:unprocessable_entity)
     end
+
+    it 'returns 409 when the call has already ended (caller hung up mid-ring)' do
+      call.update!(status: 'no_answer')
+
+      post "/api/v1/accounts/#{account.id}/whatsapp_calls/#{call.id}/accept",
+           params: { sdp_answer: 'sdp_answer' }, headers: agent.create_new_auth_token
+
+      expect(response).to have_http_status(:conflict)
+    end
   end
 
   describe 'POST /api/v1/accounts/:account_id/whatsapp_calls/:id/reject' do
@@ -104,6 +113,31 @@ RSpec.describe 'WhatsApp Calls API', type: :request do
       expect(Call.find_by(provider_call_id: 'wacid_outbound')).to have_attributes(direction: 'outgoing', status: 'ringing')
     end
 
+    it 'assigns the conversation to the agent placing the call when it is unassigned' do
+      allow(provider_service).to receive(:initiate_call).and_return({ 'calls' => [{ 'id' => 'wacid_outbound' }] })
+
+      post "/api/v1/accounts/#{account.id}/whatsapp_calls/initiate",
+           params: { conversation_id: initiate_conversation.display_id, sdp_offer: 'sdp_offer' },
+           headers: agent.create_new_auth_token
+
+      expect(response).to have_http_status(:ok)
+      expect(initiate_conversation.reload.assignee_id).to eq(agent.id)
+    end
+
+    it 'keeps the existing assignee when the conversation is already assigned' do
+      other_agent = create(:user, account: account, role: :agent)
+      create(:inbox_member, user: other_agent, inbox: inbox)
+      initiate_conversation.update!(assignee: other_agent)
+      allow(provider_service).to receive(:initiate_call).and_return({ 'calls' => [{ 'id' => 'wacid_outbound' }] })
+
+      post "/api/v1/accounts/#{account.id}/whatsapp_calls/initiate",
+           params: { conversation_id: initiate_conversation.display_id, sdp_offer: 'sdp_offer' },
+           headers: agent.create_new_auth_token
+
+      expect(response).to have_http_status(:ok)
+      expect(initiate_conversation.reload.assignee_id).to eq(other_agent.id)
+    end
+
     it 'sends a permission request and records the wamid when Meta returns NoCallPermission' do
       allow(provider_service).to receive(:initiate_call).and_raise(Voice::CallErrors::NoCallPermission)
       allow(provider_service).to receive(:send_call_permission_request).and_return({ 'messages' => [{ 'id' => 'wamid.req_xyz' }] })
diff --git a/spec/enterprise/controllers/enterprise/api/v1/accounts/conversations_controller_spec.rb b/spec/enterprise/controllers/enterprise/api/v1/accounts/conversations_controller_spec.rb
index fb028b76f..4fe7f46e5 100644
--- a/spec/enterprise/controllers/enterprise/api/v1/accounts/conversations_controller_spec.rb
+++ b/spec/enterprise/controllers/enterprise/api/v1/accounts/conversations_controller_spec.rb
@@ -36,6 +36,19 @@ RSpec.describe 'Enterprise Conversations API', type: :request do
         expect(response).to have_http_status(:unprocessable_entity)
         expect(JSON.parse(response.body, symbolize_names: true)[:message]).to eq('Sla policy conversation already has a different sla')
       end
+
+      it 'throws error if conversation contact is blocked' do
+        conversation.contact.update!(blocked: true)
+
+        patch "/api/v1/accounts/#{account.id}/conversations/#{conversation.display_id}",
+              params: params,
+              headers: agent.create_new_auth_token,
+              as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(JSON.parse(response.body, symbolize_names: true)[:message])
+          .to eq('Sla policy cannot be assigned to conversations with blocked contacts')
+      end
     end
   end
 end
diff --git a/spec/enterprise/controllers/enterprise/api/v1/accounts_controller_spec.rb b/spec/enterprise/controllers/enterprise/api/v1/accounts_controller_spec.rb
index b2a920b07..cfabf6b7e 100644
--- a/spec/enterprise/controllers/enterprise/api/v1/accounts_controller_spec.rb
+++ b/spec/enterprise/controllers/enterprise/api/v1/accounts_controller_spec.rb
@@ -256,6 +256,14 @@ RSpec.describe 'Enterprise Billing APIs', type: :request do
                { 'name' => 'Hacker', 'product_id' => ['prod_hacker'], 'price_ids' => ['price_hacker'] },
                { 'name' => 'Business', 'product_id' => ['prod_business'], 'price_ids' => ['price_business'] }
              ])
+      create(:installation_config, name: 'CAPTAIN_TOPUP_OPTIONS', value: {
+               'usd' => [
+                 { 'credits' => 1000, 'amount' => 20.0 },
+                 { 'credits' => 2500, 'amount' => 50.0 },
+                 { 'credits' => 6000, 'amount' => 100.0 },
+                 { 'credits' => 12_000, 'amount' => 200.0 }
+               ]
+             })
     end
 
     it 'returns unauthorized for unauthenticated user' do
diff --git a/spec/enterprise/controllers/enterprise/api/v2/accounts/reports_controller_spec.rb b/spec/enterprise/controllers/enterprise/api/v2/accounts/reports_controller_spec.rb
index ff05af909..a49e2b456 100644
--- a/spec/enterprise/controllers/enterprise/api/v2/accounts/reports_controller_spec.rb
+++ b/spec/enterprise/controllers/enterprise/api/v2/accounts/reports_controller_spec.rb
@@ -64,4 +64,28 @@ RSpec.describe 'Enterprise Reports API', type: :request do
       end
     end
   end
+
+  describe 'GET /api/v2/accounts/:account_id/reports/drilldown' do
+    context 'when it is an agent with report_manage permission' do
+      let(:params) do
+        super().merge(
+          metric: 'conversations_count',
+          type: :account,
+          since: start_of_today.to_s,
+          until: end_of_today.to_s,
+          bucket_timestamp: start_of_today.to_s,
+          group_by: 'day'
+        )
+      end
+
+      it 'returns unauthorized' do
+        get "/api/v2/accounts/#{account.id}/reports/drilldown",
+            params: params,
+            headers: agent_with_role.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+  end
 end
diff --git a/spec/enterprise/jobs/onboarding/help_center_article_writer_job_spec.rb b/spec/enterprise/jobs/onboarding/help_center_article_writer_job_spec.rb
index b01ec35e3..ff7b434da 100644
--- a/spec/enterprise/jobs/onboarding/help_center_article_writer_job_spec.rb
+++ b/spec/enterprise/jobs/onboarding/help_center_article_writer_job_spec.rb
@@ -102,6 +102,47 @@ RSpec.describe Onboarding::HelpCenterArticleWriterJob do
     end
   end
 
+  describe 'catch-all failure handling' do
+    # Any exception the job does not specifically handle (e.g.
+    # ActiveRecord::RecordInvalid from articles.create!, SSL errors, OOM)
+    # must still finalize the generation so state cannot wedge in
+    # "generating" at total - 1 until the Redis TTL expires.
+
+    it 'increments the counter on an unhandled StandardError without re-raising' do
+      allow(Onboarding::HelpCenterArticleBuilder).to receive(:new).and_raise(
+        StandardError, 'unexpected boom'
+      )
+
+      expect { described_class.perform_now(*job_args) }.not_to raise_error
+
+      expect(Onboarding::HelpCenterGenerationState.current(generation_id)).to include('finished' => '1')
+    end
+
+    it 'marks generation completed when the final writer fails with an unhandled error' do
+      allow(Onboarding::HelpCenterArticleBuilder).to receive(:new).and_raise(
+        StandardError, 'unexpected boom'
+      )
+      Onboarding::HelpCenterGenerationState.record_article_finished(generation_id)
+
+      described_class.perform_now(*job_args)
+
+      expect(Onboarding::HelpCenterGenerationState.current(generation_id)).to include(
+        'status' => 'completed', 'finished' => '2'
+      )
+    end
+
+    it 'logs the failure so the error is not silent' do
+      allow(Onboarding::HelpCenterArticleBuilder).to receive(:new).and_raise(
+        StandardError, 'unexpected boom'
+      )
+      allow(Rails.logger).to receive(:warn)
+
+      described_class.perform_now(*job_args)
+
+      expect(Rails.logger).to have_received(:warn).with(/gen=#{generation_id} failed: StandardError unexpected boom/)
+    end
+  end
+
   describe 'missing state' do
     let(:built_article) { instance_double(Article, id: 9876) }
 
diff --git a/spec/enterprise/jobs/sla/process_account_applied_slas_job_spec.rb b/spec/enterprise/jobs/sla/process_account_applied_slas_job_spec.rb
index abddfca23..e99a5087b 100644
--- a/spec/enterprise/jobs/sla/process_account_applied_slas_job_spec.rb
+++ b/spec/enterprise/jobs/sla/process_account_applied_slas_job_spec.rb
@@ -8,6 +8,11 @@ RSpec.describe Sla::ProcessAccountAppliedSlasJob do
     let!(:hit_applied_sla) { create(:applied_sla, account: account, sla_policy: sla_policy, sla_status: 'hit') }
     let!(:miss_applied_sla) { create(:applied_sla, account: account, sla_policy: sla_policy, sla_status: 'missed') }
     let!(:active_with_misses_applied_sla) { create(:applied_sla, account: account, sla_policy: sla_policy, sla_status: 'active_with_misses') }
+    let!(:blocked_contact_applied_sla) { create(:applied_sla, account: account, sla_policy: sla_policy, sla_status: 'active') }
+
+    before do
+      blocked_contact_applied_sla.conversation.contact.update!(blocked: true)
+    end
 
     it 'enqueues the job' do
       expect { described_class.perform_later(account) }.to have_enqueued_job(described_class)
@@ -18,6 +23,7 @@ RSpec.describe Sla::ProcessAccountAppliedSlasJob do
     it 'calls the ProcessAppliedSlaJob for both active and active_with_misses' do
       expect(Sla::ProcessAppliedSlaJob).to receive(:perform_later).with(active_with_misses_applied_sla).and_call_original
       expect(Sla::ProcessAppliedSlaJob).to receive(:perform_later).with(applied_sla).and_call_original
+      expect(Sla::ProcessAppliedSlaJob).not_to receive(:perform_later).with(blocked_contact_applied_sla)
       described_class.perform_now(account)
     end
 
diff --git a/spec/enterprise/models/applied_sla_spec.rb b/spec/enterprise/models/applied_sla_spec.rb
index a1433f6a2..df685444c 100644
--- a/spec/enterprise/models/applied_sla_spec.rb
+++ b/spec/enterprise/models/applied_sla_spec.rb
@@ -22,10 +22,45 @@ RSpec.describe AppliedSla, type: :model do
           sla_first_response_time_threshold: applied_sla.sla_policy.first_response_time_threshold,
           sla_next_response_time_threshold: applied_sla.sla_policy.next_response_time_threshold,
           sla_only_during_business_hours: applied_sla.sla_policy.only_during_business_hours,
-          sla_resolution_time_threshold: applied_sla.sla_policy.resolution_time_threshold
+          sla_resolution_time_threshold: applied_sla.sla_policy.resolution_time_threshold,
+          sla_frt_due_at: applied_sla.frt_due_at,
+          sla_nrt_due_at: applied_sla.nrt_due_at,
+          sla_rt_due_at: applied_sla.rt_due_at
         }
       )
     end
+
+    it 'shares the working hours cache while serializing due times' do
+      account = create(:account)
+      inbox = create(:inbox, account: account, working_hours_enabled: true, timezone: 'UTC')
+      sla_policy = create(
+        :sla_policy,
+        account: account,
+        first_response_time_threshold: 1.hour,
+        next_response_time_threshold: 30.minutes,
+        resolution_time_threshold: 2.hours,
+        only_during_business_hours: true
+      )
+      start_time = Time.zone.parse('2024-01-17 10:00:00')
+      conversation = create(
+        :conversation,
+        account: account,
+        inbox: inbox,
+        created_at: start_time,
+        waiting_since: start_time + 1.hour
+      )
+      conversation.update!(waiting_since: start_time + 1.hour)
+      applied_sla = create(:applied_sla, account: account, conversation: conversation, sla_policy: sla_policy)
+      working_hours = inbox.working_hours
+
+      expect(working_hours).to receive(:index_by).once.and_call_original
+
+      expect(applied_sla.push_event_data).to include(
+        sla_frt_due_at: Time.zone.parse('2024-01-17 11:00:00').to_i,
+        sla_nrt_due_at: Time.zone.parse('2024-01-17 11:30:00').to_i,
+        sla_rt_due_at: Time.zone.parse('2024-01-17 12:00:00').to_i
+      )
+    end
   end
 
   describe 'validates_factory' do
@@ -34,4 +69,100 @@ RSpec.describe AppliedSla, type: :model do
       expect(applied_sla.sla_status).to eq 'active'
     end
   end
+
+  describe '.with_sla_applicable_conversation' do
+    it 'excludes blocked contacts and keeps conversations with missing contacts' do
+      applied_sla = create(:applied_sla)
+      blocked_applied_sla = create(:applied_sla)
+      missing_contact_applied_sla = create(:applied_sla)
+
+      blocked_applied_sla.conversation.contact.update!(blocked: true)
+      missing_contact_applied_sla.conversation.update_columns(contact_id: nil, contact_inbox_id: nil) # rubocop:disable Rails/SkipsModelValidations
+
+      expect(described_class.with_sla_applicable_conversation).to include(applied_sla, missing_contact_applied_sla)
+      expect(described_class.with_sla_applicable_conversation).not_to include(blocked_applied_sla)
+    end
+  end
+
+  describe '#frt_due_at' do
+    it 'returns nil when first_response_time_threshold is blank' do
+      applied_sla = create(:applied_sla)
+      applied_sla.sla_policy.update!(first_response_time_threshold: nil)
+
+      expect(applied_sla.frt_due_at).to be_nil
+    end
+
+    it 'returns deadline based on conversation created_at' do
+      applied_sla = create(:applied_sla)
+      applied_sla.sla_policy.update!(first_response_time_threshold: 3600, only_during_business_hours: false)
+
+      expected_deadline = applied_sla.conversation.created_at.to_i + 3600
+      expect(applied_sla.frt_due_at).to eq(expected_deadline)
+    end
+  end
+
+  describe '#nrt_due_at' do
+    it 'returns nil when next_response_time_threshold is blank' do
+      applied_sla = create(:applied_sla)
+      applied_sla.sla_policy.update!(next_response_time_threshold: nil)
+
+      expect(applied_sla.nrt_due_at).to be_nil
+    end
+
+    it 'returns nil when waiting_since is blank' do
+      applied_sla = create(:applied_sla)
+      applied_sla.sla_policy.update!(next_response_time_threshold: 1800)
+      applied_sla.conversation.update!(waiting_since: nil)
+
+      expect(applied_sla.nrt_due_at).to be_nil
+    end
+
+    it 'returns deadline based on waiting_since' do
+      applied_sla = create(:applied_sla)
+      waiting_since = 2.hours.ago
+      applied_sla.sla_policy.update!(next_response_time_threshold: 1800, only_during_business_hours: false)
+      applied_sla.conversation.update!(waiting_since: waiting_since)
+
+      expected_deadline = waiting_since.to_i + 1800
+      expect(applied_sla.nrt_due_at).to eq(expected_deadline)
+    end
+  end
+
+  describe '#rt_due_at' do
+    it 'returns nil when resolution_time_threshold is blank' do
+      applied_sla = create(:applied_sla)
+      applied_sla.sla_policy.update!(resolution_time_threshold: nil)
+
+      expect(applied_sla.rt_due_at).to be_nil
+    end
+
+    it 'returns deadline based on conversation created_at' do
+      applied_sla = create(:applied_sla)
+      applied_sla.sla_policy.update!(resolution_time_threshold: 7200, only_during_business_hours: false)
+
+      expected_deadline = applied_sla.conversation.created_at.to_i + 7200
+      expect(applied_sla.rt_due_at).to eq(expected_deadline)
+    end
+  end
+
+  describe '#calculate_due_at' do
+    it 'uses BusinessHoursService when only_during_business_hours is true' do
+      account = create(:account)
+      inbox = create(:inbox, account: account, working_hours_enabled: true)
+      sla_policy = create(:sla_policy, account: account, first_response_time_threshold: 3600, only_during_business_hours: true)
+      conversation = create(:conversation, account: account, inbox: inbox)
+      applied_sla = create(:applied_sla, sla_policy: sla_policy, conversation: conversation, account: account)
+
+      expect(Sla::BusinessHoursService).to receive(:new).and_call_original
+      applied_sla.frt_due_at
+    end
+
+    it 'does not use BusinessHoursService when only_during_business_hours is false' do
+      applied_sla = create(:applied_sla)
+      applied_sla.sla_policy.update!(first_response_time_threshold: 3600, only_during_business_hours: false)
+
+      expect(Sla::BusinessHoursService).not_to receive(:new)
+      applied_sla.frt_due_at
+    end
+  end
 end
diff --git a/spec/enterprise/models/conversation_spec.rb b/spec/enterprise/models/conversation_spec.rb
index f7116eb54..7138c468c 100644
--- a/spec/enterprise/models/conversation_spec.rb
+++ b/spec/enterprise/models/conversation_spec.rb
@@ -59,6 +59,30 @@ RSpec.describe Conversation, type: :model do
         conversation.save!
         expect(conversation.applied_sla.sla_policy_id).to eq(sla_policy.id)
       end
+
+      it 'throws error if contact is blocked' do
+        conversation.contact.update!(blocked: true)
+        conversation.sla_policy = sla_policy
+
+        expect(conversation.valid?).to be false
+        expect(conversation.errors[:sla_policy]).to eq(['cannot be assigned to conversations with blocked contacts'])
+      end
+
+      it 'allows assigning sla after contact is unblocked' do
+        conversation.contact.update!(blocked: true)
+        conversation.contact.update!(blocked: false)
+        conversation.sla_policy = sla_policy
+
+        conversation.save!
+
+        expect(conversation.applied_sla.sla_policy_id).to eq(sla_policy.id)
+      end
+
+      it 'keeps existing behavior when contact is missing' do
+        conversation.update_columns(contact_id: nil, contact_inbox_id: nil) # rubocop:disable Rails/SkipsModelValidations
+
+        expect(conversation.reload.sla_applicable?).to be true
+      end
     end
 
     context 'when conversation already has a different sla' do
diff --git a/spec/enterprise/presenters/conversations/event_data_presenter_spec.rb b/spec/enterprise/presenters/conversations/event_data_presenter_spec.rb
index f9897c96d..d87a43363 100644
--- a/spec/enterprise/presenters/conversations/event_data_presenter_spec.rb
+++ b/spec/enterprise/presenters/conversations/event_data_presenter_spec.rb
@@ -20,6 +20,19 @@ RSpec.describe Conversations::EventDataPresenter do
       )
     end
 
+    it 'returns push event payload without active sla data when contact is blocked' do
+      conversation.account.enable_features!('sla')
+      conversation.contact.update!(blocked: true)
+
+      expect(presenter.push_data).to include(
+        {
+          applied_sla: nil,
+          sla_events: [],
+          sla_policy_id: nil
+        }
+      )
+    end
+
     it 'returns push event payload without applied sla & sla events if the feature is disabled' do
       conversation.account.disable_features!('sla')
 
diff --git a/spec/enterprise/services/enterprise/action_service_spec.rb b/spec/enterprise/services/enterprise/action_service_spec.rb
index a77a039dd..9396dc15d 100644
--- a/spec/enterprise/services/enterprise/action_service_spec.rb
+++ b/spec/enterprise/services/enterprise/action_service_spec.rb
@@ -20,6 +20,13 @@ describe ActionService do
         expect(applied_sla.conversation_id).to eq(conversation.id)
         expect(applied_sla.sla_status).to eq('active')
       end
+
+      it 'does not add the sla policy when contact is blocked' do
+        conversation.contact.update!(blocked: true)
+
+        expect { action_service.add_sla([sla_policy.id]) }.not_to change(AppliedSla, :count)
+        expect(conversation.reload.sla_policy_id).to be_nil
+      end
     end
 
     context 'when sla_policy_id is not present' do
diff --git a/spec/enterprise/services/enterprise/billing/create_stripe_customer_service_spec.rb b/spec/enterprise/services/enterprise/billing/create_stripe_customer_service_spec.rb
index d2dbf646a..a7b2e8322 100644
--- a/spec/enterprise/services/enterprise/billing/create_stripe_customer_service_spec.rb
+++ b/spec/enterprise/services/enterprise/billing/create_stripe_customer_service_spec.rb
@@ -82,7 +82,8 @@ describe Enterprise::Billing::CreateStripeCustomerService do
           subscribed_quantity: 2,
           plan_name: 'A Plan Name',
           subscription_status: 'active',
-          subscription_ends_on: subscription_ends_on
+          subscription_ends_on: subscription_ends_on,
+          billing_currency: 'usd'
         }.with_indifferent_access
       )
     end
@@ -95,7 +96,9 @@ describe Enterprise::Billing::CreateStripeCustomerService do
 
       create_stripe_customer_service.new(account: account).perform
 
-      expect(Stripe::Customer).to have_received(:create).with({ name: account.name, email: admin1.email })
+      expect(Stripe::Customer).to have_received(:create).with(
+        { name: account.name, email: admin1.email }
+      )
       expect(Stripe::Subscription)
         .to have_received(:create)
         .with({ customer: customer.id, items: [{ price: 'price_hacker_random', quantity: 2 }] })
@@ -108,10 +111,27 @@ describe Enterprise::Billing::CreateStripeCustomerService do
           subscribed_quantity: 2,
           plan_name: 'A Plan Name',
           subscription_status: 'active',
-          subscription_ends_on: subscription_ends_on
+          subscription_ends_on: subscription_ends_on,
+          billing_currency: 'usd'
         }.with_indifferent_access
       )
     end
+
+    it 'sets the billing country override when the account currency requires it' do
+      with_modified_env ENABLE_MULTI_CURRENCY_BILLING: 'true' do
+        account.update!(custom_attributes: { billing_currency: 'brl' })
+        customer = double
+        allow(Stripe::Customer).to receive(:create).and_return(customer)
+        allow(customer).to receive(:id).and_return('cus_random_number')
+        allow(Stripe::Subscription).to receive(:create).and_return(created_subscription)
+
+        create_stripe_customer_service.new(account: account).perform
+
+        expect(Stripe::Customer).to have_received(:create).with(
+          { name: account.name, email: admin1.email, address: { country: 'BR' }, preferred_locales: ['pt-BR'] }
+        )
+      end
+    end
   end
 
   describe 'when checking for existing subscriptions' do
diff --git a/spec/enterprise/services/enterprise/billing/currencies_spec.rb b/spec/enterprise/services/enterprise/billing/currencies_spec.rb
new file mode 100644
index 000000000..84172137e
--- /dev/null
+++ b/spec/enterprise/services/enterprise/billing/currencies_spec.rb
@@ -0,0 +1,36 @@
+require 'rails_helper'
+
+describe Enterprise::Billing::Currencies do
+  describe 'Brazilian Real (brl)' do
+    it 'is a supported currency' do
+      expect(described_class.supported?('brl')).to be(true)
+    end
+
+    it 'recognizes brl regardless of casing or surrounding whitespace' do
+      expect(described_class.supported?('  BRL ')).to be(true)
+      expect(described_class.normalize('  BRL ')).to eq('brl')
+    end
+
+    it 'keeps brl when coercing to a supported code' do
+      expect(described_class.to_supported('BRL')).to eq('brl')
+    end
+
+    it 'defaults the pt_BR account locale to brl' do
+      expect(described_class.for_locale('pt_BR')).to eq('brl')
+    end
+
+    it 'maps brl to Brazil and the pt-BR checkout locale' do
+      expect(described_class.country_for('brl')).to eq('BR')
+      expect(described_class.preferred_locale_for('brl')).to eq('pt-BR')
+    end
+
+    it 'falls back to the usd default for unsupported input' do
+      expect(described_class.to_supported('eur')).to eq('usd')
+    end
+
+    it 'does not set a country override for usd customers' do
+      expect(described_class.country_for('usd')).to be_nil
+      expect(described_class.preferred_locale_for('usd')).to be_nil
+    end
+  end
+end
diff --git a/spec/enterprise/services/enterprise/billing/topup_checkout_service_spec.rb b/spec/enterprise/services/enterprise/billing/topup_checkout_service_spec.rb
index fa4c052a1..1836cb39d 100644
--- a/spec/enterprise/services/enterprise/billing/topup_checkout_service_spec.rb
+++ b/spec/enterprise/services/enterprise/billing/topup_checkout_service_spec.rb
@@ -15,6 +15,15 @@ describe Enterprise::Billing::TopupCheckoutService do
              { 'name' => 'Business', 'product_id' => ['prod_business'], 'price_ids' => ['price_business'] }
            ])
 
+    create(:installation_config, name: 'CAPTAIN_TOPUP_OPTIONS', value: {
+             'usd' => [
+               { 'credits' => 1000, 'amount' => 20.0 },
+               { 'credits' => 2500, 'amount' => 50.0 },
+               { 'credits' => 6000, 'amount' => 100.0 },
+               { 'credits' => 12_000, 'amount' => 200.0 }
+             ]
+           })
+
     account.update!(
       custom_attributes: { plan_name: 'Business', stripe_customer_id: stripe_customer_id },
       limits: { 'captain_responses' => 500 }
diff --git a/spec/enterprise/services/sla/business_hours_service_spec.rb b/spec/enterprise/services/sla/business_hours_service_spec.rb
new file mode 100644
index 000000000..31205c934
--- /dev/null
+++ b/spec/enterprise/services/sla/business_hours_service_spec.rb
@@ -0,0 +1,184 @@
+require 'rails_helper'
+
+RSpec.describe Sla::BusinessHoursService do
+  let(:account) { create(:account) }
+  let(:inbox) { create(:inbox, account: account, working_hours_enabled: true, timezone: 'UTC') }
+
+  # Default working hours: Mon-Fri 9:00-17:00 UTC, Sat-Sun closed
+  describe '#deadline' do
+    context 'when business hours should not apply' do
+      it 'returns wall-clock deadline when working_hours_enabled is false' do
+        inbox.update!(working_hours_enabled: false)
+        start_time = Time.zone.parse('2024-01-19 16:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: start_time, threshold_seconds: 3600)
+
+        expect(service.deadline.to_i).to eq((start_time + 1.hour).to_i)
+      end
+
+      it 'returns wall-clock deadline when all days are closed' do
+        inbox.working_hours.find_each { |wh| wh.update!(closed_all_day: true) }
+        start_time = Time.zone.parse('2024-01-19 16:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: start_time, threshold_seconds: 3600)
+
+        expect(service.deadline.to_i).to eq((start_time + 1.hour).to_i)
+      end
+    end
+
+    context 'when start time is during business hours' do
+      it 'calculates deadline within the same day' do
+        # Wednesday 10:00 AM + 2 hours = Wednesday 12:00 PM
+        start_time = Time.zone.parse('2024-01-17 10:00:00') # Wednesday
+        expected_deadline = Time.zone.parse('2024-01-17 12:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: start_time, threshold_seconds: 2.hours)
+
+        expect(service.deadline.to_i).to eq(expected_deadline.to_i)
+      end
+
+      it 'spans to next business day when threshold exceeds remaining hours' do
+        # Friday 4:00 PM + 2 hours = Monday 10:00 AM (1h Friday + 1h Monday)
+        friday_4pm = Time.zone.parse('2024-01-19 16:00:00')
+        monday_10am = Time.zone.parse('2024-01-22 10:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: friday_4pm, threshold_seconds: 2.hours)
+
+        expect(service.deadline.to_i).to eq(monday_10am.to_i)
+      end
+    end
+
+    context 'when start time is before business hours' do
+      it 'starts counting from business hours open time' do
+        # Wednesday 7:00 AM + 2 hours = Wednesday 11:00 AM (starts at 9 AM)
+        start_time = Time.zone.parse('2024-01-17 07:00:00') # Wednesday 7 AM
+        expected_deadline = Time.zone.parse('2024-01-17 11:00:00') # Wednesday 11 AM
+
+        service = described_class.new(inbox: inbox, start_time: start_time, threshold_seconds: 2.hours)
+
+        expect(service.deadline.to_i).to eq(expected_deadline.to_i)
+      end
+    end
+
+    context 'when start time is after business hours' do
+      it 'starts counting from next business day' do
+        # Wednesday 6:00 PM + 2 hours = Thursday 11:00 AM
+        start_time = Time.zone.parse('2024-01-17 18:00:00') # Wednesday 6 PM
+        expected_deadline = Time.zone.parse('2024-01-18 11:00:00') # Thursday 11 AM
+
+        service = described_class.new(inbox: inbox, start_time: start_time, threshold_seconds: 2.hours)
+
+        expect(service.deadline.to_i).to eq(expected_deadline.to_i)
+      end
+    end
+
+    context 'when start time is on a closed day' do
+      it 'starts counting from next business day' do
+        # Saturday 10:00 AM + 2 hours = Monday 11:00 AM
+        saturday = Time.zone.parse('2024-01-20 10:00:00')
+        monday_11am = Time.zone.parse('2024-01-22 11:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: saturday, threshold_seconds: 2.hours)
+
+        expect(service.deadline.to_i).to eq(monday_11am.to_i)
+      end
+    end
+
+    context 'when threshold spans multiple days' do
+      it 'calculates correctly across multiple business days' do
+        # Monday 4:00 PM + 10 hours = Wednesday 10:00 AM
+        # Monday: 1h (4-5 PM), Tuesday: 8h (9-5), Wednesday: 1h (9-10 AM)
+        monday_4pm = Time.zone.parse('2024-01-15 16:00:00')
+        wednesday_10am = Time.zone.parse('2024-01-17 10:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: monday_4pm, threshold_seconds: 10.hours)
+
+        expect(service.deadline.to_i).to eq(wednesday_10am.to_i)
+      end
+
+      it 'reuses loaded working hours while calculating across days' do
+        monday_4pm = Time.zone.parse('2024-01-15 16:00:00')
+        wednesday_10am = Time.zone.parse('2024-01-17 10:00:00')
+        working_hours = inbox.working_hours
+        service = described_class.new(inbox: inbox, start_time: monday_4pm, threshold_seconds: 10.hours)
+
+        expect(working_hours).to receive(:index_by).once.and_call_original
+        expect(working_hours).not_to receive(:find_by)
+
+        expect(service.deadline.to_i).to eq(wednesday_10am.to_i)
+      end
+    end
+
+    context 'with different timezone' do
+      it 'respects inbox timezone' do
+        inbox.update!(timezone: 'America/New_York')
+        # Friday 4:00 PM EST + 2 hours = Monday 10:00 AM EST
+        friday_4pm_est = Time.zone.parse('2024-01-19 16:00:00 EST')
+        monday_10am_est = Time.zone.parse('2024-01-22 10:00:00 EST')
+
+        service = described_class.new(inbox: inbox, start_time: friday_4pm_est, threshold_seconds: 2.hours)
+
+        expect(service.deadline.to_i).to eq(monday_10am_est.to_i)
+      end
+    end
+
+    context 'when day is open all day' do
+      it 'treats the day as 24 hours of business time' do
+        # Set Saturday to open_all_day (0:00 - 23:59)
+        inbox.working_hours.find_by(day_of_week: 6).update!(open_all_day: true, closed_all_day: false)
+
+        # Saturday 10:00 AM + 2 hours = Saturday 12:00 PM
+        saturday_10am = Time.zone.parse('2024-01-20 10:00:00')
+        saturday_12pm = Time.zone.parse('2024-01-20 12:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: saturday_10am, threshold_seconds: 2.hours)
+
+        expect(service.deadline.to_i).to eq(saturday_12pm.to_i)
+      end
+
+      it 'includes the final minute in the business-time window' do
+        inbox.working_hours.find_by(day_of_week: 6).update!(open_all_day: true, closed_all_day: false)
+
+        saturday_midnight = Time.zone.parse('2024-01-20 00:00:00')
+        sunday_midnight = Time.zone.parse('2024-01-21 00:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: saturday_midnight, threshold_seconds: 24.hours)
+
+        expect(service.deadline.to_i).to eq(sunday_midnight.to_i)
+      end
+    end
+
+    context 'when days have different business hours' do
+      it 'uses the correct close time after advancing to next day' do
+        # Monday (day 1) closes at 17:00, Tuesday (day 2) closes at 20:00
+        inbox.working_hours.find_by(day_of_week: 1).update!(open_hour: 9, close_hour: 17)
+        inbox.working_hours.find_by(day_of_week: 2).update!(open_hour: 9, close_hour: 20)
+
+        # Start at Monday 18:00 (after close) + 10 hours
+        # Should start counting from Tuesday 9:00 AM
+        # Tuesday has 11 hours available (9:00-20:00), so 10 hours = Tuesday 19:00
+        monday_6pm = Time.zone.parse('2024-01-15 18:00:00') # Monday
+        tuesday_7pm = Time.zone.parse('2024-01-16 19:00:00') # Tuesday
+
+        service = described_class.new(inbox: inbox, start_time: monday_6pm, threshold_seconds: 10.hours)
+
+        expect(service.deadline.to_i).to eq(tuesday_7pm.to_i)
+      end
+
+      it 'spans correctly across days with varying hours' do
+        # Monday (day 1): 9:00-17:00 (8h), Tuesday (day 2): 9:00-20:00 (11h)
+        inbox.working_hours.find_by(day_of_week: 1).update!(open_hour: 9, close_hour: 17)
+        inbox.working_hours.find_by(day_of_week: 2).update!(open_hour: 9, close_hour: 20)
+
+        # Start at Monday 16:00 + 12 hours
+        # Monday: 1h (16:00-17:00), Tuesday: 11h remaining (9:00-20:00)
+        monday_4pm = Time.zone.parse('2024-01-15 16:00:00')
+        tuesday_8pm = Time.zone.parse('2024-01-16 20:00:00')
+
+        service = described_class.new(inbox: inbox, start_time: monday_4pm, threshold_seconds: 12.hours)
+
+        expect(service.deadline.to_i).to eq(tuesday_8pm.to_i)
+      end
+    end
+  end
+end
diff --git a/spec/enterprise/services/sla/evaluate_applied_sla_service_spec.rb b/spec/enterprise/services/sla/evaluate_applied_sla_service_spec.rb
index 71afd2125..6f672e694 100644
--- a/spec/enterprise/services/sla/evaluate_applied_sla_service_spec.rb
+++ b/spec/enterprise/services/sla/evaluate_applied_sla_service_spec.rb
@@ -19,6 +19,29 @@ RSpec.describe Sla::EvaluateAppliedSlaService do
   end
   let!(:applied_sla) { conversation.applied_sla }
 
+  describe '#perform - blocked contacts' do
+    before do
+      applied_sla.sla_policy.update(first_response_time_threshold: 1.hour, resolution_time_threshold: 1.hour)
+      conversation.contact.update!(blocked: true)
+    end
+
+    it 'does not create SLA events or update SLA status' do
+      described_class.new(applied_sla: applied_sla).perform
+
+      expect(SlaEvent.where(applied_sla: applied_sla)).not_to exist
+      expect(applied_sla.reload.sla_status).to eq('active')
+    end
+
+    it 'does not mark resolved conversations as hit or missed' do
+      conversation.resolved!
+
+      described_class.new(applied_sla: applied_sla).perform
+
+      expect(SlaEvent.where(applied_sla: applied_sla)).not_to exist
+      expect(applied_sla.reload.sla_status).to eq('active')
+    end
+  end
+
   describe '#perform - SLA misses' do
     context 'when first response SLA is missed' do
       before { applied_sla.sla_policy.update(first_response_time_threshold: 1.hour) }
@@ -140,6 +163,71 @@ RSpec.describe Sla::EvaluateAppliedSlaService do
       end
     end
 
+    context 'when first response SLA is hit after non-business hours' do
+      let(:created_at) { Time.zone.parse('2026-06-25 00:39:56 UTC') }
+      let(:wall_clock_breach_time) { Time.zone.parse('2026-06-25 01:40:03 UTC') }
+      let(:first_reply_created_at) { Time.zone.parse('2026-06-25 11:45:36 UTC') }
+      let(:post_reply_eval_time) { Time.zone.parse('2026-06-25 11:46:38 UTC') }
+      let(:email_inbox) { create(:inbox, :with_email, account: account, working_hours_enabled: true, timezone: 'America/New_York') }
+      let(:business_hours_sla_policy) do
+        create(
+          :sla_policy,
+          account: account,
+          first_response_time_threshold: 1.hour,
+          next_response_time_threshold: nil,
+          resolution_time_threshold: nil,
+          only_during_business_hours: true
+        )
+      end
+      let(:business_hours_conversation) do
+        create(
+          :conversation,
+          account: account,
+          inbox: email_inbox,
+          sla_policy: business_hours_sla_policy,
+          created_at: created_at,
+          last_activity_at: created_at
+        )
+      end
+      let(:business_hours_applied_sla) { business_hours_conversation.applied_sla }
+
+      before do
+        {
+          0 => [11, 0, 20, 0],
+          1 => [7, 0, 20, 0],
+          2 => [7, 0, 20, 0],
+          3 => [7, 0, 20, 0],
+          4 => [7, 0, 16, 0],
+          5 => [7, 0, 16, 0],
+          6 => [11, 0, 20, 0]
+        }.each do |day_of_week, (open_hour, open_minutes, close_hour, close_minutes)|
+          email_inbox.working_hours.find_by(day_of_week: day_of_week).update!(
+            open_hour: open_hour,
+            open_minutes: open_minutes,
+            close_hour: close_hour,
+            close_minutes: close_minutes,
+            closed_all_day: false,
+            open_all_day: false
+          )
+        end
+      end
+
+      it 'does not mark FRT missed while outside business hours or after an on-time business-hours reply' do
+        travel_to wall_clock_breach_time do
+          described_class.new(applied_sla: business_hours_applied_sla).perform
+        end
+
+        business_hours_conversation.update!(first_reply_created_at: first_reply_created_at, last_activity_at: first_reply_created_at)
+
+        travel_to post_reply_eval_time do
+          described_class.new(applied_sla: business_hours_applied_sla).perform
+        end
+
+        expect(business_hours_applied_sla.reload.sla_status).to eq('active')
+        expect(SlaEvent.where(applied_sla: business_hours_applied_sla, event_type: 'frt')).not_to exist
+      end
+    end
+
     context 'when next response SLA is hit' do
       before do
         applied_sla.sla_policy.update(next_response_time_threshold: 6.hours)
@@ -191,16 +279,16 @@ RSpec.describe Sla::EvaluateAppliedSlaService do
       # Simulate conversation timeline
       # Hit frt
       # incoming message from customer
-      create(:message, conversation: conversation, created_at: 6.hours.ago, message_type: :incoming)
+      create(:message, conversation: conversation, account: conversation.account, created_at: 6.hours.ago, message_type: :incoming)
       # outgoing message from agent within frt
-      create(:message, conversation: conversation, created_at: 5.hours.ago, message_type: :outgoing)
+      create(:message, conversation: conversation, account: conversation.account, created_at: 5.hours.ago, message_type: :outgoing)
 
       # Miss nrt first time
-      create(:message, conversation: conversation, created_at: 4.hours.ago, message_type: :incoming)
+      create(:message, conversation: conversation, account: conversation.account, created_at: 4.hours.ago, message_type: :incoming)
       described_class.new(applied_sla: applied_sla).perform
 
       # Miss nrt second time
-      create(:message, conversation: conversation, created_at: 3.hours.ago, message_type: :incoming)
+      create(:message, conversation: conversation, account: conversation.account, created_at: 3.hours.ago, message_type: :incoming)
       described_class.new(applied_sla: applied_sla).perform
 
       # Conversation is resolved missing rt
diff --git a/spec/enterprise/services/voice/outbound_call_builder_spec.rb b/spec/enterprise/services/voice/outbound_call_builder_spec.rb
index 796afe715..0dc565eaf 100644
--- a/spec/enterprise/services/voice/outbound_call_builder_spec.rb
+++ b/spec/enterprise/services/voice/outbound_call_builder_spec.rb
@@ -44,6 +44,54 @@ RSpec.describe Voice::OutboundCallBuilder do
       end
     end
 
+    it 'assigns the conversation to the agent placing the call' do
+      call = described_class.perform!(
+        account: account,
+        inbox: inbox,
+        user: user,
+        contact: contact
+      )
+
+      expect(call.conversation.assignee_id).to eq(user.id)
+    end
+
+    it 'keeps the calling agent assigned even when auto-assignment would pick an online agent' do
+      other_agent = create(:user, account: account)
+      create(:inbox_member, inbox: inbox, user: other_agent)
+      create(:inbox_member, inbox: inbox, user: user)
+      inbox.update!(enable_auto_assignment: true)
+      # Only other_agent is online, so round-robin would claim the conversation unless the caller wins at creation.
+      OnlineStatusTracker.update_presence(account.id, 'User', other_agent.id)
+      OnlineStatusTracker.set_status(account.id, other_agent.id, 'online')
+
+      call = described_class.perform!(
+        account: account,
+        inbox: inbox,
+        user: user,
+        contact: contact
+      )
+
+      expect(call.conversation.assignee_id).to eq(user.id)
+    end
+
+    it 'claims a reused conversation for the caller when it is unassigned' do
+      # Reload so the builder gets a DB-fresh record, mirroring the controller's find_by load.
+      conversation = create(:conversation, account: account, inbox: inbox, contact: contact).reload
+
+      described_class.perform!(account: account, inbox: inbox, user: user, contact: contact, conversation: conversation)
+
+      expect(conversation.reload.assignee_id).to eq(user.id)
+    end
+
+    it 'keeps the existing assignee when a reused conversation is already assigned' do
+      other_agent = create(:user, account: account)
+      conversation = create(:conversation, account: account, inbox: inbox, contact: contact, assignee: other_agent).reload
+
+      described_class.perform!(account: account, inbox: inbox, user: user, contact: contact, conversation: conversation)
+
+      expect(conversation.reload.assignee_id).to eq(other_agent.id)
+    end
+
     it 'does not set conversation.identifier or write call state to additional_attributes' do
       call = described_class.perform!(
         account: account,
diff --git a/spec/enterprise/services/whatsapp/call_service_spec.rb b/spec/enterprise/services/whatsapp/call_service_spec.rb
index 926771a65..4620ca588 100644
--- a/spec/enterprise/services/whatsapp/call_service_spec.rb
+++ b/spec/enterprise/services/whatsapp/call_service_spec.rb
@@ -57,11 +57,11 @@ describe Whatsapp::CallService do
         .to raise_error(StandardError) { |error| expect(error.class.name).to eq('Voice::CallErrors::AlreadyAccepted') }
     end
 
-    it 'raises NotRinging when the call has reached a terminal state' do
+    it 'raises CallAlreadyEnded when the call has reached a terminal state' do
       call.update!(status: 'completed')
 
       expect { described_class.new(call: call, agent: agent, sdp_answer: sdp_answer).accept }
-        .to raise_error(StandardError) { |error| expect(error.class.name).to eq('Voice::CallErrors::NotRinging') }
+        .to raise_error(StandardError) { |error| expect(error.class.name).to eq('Voice::CallErrors::CallAlreadyEnded') }
     end
 
     it 'raises CallFailed when sdp_answer is missing' do
diff --git a/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb b/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb
index 4651b5f13..a3c5246d2 100644
--- a/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb
+++ b/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb
@@ -149,17 +149,39 @@ describe Whatsapp::IncomingCallService do
   end
 
   describe 'terminate with no local row yet' do
-    it 'logs and skips instead of materialising an inbound missed-call row' do
-      allow(Rails.logger).to receive(:warn)
+    # Unique per example: the 60s tombstone isn't rolled back between specs.
+    let(:tombstone_call_id) { "wacid.#{SecureRandom.hex(6)}" }
+
+    after { Redis::Alfred.delete(format(Redis::Alfred::WHATSAPP_CALL_TERMINATE_TOMBSTONE, call_id: tombstone_call_id)) }
+
+    it 'tombstones the terminate instead of materialising an inbound missed-call row' do
       allow(ActionCable.server).to receive(:broadcast)
 
       params = call_payload(event: 'terminate', duration: 0, terminate_reason: 'no_answer')
+      params[:calls][0][:id] = tombstone_call_id
 
       expect { described_class.new(inbox: inbox, params: params).perform }
         .not_to change(Call, :count)
-      expect(Rails.logger).to have_received(:warn).with(/Terminate for unknown call/)
+      key = format(Redis::Alfred::WHATSAPP_CALL_TERMINATE_TOMBSTONE, call_id: tombstone_call_id)
+      expect(Redis::Alfred.get(key)).to be_present
       expect(ActionCable.server).not_to have_received(:broadcast)
     end
+
+    it 'finalizes the call as no_answer when the connect arrives after the tombstone' do
+      allow(ActionCable.server).to receive(:broadcast)
+
+      terminate = call_payload(event: 'terminate', duration: 0, terminate_reason: 'no_answer')
+      terminate[:calls][0][:id] = tombstone_call_id
+      described_class.new(inbox: inbox, params: terminate).perform
+
+      connect = call_payload(event: 'connect', session: { sdp: 'v=0', sdp_type: 'offer' })
+      connect[:calls][0][:id] = tombstone_call_id
+      expect { described_class.new(inbox: inbox, params: connect).perform }
+        .to change(Call, :count).by(1)
+      expect(Call.find_by(provider_call_id: tombstone_call_id).status).to eq('no_answer')
+      expect(ActionCable.server).to have_received(:broadcast)
+        .with(anything, hash_including(event: 'voice_call.ended')).at_least(:once)
+    end
   end
 
   describe 'outbound connect with no local row yet' do
diff --git a/spec/models/article_spec.rb b/spec/models/article_spec.rb
index 04466ccd1..cdad2d9f4 100644
--- a/spec/models/article_spec.rb
+++ b/spec/models/article_spec.rb
@@ -207,4 +207,29 @@ RSpec.describe Article do
       expect(article.to_llm_text).to eq(expected_output)
     end
   end
+
+  describe '.update_positions' do
+    let!(:article_a) { create(:article, portal: portal_1, category: category_1, author: user, position: 10) }
+    let!(:article_b) { create(:article, portal: portal_1, category: category_1, author: user, position: 11) }
+    let!(:article_c) { create(:article, portal: portal_1, category: category_1, author: user, position: 30) }
+
+    it 're-spaces the category to clean gaps and places a collided move after its tie' do
+      # Dropping C into the tight 10/11 gap gives a floored midpoint of 10, colliding with A
+      positions = described_class.update_positions(portal: portal_1, positions_hash: { article_c.id => 10 })
+
+      expect(article_a.reload.position).to eq(10)
+      expect(article_c.reload.position).to eq(20)
+      expect(article_b.reload.position).to eq(30)
+      expect(positions).to eq(article_a.id => 10, article_c.id => 20, article_b.id => 30)
+    end
+
+    it 'leaves a lone article untouched and returns nothing to sync' do
+      lone = create(:article, portal: portal_1, category: create(:category, portal_id: portal_1.id), author: user, position: 20)
+
+      positions = described_class.update_positions(portal: portal_1, positions_hash: { lone.id => 20 })
+
+      expect(lone.reload.position).to eq(20)
+      expect(positions).to be_empty
+    end
+  end
 end