From 412b72db7c629d1eb3ca431314ad34d9b0552091 Mon Sep 17 00:00:00 2001
From: Alexander Udovichenko <udovichenko48@gmail.com>
Date: Fri, 13 Mar 2026 12:30:17 +0300
Subject: [PATCH 01/16] fix: Delete double hmac check (#12464)

## Description

When hmac identity check is enabled according to
[this](https://www.chatwoot.com/hc/user-guide/articles/1677587479-how-to-enable-identity-validation-in-chatwoot)
I found out, that it checked twice.

If `should_verify_hmac? -> true` then hmac checked in `before_action`
and we don't need to do it again later.

This perfomance related and PR fixes this.
---
 app/controllers/api/v1/widget/contacts_controller.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/controllers/api/v1/widget/contacts_controller.rb b/app/controllers/api/v1/widget/contacts_controller.rb
index 5138fe675..6c595ab59 100644
--- a/app/controllers/api/v1/widget/contacts_controller.rb
+++ b/app/controllers/api/v1/widget/contacts_controller.rb
@@ -19,7 +19,7 @@ class Api::V1::Widget::ContactsController < Api::V1::Widget::BaseController
       contact = @contact
     end
 
-    @contact_inbox.update(hmac_verified: true) if should_verify_hmac? && valid_hmac?
+    @contact_inbox.update(hmac_verified: true) if should_verify_hmac?
 
     identify_contact(contact)
   end

From b8543c09fbb2e7ce2a3ffb34f4c66a963365443d Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Fri, 13 Mar 2026 15:17:46 +0530
Subject: [PATCH 02/16] refactor: unify backfill service to per-dimension query
 pattern

Replace the two-path aggregation (group-then-fan-out for standard events,
per-dimension for distinct-count) with a single per-dimension loop for both.
This removes the bug-prone fan-out logic and the conceptual split.

Strengthen specs to cover all three dimensions (account, agent, inbox),
assert total rollup row counts, and add distinct-count deduplication test.
---
 .../reporting_events/backfill_service.rb      | 125 ++++++++----------
 .../reporting_events/backfill_service_spec.rb |  73 ++++++++--
 2 files changed, 122 insertions(+), 76 deletions(-)

diff --git a/app/services/reporting_events/backfill_service.rb b/app/services/reporting_events/backfill_service.rb
index 8ec1c242e..0deef624d 100644
--- a/app/services/reporting_events/backfill_service.rb
+++ b/app/services/reporting_events/backfill_service.rb
@@ -1,29 +1,20 @@
 # frozen_string_literal: true
 
 class ReportingEvents::BackfillService
-  AGGREGATE_SELECTS = [
-    :name,
-    :user_id,
-    :inbox_id,
-    Arel.sql('COUNT(*)'),
-    Arel.sql('COALESCE(SUM(value), 0)'),
-    Arel.sql('COALESCE(SUM(value_in_business_hours), 0)')
-  ].freeze
-
-  DISTINCT_AGGREGATE_SELECTS = [
-    :name,
-    :user_id,
-    :inbox_id,
-    Arel.sql('COUNT(DISTINCT conversation_id)'),
-    Arel.sql('COALESCE(SUM(value), 0)'),
-    Arel.sql('COALESCE(SUM(value_in_business_hours), 0)')
+  DIMENSIONS = [
+    { type: 'account', group_column: nil },
+    { type: 'agent',   group_column: :user_id },
+    { type: 'inbox',   group_column: :inbox_id }
   ].freeze
 
   # TODO: Move this to EventMetricRegistry when we expand distinct-counting support.
   # The live path already guards uniqueness in ReportingEventListener#conversation_bot_handoff,
   # but historical duplicates can exist since it's not enforced at the DB level.
+  # These events are queried per-dimension (not group-then-sum) because COUNT(DISTINCT) is not additive.
   DISTINCT_COUNT_EVENTS = %w[conversation_bot_handoff].freeze
 
+  DISTINCT_COUNT_SQL = Arel.sql('COUNT(DISTINCT conversation_id)')
+
   def self.backfill_date(account, date)
     new(account, date).perform
   end
@@ -74,72 +65,70 @@ class ReportingEvents::BackfillService
 
   def build_aggregates(start_utc, end_utc)
     aggregates = Hash.new { |h, k| h[k] = { count: 0, sum_value: 0.0, sum_value_business_hours: 0.0 } }
+    standard_names = ReportingEvents::EventMetricRegistry.event_names - DISTINCT_COUNT_EVENTS
+    base = @account.reporting_events.where(created_at: start_utc...end_utc)
 
-    grouped_events(start_utc, end_utc).each { |grouped_event| accumulate_grouped_aggregates(aggregates, grouped_event) }
+    DIMENSIONS.each do |dimension|
+      aggregate_standard_events(aggregates, base.where(name: standard_names), dimension)
+      aggregate_distinct_events(aggregates, base.where(name: DISTINCT_COUNT_EVENTS), dimension)
+    end
 
     aggregates
   end
 
-  def grouped_events(start_utc, end_utc)
-    standard = fetch_grouped_events(start_utc, end_utc, standard_event_names, AGGREGATE_SELECTS)
-    distinct = fetch_grouped_events(start_utc, end_utc, DISTINCT_COUNT_EVENTS, DISTINCT_AGGREGATE_SELECTS)
+  def aggregate_standard_events(aggregates, scope, dimension)
+    group_cols, selects = dimension_groups_and_selects(dimension)
 
-    (standard + distinct).map { |grouped_row| grouped_event_attributes(grouped_row) }
-  end
+    scope.group(*group_cols).pluck(*selects).each do |row|
+      event_name, dimension_id, count, sum_value, sum_value_business_hours = unpack_row(row, dimension)
+      next if dimension_id.nil?
 
-  def standard_event_names
-    ReportingEvents::EventMetricRegistry.event_names - DISTINCT_COUNT_EVENTS
-  end
-
-  def fetch_grouped_events(start_utc, end_utc, event_names, selects)
-    return [] if event_names.empty?
-
-    @account.reporting_events
-            .where(name: event_names, created_at: start_utc...end_utc)
-            .group(:name, :user_id, :inbox_id)
-            .pluck(*selects)
-  end
-
-  def dimensions(grouped_event)
-    {
-      'account' => @account.id,
-      'agent' => grouped_event[:user_id],
-      'inbox' => grouped_event[:inbox_id]
-    }
-  end
-
-  def accumulate_grouped_aggregates(aggregates, grouped_event)
-    ReportingEvents::EventMetricRegistry.metrics_for_aggregate(
-      grouped_event[:event_name],
-      count: grouped_event[:count],
-      sum_value: grouped_event[:sum_value],
-      sum_value_business_hours: grouped_event[:sum_value_business_hours]
-    ).each do |metric, metric_data|
-      accumulate_metric_aggregates(aggregates, dimensions(grouped_event), metric, metric_data)
+      ReportingEvents::EventMetricRegistry.metrics_for_aggregate(
+        event_name, count: count, sum_value: sum_value, sum_value_business_hours: sum_value_business_hours
+      ).each do |metric, metric_data|
+        key = [dimension[:type], dimension_id, metric]
+        aggregates[key][:count] += metric_data[:count]
+        aggregates[key][:sum_value] += metric_data[:sum_value].to_f
+        aggregates[key][:sum_value_business_hours] += metric_data[:sum_value_business_hours].to_f
+      end
     end
   end
 
-  def grouped_event_attributes(grouped_row)
-    event_name, user_id, inbox_id, count, sum_value, sum_value_business_hours = grouped_row
+  def aggregate_distinct_events(aggregates, scope, dimension)
+    return if DISTINCT_COUNT_EVENTS.empty?
 
-    {
-      event_name: event_name,
-      user_id: user_id,
-      inbox_id: inbox_id,
-      count: count,
-      sum_value: sum_value,
-      sum_value_business_hours: sum_value_business_hours
-    }
-  end
+    group_cols = dimension[:group_column] ? [:name, dimension[:group_column]] : [:name]
 
-  def accumulate_metric_aggregates(aggregates, dimensions, metric, metric_data)
-    dimensions.each do |dimension_type, dimension_id|
+    scope.group(*group_cols).pluck(*group_cols, DISTINCT_COUNT_SQL).each do |row|
+      event_name, dimension_id, count = dimension[:group_column] ? row : [row[0], @account.id, row[1]]
       next if dimension_id.nil?
 
-      key = [dimension_type, dimension_id, metric]
-      aggregates[key][:count] += metric_data[:count]
-      aggregates[key][:sum_value] += metric_data[:sum_value].to_f
-      aggregates[key][:sum_value_business_hours] += metric_data[:sum_value_business_hours].to_f
+      ReportingEvents::EventMetricRegistry.metrics_for_aggregate(
+        event_name, count: count, sum_value: 0, sum_value_business_hours: 0
+      ).each do |metric, metric_data|
+        key = [dimension[:type], dimension_id, metric]
+        aggregates[key][:count] += metric_data[:count]
+      end
+    end
+  end
+
+  def dimension_groups_and_selects(dimension)
+    agg_selects = [Arel.sql('COUNT(*)'), Arel.sql('COALESCE(SUM(value), 0)'), Arel.sql('COALESCE(SUM(value_in_business_hours), 0)')]
+
+    if dimension[:group_column]
+      [[:name, dimension[:group_column]], [:name, dimension[:group_column], *agg_selects]]
+    else
+      [[:name], [:name, *agg_selects]]
+    end
+  end
+
+  def unpack_row(row, dimension)
+    if dimension[:group_column]
+      # [name, dimension_id, count, sum_value, sum_value_business_hours]
+      row
+    else
+      # [name, count, sum_value, sum_value_business_hours] → inject account id
+      [row[0], @account.id, row[1], row[2], row[3]]
     end
   end
 
diff --git a/spec/services/reporting_events/backfill_service_spec.rb b/spec/services/reporting_events/backfill_service_spec.rb
index c74b32860..8f0572d3b 100644
--- a/spec/services/reporting_events/backfill_service_spec.rb
+++ b/spec/services/reporting_events/backfill_service_spec.rb
@@ -62,15 +62,72 @@ describe ReportingEvents::BackfillService do
 
       expect(reporting_event_instantiations).to eq(0)
 
-      first_response_rollup = find_rollup('agent', user.id, 'first_response')
-      expect(first_response_rollup.count).to eq(2)
-      expect(first_response_rollup.sum_value).to eq(140)
-      expect(first_response_rollup.sum_value_business_hours).to eq(80)
+      rollups = ReportingEventsRollup.where(account_id: account.id, date: date)
+      # 3 dimensions × first_response + 3 dimensions × resolutions_count + 3 dimensions × resolution_time
+      expect(rollups.count).to eq(9)
 
-      resolution_time_rollup = find_rollup('agent', second_user.id, 'resolution_time')
-      expect(resolution_time_rollup.count).to eq(1)
-      expect(resolution_time_rollup.sum_value).to eq(200)
-      expect(resolution_time_rollup.sum_value_business_hours).to eq(80)
+      # account dimension
+      account_first_response = find_rollup('account', account.id, 'first_response')
+      expect(account_first_response.count).to eq(2)
+      expect(account_first_response.sum_value).to eq(140)
+      expect(account_first_response.sum_value_business_hours).to eq(80)
+
+      # agent dimension
+      agent_first_response = find_rollup('agent', user.id, 'first_response')
+      expect(agent_first_response.count).to eq(2)
+      expect(agent_first_response.sum_value).to eq(140)
+      expect(agent_first_response.sum_value_business_hours).to eq(80)
+
+      agent_resolution_time = find_rollup('agent', second_user.id, 'resolution_time')
+      expect(agent_resolution_time.count).to eq(1)
+      expect(agent_resolution_time.sum_value).to eq(200)
+      expect(agent_resolution_time.sum_value_business_hours).to eq(80)
+
+      # inbox dimension
+      inbox_first_response = find_rollup('inbox', inbox.id, 'first_response')
+      expect(inbox_first_response.count).to eq(2)
+      expect(inbox_first_response.sum_value).to eq(140)
+      expect(inbox_first_response.sum_value_business_hours).to eq(80)
+
+      inbox_resolution_time = find_rollup('inbox', second_inbox.id, 'resolution_time')
+      expect(inbox_resolution_time.count).to eq(1)
+      expect(inbox_resolution_time.sum_value).to eq(200)
+      expect(inbox_resolution_time.sum_value_business_hours).to eq(80)
+    end
+
+    it 'deduplicates distinct-count events per dimension' do
+      second_user = create(:user, account: account)
+      second_inbox = create(:inbox, account: account)
+      conversation_b = create(:conversation, account: account, inbox: inbox, assignee: user)
+      conversation_c = create(:conversation, account: account, inbox: second_inbox, assignee: second_user)
+
+      # Two events for the same conversation — should count as 1
+      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
+                            inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 14))
+      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
+                            inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 15))
+      # Different conversation, same agent/inbox
+      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
+                            inbox: inbox, conversation: conversation_b, created_at: Time.utc(2026, 2, 11, 16))
+      # Different agent/inbox
+      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: second_user,
+                            inbox: second_inbox, conversation: conversation_c, created_at: Time.utc(2026, 2, 11, 17))
+
+      described_class.backfill_date(account, date)
+
+      rollups = ReportingEventsRollup.where(account_id: account.id, date: date)
+      expect(rollups.count).to eq(5)
+
+      # account: 3 distinct conversations
+      expect(find_rollup('account', account.id, 'bot_handoffs_count').count).to eq(3)
+
+      # agent: user has 2 distinct, second_user has 1
+      expect(find_rollup('agent', user.id, 'bot_handoffs_count').count).to eq(2)
+      expect(find_rollup('agent', second_user.id, 'bot_handoffs_count').count).to eq(1)
+
+      # inbox: inbox has 2 distinct, second_inbox has 1
+      expect(find_rollup('inbox', inbox.id, 'bot_handoffs_count').count).to eq(2)
+      expect(find_rollup('inbox', second_inbox.id, 'bot_handoffs_count').count).to eq(1)
     end
 
     def create_backfill_event(**attributes)

From a90ffe6264bd2bc614a8a8949ffb05ae8596fe00 Mon Sep 17 00:00:00 2001
From: Aakash Bakhle <48802744+aakashb95@users.noreply.github.com>
Date: Sat, 14 Mar 2026 03:34:58 +0530
Subject: [PATCH 03/16] feat: Add force legacy auto-resolve flag (#13804)

# Pull Request Template

## Description

Add account setting and store_accessor for
`captain_force_legacy_auto_resolve`.
Enterprise job now skips LLM evaluation when this flag is true and falls
back to legacy time-based resolution. Add spec to cover the fallback.


## Type of change

We recently rolled out Captain deciding if a conversation is resolved or
not. While it is an improvement for majority of customers, some still
prefer the old way of auto-resolving based on inactivity. This PR adds a
check.

## How Has This Been Tested?

Please describe the tests that you ran to verify your changes. Provide
instructions so we can reproduce. Please also list any relevant details
for your test configuration.

legacy_auto_resolve = true

<img width="1282" height="848" alt="CleanShot 2026-03-13 at 19 55 55@2x"
src="https://github.com/user-attachments/assets/dfdcc5d5-6d21-462b-87a6-a5e1b1290a8b"
/>


legacy_auto_resolve = false
<img width="1268" height="864" alt="CleanShot 2026-03-13 at 20 00 50@2x"
src="https://github.com/user-attachments/assets/f4719ec6-922a-4c3b-bc45-7b29eaced565"
/>



## Checklist:

- [x] My code follows the style guidelines of this project
- [x] I have performed a self-review of my code
- [x] I have commented on my code, particularly in hard-to-understand
areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] Any dependent changes have been merged and published in downstream
modules
---
 app/models/account.rb                         |  5 ++-
 .../concerns/account_captain_auto_resolve.rb  | 21 ++++++++++
 ...ox_pending_conversations_resolution_job.rb |  8 +++-
 .../conversations_resolution_scheduler_job.rb |  2 +-
 .../tools/resolve_conversation_tool.rb        |  2 +-
 ...nding_conversations_resolution_job_spec.rb | 22 ++++++++++-
 ...ersations_resolution_scheduler_job_spec.rb | 20 +++++++++-
 .../tools/resolve_conversation_tool_spec.rb   | 13 ++++++-
 spec/models/account_spec.rb                   | 38 +++++++++++++++++++
 9 files changed, 121 insertions(+), 10 deletions(-)
 create mode 100644 app/models/concerns/account_captain_auto_resolve.rb

diff --git a/app/models/account.rb b/app/models/account.rb
index eabaa5c26..087226710 100644
--- a/app/models/account.rb
+++ b/app/models/account.rb
@@ -41,7 +41,7 @@ class Account < ApplicationRecord
         'audio_transcriptions': { 'type': %w[boolean null] },
         'auto_resolve_label': { 'type': %w[string null] },
         'keep_pending_on_bot_failure': { 'type': %w[boolean null] },
-        'captain_disable_auto_resolve': { 'type': %w[boolean null] },
+        'captain_auto_resolve_mode': { 'type': %w[string null], 'enum': ['evaluated', 'legacy', 'disabled', nil] },
         'conversation_required_attributes': {
           'type': %w[array null],
           'items': { 'type': 'string' }
@@ -91,7 +91,8 @@ class Account < ApplicationRecord
   store_accessor :settings, :audio_transcriptions, :auto_resolve_label
   store_accessor :settings, :captain_models, :captain_features
   store_accessor :settings, :keep_pending_on_bot_failure
-  store_accessor :settings, :captain_disable_auto_resolve
+  store_accessor :settings, :captain_auto_resolve_mode
+  include AccountCaptainAutoResolve
 
   has_many :account_users, dependent: :destroy_async
   has_many :agent_bot_inboxes, dependent: :destroy_async
diff --git a/app/models/concerns/account_captain_auto_resolve.rb b/app/models/concerns/account_captain_auto_resolve.rb
new file mode 100644
index 000000000..5d17e92f9
--- /dev/null
+++ b/app/models/concerns/account_captain_auto_resolve.rb
@@ -0,0 +1,21 @@
+module AccountCaptainAutoResolve
+  extend ActiveSupport::Concern
+
+  VALID_CAPTAIN_AUTO_RESOLVE_MODES = %w[evaluated legacy disabled].freeze
+
+  included do
+    VALID_CAPTAIN_AUTO_RESOLVE_MODES.each do |mode|
+      define_method("captain_auto_resolve_#{mode}?") do
+        captain_auto_resolve_mode == mode
+      end
+    end
+  end
+
+  def captain_auto_resolve_mode
+    mode = settings&.[]('captain_auto_resolve_mode')
+    return mode if VALID_CAPTAIN_AUTO_RESOLVE_MODES.include?(mode)
+    return 'disabled' if settings&.[]('captain_disable_auto_resolve') == true
+
+    feature_enabled?('captain_tasks') ? 'evaluated' : 'legacy'
+  end
+end
diff --git a/enterprise/app/jobs/captain/inbox_pending_conversations_resolution_job.rb b/enterprise/app/jobs/captain/inbox_pending_conversations_resolution_job.rb
index 538c03d22..0be179f04 100644
--- a/enterprise/app/jobs/captain/inbox_pending_conversations_resolution_job.rb
+++ b/enterprise/app/jobs/captain/inbox_pending_conversations_resolution_job.rb
@@ -5,9 +5,9 @@ class Captain::InboxPendingConversationsResolutionJob < ApplicationJob
   queue_as :low
 
   def perform(inbox)
-    return if inbox.account.captain_disable_auto_resolve
+    return if inbox.account.captain_auto_resolve_disabled?
 
-    if inbox.account.feature_enabled?('captain_tasks')
+    if evaluate_conversation_completion?(inbox.account)
       perform_with_evaluation(inbox)
     else
       perform_time_based(inbox)
@@ -18,6 +18,10 @@ class Captain::InboxPendingConversationsResolutionJob < ApplicationJob
 
   private
 
+  def evaluate_conversation_completion?(account)
+    account.feature_enabled?('captain_tasks') && account.captain_auto_resolve_evaluated?
+  end
+
   def perform_time_based(inbox)
     Current.executed_by = inbox.captain_assistant
 
diff --git a/enterprise/app/jobs/enterprise/account/conversations_resolution_scheduler_job.rb b/enterprise/app/jobs/enterprise/account/conversations_resolution_scheduler_job.rb
index 8b6527c93..7ccebf72f 100644
--- a/enterprise/app/jobs/enterprise/account/conversations_resolution_scheduler_job.rb
+++ b/enterprise/app/jobs/enterprise/account/conversations_resolution_scheduler_job.rb
@@ -12,7 +12,7 @@ module Enterprise::Account::ConversationsResolutionSchedulerJob
       inbox = captain_inbox.inbox
 
       next if inbox.email?
-      next if inbox.account.captain_disable_auto_resolve
+      next if inbox.account.captain_auto_resolve_disabled?
 
       Captain::InboxPendingConversationsResolutionJob.perform_later(
         inbox
diff --git a/enterprise/lib/captain/tools/resolve_conversation_tool.rb b/enterprise/lib/captain/tools/resolve_conversation_tool.rb
index 2b71098c9..eeffc3f06 100644
--- a/enterprise/lib/captain/tools/resolve_conversation_tool.rb
+++ b/enterprise/lib/captain/tools/resolve_conversation_tool.rb
@@ -6,7 +6,7 @@ class Captain::Tools::ResolveConversationTool < Captain::Tools::BasePublicTool
     conversation = find_conversation(tool_context.state)
     return 'Conversation not found' unless conversation
     return "Conversation ##{conversation.display_id} is already resolved" if conversation.resolved?
-    return 'Auto-resolve is disabled for this account' if conversation.account.captain_disable_auto_resolve
+    return 'Auto-resolve is disabled for this account' if conversation.account.captain_auto_resolve_disabled?
 
     log_tool_usage('resolve_conversation', { conversation_id: conversation.id, reason: reason })
 
diff --git a/spec/enterprise/jobs/captain/inbox_pending_conversations_resolution_job_spec.rb b/spec/enterprise/jobs/captain/inbox_pending_conversations_resolution_job_spec.rb
index 63b8c1bca..f432aae62 100644
--- a/spec/enterprise/jobs/captain/inbox_pending_conversations_resolution_job_spec.rb
+++ b/spec/enterprise/jobs/captain/inbox_pending_conversations_resolution_job_spec.rb
@@ -84,6 +84,16 @@ RSpec.describe Captain::InboxPendingConversationsResolutionJob, type: :job do
       expect(resolvable_pending_conversation.reload.status).to eq('pending')
       expect(resolvable_pending_conversation.messages.outgoing).to be_empty
     end
+
+    it 'falls back to legacy time-based resolve when legacy auto-resolve is forced' do
+      inbox.account.update!(captain_auto_resolve_mode: 'legacy')
+      allow(Captain::ConversationCompletionService).to receive(:new)
+
+      described_class.perform_now(inbox)
+
+      expect(Captain::ConversationCompletionService).not_to have_received(:new)
+      expect(resolvable_pending_conversation.reload.status).to eq('resolved')
+    end
   end
 
   context 'when LLM evaluation returns complete' do
@@ -322,7 +332,7 @@ RSpec.describe Captain::InboxPendingConversationsResolutionJob, type: :job do
   end
 
   it 'does not resolve conversations when auto-resolve is disabled at execution time' do
-    inbox.account.update!(captain_disable_auto_resolve: true)
+    inbox.account.update!(captain_auto_resolve_mode: 'disabled')
 
     expect do
       described_class.perform_now(inbox)
@@ -331,4 +341,14 @@ RSpec.describe Captain::InboxPendingConversationsResolutionJob, type: :job do
     expect(resolvable_pending_conversation.reload.status).to eq('pending')
     expect(resolvable_pending_conversation.messages.outgoing).to be_empty
   end
+
+  it 'falls back to disabled mode from legacy settings key' do
+    inbox.account.update!(settings: inbox.account.settings.merge('captain_disable_auto_resolve' => true))
+
+    expect do
+      described_class.perform_now(inbox)
+    end.not_to(change { resolvable_pending_conversation.reload.status })
+
+    expect(resolvable_pending_conversation.reload.status).to eq('pending')
+  end
 end
diff --git a/spec/enterprise/jobs/enterprise/account/conversations_resolution_scheduler_job_spec.rb b/spec/enterprise/jobs/enterprise/account/conversations_resolution_scheduler_job_spec.rb
index 343100a50..1988d346c 100644
--- a/spec/enterprise/jobs/enterprise/account/conversations_resolution_scheduler_job_spec.rb
+++ b/spec/enterprise/jobs/enterprise/account/conversations_resolution_scheduler_job_spec.rb
@@ -30,12 +30,28 @@ RSpec.describe Account::ConversationsResolutionSchedulerJob, type: :job do
       end
     end
 
-    context 'when account has captain_disable_auto_resolve enabled' do
+    context 'when account has captain auto resolve disabled' do
       let!(:regular_inbox) { create(:inbox, account: account) }
 
       before do
         create(:captain_inbox, captain_assistant: assistant, inbox: regular_inbox)
-        account.update!(captain_disable_auto_resolve: true)
+        account.update!(captain_auto_resolve_mode: 'disabled')
+      end
+
+      it 'does not enqueue resolution jobs' do
+        expect do
+          described_class.perform_now
+        end.not_to have_enqueued_job(Captain::InboxPendingConversationsResolutionJob)
+          .with(regular_inbox)
+      end
+    end
+
+    context 'when account uses legacy disabled settings key' do
+      let!(:regular_inbox) { create(:inbox, account: account) }
+
+      before do
+        create(:captain_inbox, captain_assistant: assistant, inbox: regular_inbox)
+        account.update!(settings: account.settings.merge('captain_disable_auto_resolve' => true))
       end
 
       it 'does not enqueue resolution jobs' do
diff --git a/spec/enterprise/lib/captain/tools/resolve_conversation_tool_spec.rb b/spec/enterprise/lib/captain/tools/resolve_conversation_tool_spec.rb
index f676b2974..2eae2905a 100644
--- a/spec/enterprise/lib/captain/tools/resolve_conversation_tool_spec.rb
+++ b/spec/enterprise/lib/captain/tools/resolve_conversation_tool_spec.rb
@@ -41,7 +41,18 @@ RSpec.describe Captain::Tools::ResolveConversationTool do
   end
 
   describe 'when auto-resolve is disabled for the account' do
-    before { account.update!(captain_disable_auto_resolve: true) }
+    before { account.update!(captain_auto_resolve_mode: 'disabled') }
+
+    it 'does not resolve and returns a disabled message' do
+      result = tool.perform(tool_context, reason: 'Possible spam')
+
+      expect(result).to eq('Auto-resolve is disabled for this account')
+      expect(conversation.reload).not_to be_resolved
+    end
+  end
+
+  describe 'when auto-resolve is disabled via legacy settings key' do
+    before { account.update!(settings: account.settings.merge('captain_disable_auto_resolve' => true)) }
 
     it 'does not resolve and returns a disabled message' do
       result = tool.perform(tool_context, reason: 'Possible spam')
diff --git a/spec/models/account_spec.rb b/spec/models/account_spec.rb
index 5ccff6517..166b4c34b 100644
--- a/spec/models/account_spec.rb
+++ b/spec/models/account_spec.rb
@@ -198,6 +198,44 @@ RSpec.describe Account do
         expect(account.settings['auto_resolve_message']).to eq(message)
       end
 
+      it 'defaults captain_auto_resolve_mode to legacy when captain_tasks is disabled' do
+        allow(account).to receive(:feature_enabled?).with('captain_tasks').and_return(false)
+
+        expect(account.captain_auto_resolve_mode).to eq('legacy')
+        expect(account).to be_captain_auto_resolve_legacy
+      end
+
+      it 'defaults captain_auto_resolve_mode to evaluated when captain_tasks is enabled' do
+        allow(account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
+
+        expect(account.captain_auto_resolve_mode).to eq('evaluated')
+        expect(account).to be_captain_auto_resolve_evaluated
+      end
+
+      it 'correctly gets and sets captain_auto_resolve_mode' do
+        account.captain_auto_resolve_mode = 'legacy'
+
+        expect(account.captain_auto_resolve_mode).to eq('legacy')
+        expect(account.settings['captain_auto_resolve_mode']).to eq('legacy')
+        expect(account).to be_captain_auto_resolve_legacy
+      end
+
+      it 'allows clearing captain_auto_resolve_mode to fall back to feature defaults' do
+        allow(account).to receive(:feature_enabled?).with('captain_tasks').and_return(false)
+        account.captain_auto_resolve_mode = nil
+
+        expect(account).to be_valid
+        expect(account.captain_auto_resolve_mode).to eq('legacy')
+        expect(account.settings['captain_auto_resolve_mode']).to be_nil
+      end
+
+      it 'falls back to disabled mode from legacy settings key' do
+        account.settings = { 'captain_disable_auto_resolve' => true }
+
+        expect(account.captain_auto_resolve_mode).to eq('disabled')
+        expect(account).to be_captain_auto_resolve_disabled
+      end
+
       it 'handles nil values correctly' do
         account.auto_resolve_after = nil
         account.auto_resolve_message = nil

From 73a90f284119330511ed87f38e63c12b42d85985 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 11:04:27 +0530
Subject: [PATCH 04/16] feat: update bunny video support in HC (#13815)

Bunny Video has added a new URL player.mediadelivery.net, this PR adds
support for the new URL
---
 .../EmptyState/Portal/PortalEmptyState.vue       |  1 +
 config/markdown_embeds.yml                       |  4 ++--
 spec/config/markdown_embeds_spec.rb              |  6 +++++-
 spec/lib/custom_markdown_renderer_spec.rb        | 16 ++++++++++++++--
 4 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/app/javascript/dashboard/components-next/HelpCenter/EmptyState/Portal/PortalEmptyState.vue b/app/javascript/dashboard/components-next/HelpCenter/EmptyState/Portal/PortalEmptyState.vue
index b7a986254..192e1d5ee 100644
--- a/app/javascript/dashboard/components-next/HelpCenter/EmptyState/Portal/PortalEmptyState.vue
+++ b/app/javascript/dashboard/components-next/HelpCenter/EmptyState/Portal/PortalEmptyState.vue
@@ -26,6 +26,7 @@ const onPortalCreate = ({ slug: portalSlug, locale }) => {
   <EmptyStateLayout
     :title="$t('HELP_CENTER.TITLE')"
     :subtitle="$t('HELP_CENTER.NEW_PAGE.DESCRIPTION')"
+    class="bg-n-surface-1"
   >
     <template #empty-state-item>
       <div class="grid grid-cols-2 gap-4 p-px">
diff --git a/config/markdown_embeds.yml b/config/markdown_embeds.yml
index f85e181e3..b826931ec 100644
--- a/config/markdown_embeds.yml
+++ b/config/markdown_embeds.yml
@@ -104,11 +104,11 @@ wistia:
     </div>
 
 bunny:
-  regex: 'https?://iframe\.mediadelivery\.net/play/(?<library_id>\d+)/(?<video_id>[^&/?]+)'
+  regex: 'https?://(?:iframe|player)\.mediadelivery\.net/(?:play|embed)/(?<library_id>\d+)/(?<video_id>[^&/?]+)'
   template: |
     <div style="position: relative; padding-top: 56.25%;">
       <iframe
-        src="https://iframe.mediadelivery.net/embed/%{library_id}/%{video_id}?autoplay=false&loop=false&muted=false&preload=true&responsive=true"
+        src="https://player.mediadelivery.net/embed/%{library_id}/%{video_id}?autoplay=false&loop=false&muted=false&preload=true&responsive=true"
         title="Bunny video player"
         loading="lazy"
         style="border: 0; position: absolute; top: 0; height: 100%; width: 100%;"
diff --git a/spec/config/markdown_embeds_spec.rb b/spec/config/markdown_embeds_spec.rb
index 9e9e56898..f609ac113 100644
--- a/spec/config/markdown_embeds_spec.rb
+++ b/spec/config/markdown_embeds_spec.rb
@@ -63,7 +63,11 @@ describe 'Markdown Embeds Configuration' do
         'bunny' => [
           { url: 'https://iframe.mediadelivery.net/play/431789/1f105841-cad9-46fe-a70e-b7623c60797c',
             expected: { 'library_id' => '431789', 'video_id' => '1f105841-cad9-46fe-a70e-b7623c60797c' } },
-          { url: 'https://iframe.mediadelivery.net/play/12345/abcdef-ghijkl', expected: { 'library_id' => '12345', 'video_id' => 'abcdef-ghijkl' } }
+          { url: 'https://iframe.mediadelivery.net/play/12345/abcdef-ghijkl', expected: { 'library_id' => '12345', 'video_id' => 'abcdef-ghijkl' } },
+          { url: 'https://player.mediadelivery.net/play/431789/1f105841-cad9-46fe-a70e-b7623c60797c',
+            expected: { 'library_id' => '431789', 'video_id' => '1f105841-cad9-46fe-a70e-b7623c60797c' } },
+          { url: 'https://iframe.mediadelivery.net/embed/256380/d9d9ab1f-fc9f-4488-9c26-4ffc653c0024',
+            expected: { 'library_id' => '256380', 'video_id' => 'd9d9ab1f-fc9f-4488-9c26-4ffc653c0024' } }
         ],
         'codepen' => [
           { url: 'https://codepen.io/username/pen/abcdef', expected: { 'user' => 'username', 'pen_id' => 'abcdef' } },
diff --git a/spec/lib/custom_markdown_renderer_spec.rb b/spec/lib/custom_markdown_renderer_spec.rb
index b329105d5..1237eae2c 100644
--- a/spec/lib/custom_markdown_renderer_spec.rb
+++ b/spec/lib/custom_markdown_renderer_spec.rb
@@ -184,12 +184,12 @@ describe CustomMarkdownRenderer do
       end
     end
 
-    context 'when link is a Bunny.net URL' do
+    context 'when link is a Bunny.net iframe URL' do
       let(:bunny_url) { 'https://iframe.mediadelivery.net/play/431789/1f105841-cad9-46fe-a70e-b7623c60797c' }
 
       it 'renders an iframe with Bunny embed code' do
         output = render_markdown_link(bunny_url)
-        expect(output).to include('src="https://iframe.mediadelivery.net/embed/431789/1f105841-cad9-46fe-a70e-b7623c60797c?autoplay=false&loop=false&muted=false&preload=true&responsive=true"')
+        expect(output).to include('src="https://player.mediadelivery.net/embed/431789/1f105841-cad9-46fe-a70e-b7623c60797c?autoplay=false&loop=false&muted=false&preload=true&responsive=true"')
         expect(output).to include('allowfullscreen')
         expect(output).to include('allow="accelerometer; gyroscope; autoplay; encrypted-media; picture-in-picture;"')
       end
@@ -200,5 +200,17 @@ describe CustomMarkdownRenderer do
         expect(output).to include('position: absolute; top: 0; height: 100%; width: 100%;')
       end
     end
+
+    context 'when link is a Bunny.net player URL' do
+      let(:bunny_url) { 'https://player.mediadelivery.net/play/431789/1f105841-cad9-46fe-a70e-b7623c60797c' }
+
+      it 'renders an iframe with Bunny embed code' do
+        output = render_markdown_link(bunny_url)
+        expect(output).to include('embed/431789/1f105841-cad9-46fe-a70e-b7623c60797c')
+        expect(output).to include('autoplay=false&loop=false&muted=false&preload=true&responsive=true')
+        expect(output).to include('allowfullscreen')
+        expect(output).to include('allow="accelerometer; gyroscope; autoplay; encrypted-media; picture-in-picture;"')
+      end
+    end
   end
 end

From 28bf9fa5f9bfc970a237ccbe8be615b910ca3472 Mon Sep 17 00:00:00 2001
From: Tanmay Deep Sharma <32020192+tds-1@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:11:19 +0530
Subject: [PATCH 05/16] fix: upgrade markdown-it to 14.1.1 to remediate
 CVE-2026-2327 (#13782)

## Linear tickets
-
https://linear.app/chatwoot/issue/CW-6607/vanta-remediate-medium-vulnerabilities-identified-in-packages-are
-
https://linear.app/chatwoot/issue/CW-6612/vanta-remediate-medium-vulnerabilities-identified-in-packages-are

## Description

Upgrades markdown-it from 13.0.2 to 14.1.1 to remediate CVE-2026-2327

## Type of change

Please delete options that are not relevant.

- [ ] Bug fix (non-breaking change which fixes an issue)

## How Has This Been Tested?

- Sanity testing of golden flows via UI

## Checklist:

- [ ] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my code
- [ ] I have commented on my code, particularly in hard-to-understand
areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my
feature works
- [ ] New and existing unit tests pass locally with my changes
- [ ] Any dependent changes have been merged and published in downstream
modules
---
 package.json   |  2 +-
 pnpm-lock.yaml | 37 ++++++-------------------------------
 2 files changed, 7 insertions(+), 32 deletions(-)

diff --git a/package.json b/package.json
index 0f74d03f4..c25a1f61d 100644
--- a/package.json
+++ b/package.json
@@ -79,7 +79,7 @@
     "json-logic-js": "^2.0.5",
     "lettersanitizer": "^1.0.6",
     "libphonenumber-js": "^1.11.9",
-    "markdown-it": "^13.0.2",
+    "markdown-it": "^14.1.1",
     "markdown-it-link-attributes": "^4.0.1",
     "md5": "^2.3.0",
     "mitt": "^3.0.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index abd4acdeb..f1a6c7604 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -160,8 +160,8 @@ importers:
         specifier: ^1.11.9
         version: 1.11.9
       markdown-it:
-        specifier: ^13.0.2
-        version: 13.0.2
+        specifier: ^14.1.1
+        version: 14.1.1
       markdown-it-link-attributes:
         specifier: ^4.0.1
         version: 4.0.1
@@ -2206,10 +2206,6 @@ packages:
   entities@2.1.0:
     resolution: {integrity: sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==}
 
-  entities@3.0.1:
-    resolution: {integrity: sha512-WiyBqoomrwMdFG1e0kqvASYfnlb0lp8M5o5Fw2OFq1hNZxxcNk8Ik0Xm7LxzBhuidnZB/UtBqVCgUz3kBOP51Q==}
-    engines: {node: '>=0.12'}
-
   entities@4.5.0:
     resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
     engines: {node: '>=0.12'}
@@ -3087,9 +3083,6 @@ packages:
   linkify-it@3.0.3:
     resolution: {integrity: sha512-ynTsyrFSdE5oZ/O9GEf00kPngmOfVwazR5GKDq6EYfhlpFug3J2zybX56a2PRRpc9P+FuSoGNAwjlbDs9jJBPQ==}
 
-  linkify-it@4.0.1:
-    resolution: {integrity: sha512-C7bfi1UZmoj8+PQx22XyeXCuBlokoyWQL5pWSP+EI6nzRylyThouddufc2c1NDIcP9k5agmN9fLpA7VNJfIiqw==}
-
   linkify-it@5.0.0:
     resolution: {integrity: sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==}
 
@@ -3210,12 +3203,8 @@ packages:
     resolution: {integrity: sha512-TchMembfxfNVpHkbtriWltGWc+m3xszaRD0CZup7GFFhzIgQqxIfn3eGj1yZpfuflzPvfkt611B2Q/Bsk1YnGg==}
     hasBin: true
 
-  markdown-it@13.0.2:
-    resolution: {integrity: sha512-FtwnEuuK+2yVU7goGn/MJ0WBZMM9ZPgU9spqlFs7/A/pDIUNSOQZhUgOqYCficIuR2QaFnrt8LHqBWsbTAoI5w==}
-    hasBin: true
-
-  markdown-it@14.1.0:
-    resolution: {integrity: sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==}
+  markdown-it@14.1.1:
+    resolution: {integrity: sha512-BuU2qnTti9YKgK5N+IeMubp14ZUKUUw7yeJbkjtosvHiP0AZ5c8IAgEMk79D0eC8F23r4Ac/q8cAIFdm2FtyoA==}
     hasBin: true
 
   math-intrinsics@1.1.0:
@@ -6841,8 +6830,6 @@ snapshots:
 
   entities@2.1.0: {}
 
-  entities@3.0.1: {}
-
   entities@4.5.0: {}
 
   entities@6.0.1: {}
@@ -7950,10 +7937,6 @@ snapshots:
     dependencies:
       uc.micro: 1.0.6
 
-  linkify-it@4.0.1:
-    dependencies:
-      uc.micro: 1.0.6
-
   linkify-it@5.0.0:
     dependencies:
       uc.micro: 2.1.0
@@ -8091,15 +8074,7 @@ snapshots:
       mdurl: 1.0.1
       uc.micro: 1.0.6
 
-  markdown-it@13.0.2:
-    dependencies:
-      argparse: 2.0.1
-      entities: 3.0.1
-      linkify-it: 4.0.1
-      mdurl: 1.0.1
-      uc.micro: 1.0.6
-
-  markdown-it@14.1.0:
+  markdown-it@14.1.1:
     dependencies:
       argparse: 2.0.1
       entities: 4.5.0
@@ -8738,7 +8713,7 @@ snapshots:
 
   prosemirror-markdown@1.13.0:
     dependencies:
-      markdown-it: 14.1.0
+      markdown-it: 14.1.1
       prosemirror-model: 1.22.3
 
   prosemirror-menu@1.2.4:

From 89e53e24db1eae42aae1428a75ff7201a3996163 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 12:03:16 +0530
Subject: [PATCH 06/16] fix: timezone offset parsing

---
 ...eporting_events_rollup_timezone_setup.rake | 31 ++++++++++++++++---
 1 file changed, 26 insertions(+), 5 deletions(-)

diff --git a/lib/tasks/reporting_events_rollup_timezone_setup.rake b/lib/tasks/reporting_events_rollup_timezone_setup.rake
index acf5ed480..e3d951f57 100644
--- a/lib/tasks/reporting_events_rollup_timezone_setup.rake
+++ b/lib/tasks/reporting_events_rollup_timezone_setup.rake
@@ -66,15 +66,36 @@ class ReportingEventsRollupTimezoneSetup
   end
 
   def find_matching_zones(offset_input)
-    normalized = offset_input.gsub(/^(?!\+|-)/, '+')
-    parts = normalized.split(':')
-    hours = parts[0].to_i
-    minutes = (parts[1] || '0').to_i
-    total_seconds = (hours * 3600) + (hours.negative? ? -minutes * 60 : minutes * 60)
+    total_seconds = utc_offset_in_seconds(offset_input)
+    return [] unless total_seconds
 
     ActiveSupport::TimeZone.all.select { |tz| tz.utc_offset == total_seconds }
   end
 
+  def utc_offset_in_seconds(offset_input)
+    normalized = offset_input.strip
+    return unless normalized.match?(/\A[+-]?\d{1,2}(:\d{2})?\z/)
+
+    sign = normalized.start_with?('-') ? -1 : 1
+    raw = normalized.delete_prefix('+').delete_prefix('-')
+    hours_part, minutes_part = raw.split(':', 2)
+
+    hours = Integer(hours_part, 10)
+    minutes = Integer(minutes_part || '0', 10)
+    return unless minutes.between?(0, 59)
+
+    total_minutes = (hours * 60) + minutes
+    return if total_minutes > max_utc_offset_minutes(sign)
+
+    sign * total_minutes * 60
+  rescue ArgumentError
+    nil
+  end
+
+  def max_utc_offset_minutes(sign)
+    sign.negative? ? 12 * 60 : 14 * 60
+  end
+
   def display_matching_zones(zones, offset_input)
     puts ''
     puts color("Timezones matching UTC#{offset_input}:", :yellow, :bold)

From e7d5924ca19e461df655418288053f6f38eb9264 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 12:26:38 +0530
Subject: [PATCH 07/16] feat: make the rollup backfill atomic

---
 .../reporting_events/backfill_service.rb      |  7 +-
 lib/tasks/reporting_events_rollup.rake        | 18 ++++-
 .../reporting_events_rollup_backfill_spec.rb  | 53 +++++++++++++
 .../reporting_events/backfill_service_spec.rb | 76 +++++++++++++++++++
 4 files changed, 151 insertions(+), 3 deletions(-)
 create mode 100644 spec/lib/reporting_events_rollup_backfill_spec.rb

diff --git a/app/services/reporting_events/backfill_service.rb b/app/services/reporting_events/backfill_service.rb
index 0deef624d..1bc585b81 100644
--- a/app/services/reporting_events/backfill_service.rb
+++ b/app/services/reporting_events/backfill_service.rb
@@ -25,10 +25,13 @@ class ReportingEvents::BackfillService
   end
 
   def perform
-    delete_existing_rollups
     start_utc, end_utc = date_boundaries_in_utc
     rollup_rows = build_rollup_rows(start_utc, end_utc)
-    bulk_insert_rollups(rollup_rows) if rollup_rows.any?
+
+    ReportingEventsRollup.transaction do
+      delete_existing_rollups
+      bulk_insert_rollups(rollup_rows) if rollup_rows.any?
+    end
   end
 
   private
diff --git a/lib/tasks/reporting_events_rollup.rake b/lib/tasks/reporting_events_rollup.rake
index 82cae898a..e21442cbb 100644
--- a/lib/tasks/reporting_events_rollup.rake
+++ b/lib/tasks/reporting_events_rollup.rake
@@ -187,6 +187,7 @@ class ReportingEventsRollupBackfill # rubocop:disable Metrics/ClassLength
     end
 
     print_success(account, days_processed, total_days, Time.current - start_time)
+    prompt_enable_rollup_read_path(account)
   rescue StandardError => e
     print_failure(e, days_processed, total_days)
   end
@@ -201,13 +202,28 @@ class ReportingEventsRollupBackfill # rubocop:disable Metrics/ClassLength
     puts "Average per Day:      #{(elapsed_time / days_processed).round(3)} seconds"
     puts ''
     puts 'Next steps:'
-    puts "1. Enable feature flag: Account.find(#{account.id}).enable_features!('reporting_events_rollup')"
+    puts '1. Verify parity before enabling the reporting_events_rollup read path.'
     puts '2. Verify rollups in database:'
     puts "   ReportingEventsRollup.where(account_id: #{account.id}).count"
     puts '3. Test reports to compare rollup vs raw performance'
     puts color('=' * 70, :green)
   end
 
+  def prompt_enable_rollup_read_path(account)
+    if account.feature_enabled?(:reporting_events_rollup)
+      puts color('reporting_events_rollup is already enabled for this account.', :yellow, :bold)
+      return
+    end
+
+    print 'Enable reporting_events_rollup read path now? Only do this after parity verification. (y/N): '
+    confirm = $stdin.gets.to_s.chomp.downcase
+    puts ''
+    return unless %w[y yes].include?(confirm)
+
+    account.enable_features!('reporting_events_rollup')
+    puts color("Enabled reporting_events_rollup for account #{account.id}", :green, :bold)
+  end
+
   def print_failure(error, days_processed, total_days)
     puts "\n\n"
     puts color('=' * 70, :red)
diff --git a/spec/lib/reporting_events_rollup_backfill_spec.rb b/spec/lib/reporting_events_rollup_backfill_spec.rb
new file mode 100644
index 000000000..59ccd1c2a
--- /dev/null
+++ b/spec/lib/reporting_events_rollup_backfill_spec.rb
@@ -0,0 +1,53 @@
+require 'rails_helper'
+require 'rake'
+
+Rails.application.load_tasks unless Object.const_defined?(:ReportingEventsRollupBackfill)
+
+describe ReportingEventsRollupBackfill do
+  let(:service) { described_class.new }
+  let(:account) { create(:account, reporting_timezone: 'America/New_York') }
+  let(:date) { Date.new(2026, 2, 11) }
+
+  describe '#execute_backfill' do
+    before do
+      allow(ReportingEvents::BackfillService).to receive(:backfill_date)
+      allow($stdout).to receive(:flush)
+    end
+
+    it 'prompts to enable the read path only after a successful backfill' do
+      allow(service).to receive(:print_success)
+
+      expect(service).to receive(:prompt_enable_rollup_read_path).with(account)
+
+      service.send(:execute_backfill, account, date, date, 1)
+    end
+
+    it 'does not prompt to enable the read path when backfill fails' do
+      allow(ReportingEvents::BackfillService).to receive(:backfill_date).and_raise(StandardError, 'boom')
+
+      expect(service).not_to receive(:prompt_enable_rollup_read_path)
+
+      expect do
+        service.send(:execute_backfill, account, date, date, 1)
+      end.to raise_error(SystemExit)
+    end
+  end
+
+  describe '#prompt_enable_rollup_read_path' do
+    it 'enables the feature flag when the user confirms' do
+      allow($stdin).to receive(:gets).and_return("y\n")
+
+      expect(account).to receive(:enable_features!).with('reporting_events_rollup')
+
+      service.send(:prompt_enable_rollup_read_path, account)
+    end
+
+    it 'does not enable the feature flag when the user declines' do
+      allow($stdin).to receive(:gets).and_return("n\n")
+
+      expect(account).not_to receive(:enable_features!)
+
+      service.send(:prompt_enable_rollup_read_path, account)
+    end
+  end
+end
diff --git a/spec/services/reporting_events/backfill_service_spec.rb b/spec/services/reporting_events/backfill_service_spec.rb
index 8f0572d3b..625f9b4e7 100644
--- a/spec/services/reporting_events/backfill_service_spec.rb
+++ b/spec/services/reporting_events/backfill_service_spec.rb
@@ -42,6 +42,82 @@ describe ReportingEvents::BackfillService do
       expect(rollup.sum_value_business_hours).to eq(0)
     end
 
+    it 'preserves existing rollups when building replacement rows fails' do
+      create(
+        :reporting_events_rollup,
+        account: account,
+        date: date,
+        dimension_type: 'account',
+        dimension_id: account.id,
+        metric: 'first_response',
+        count: 7,
+        sum_value: 700,
+        sum_value_business_hours: 350
+      )
+
+      service = described_class.new(account, date)
+      allow(service).to receive(:build_rollup_rows).and_raise(StandardError, 'boom')
+
+      expect do
+        service.perform
+      end.to raise_error(StandardError, 'boom')
+
+      rollup = ReportingEventsRollup.find_by!(
+        account_id: account.id,
+        date: date,
+        dimension_type: 'account',
+        dimension_id: account.id,
+        metric: 'first_response'
+      )
+
+      expect(rollup.count).to eq(7)
+      expect(rollup.sum_value).to eq(700)
+      expect(rollup.sum_value_business_hours).to eq(350)
+    end
+
+    it 'preserves existing rollups when replacing rows fails' do
+      create(
+        :reporting_events_rollup,
+        account: account,
+        date: date,
+        dimension_type: 'account',
+        dimension_id: account.id,
+        metric: 'first_response',
+        count: 7,
+        sum_value: 700,
+        sum_value_business_hours: 350
+      )
+
+      create_backfill_event(
+        name: 'first_response',
+        value: 100,
+        value_in_business_hours: 50,
+        user: user,
+        inbox: inbox,
+        conversation: conversation,
+        created_at: Time.utc(2026, 2, 11, 15)
+      )
+
+      service = described_class.new(account, date)
+      allow(service).to receive(:bulk_insert_rollups).and_raise(StandardError, 'boom')
+
+      expect do
+        service.perform
+      end.to raise_error(StandardError, 'boom')
+
+      rollup = ReportingEventsRollup.find_by!(
+        account_id: account.id,
+        date: date,
+        dimension_type: 'account',
+        dimension_id: account.id,
+        metric: 'first_response'
+      )
+
+      expect(rollup.count).to eq(7)
+      expect(rollup.sum_value).to eq(700)
+      expect(rollup.sum_value_business_hours).to eq(350)
+    end
+
     it 'aggregates grouped rows without instantiating reporting events' do
       second_user = create(:user, account: account)
       second_inbox = create(:inbox, account: account)

From 1154f9ccb436a8ec4d530c010d8da58054b2594e Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 12:31:33 +0530
Subject: [PATCH 08/16] chore: remove prompt enable outside resuce

---
 lib/tasks/reporting_events_rollup.rake         |  3 ++-
 .../reporting_events_rollup_backfill_spec.rb   | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/lib/tasks/reporting_events_rollup.rake b/lib/tasks/reporting_events_rollup.rake
index e21442cbb..c54b155a5 100644
--- a/lib/tasks/reporting_events_rollup.rake
+++ b/lib/tasks/reporting_events_rollup.rake
@@ -187,9 +187,10 @@ class ReportingEventsRollupBackfill # rubocop:disable Metrics/ClassLength
     end
 
     print_success(account, days_processed, total_days, Time.current - start_time)
-    prompt_enable_rollup_read_path(account)
   rescue StandardError => e
     print_failure(e, days_processed, total_days)
+  else
+    prompt_enable_rollup_read_path(account)
   end
 
   def print_success(account, days_processed, _total_days, elapsed_time)
diff --git a/spec/lib/reporting_events_rollup_backfill_spec.rb b/spec/lib/reporting_events_rollup_backfill_spec.rb
index 59ccd1c2a..58128a305 100644
--- a/spec/lib/reporting_events_rollup_backfill_spec.rb
+++ b/spec/lib/reporting_events_rollup_backfill_spec.rb
@@ -31,6 +31,16 @@ describe ReportingEventsRollupBackfill do
         service.send(:execute_backfill, account, date, date, 1)
       end.to raise_error(SystemExit)
     end
+
+    it 'does not report the backfill as failed when enabling the read path fails' do
+      allow(service).to receive(:print_success)
+      allow(service).to receive(:print_failure)
+      allow(service).to receive(:prompt_enable_rollup_read_path).and_raise(StandardError, 'toggle failed')
+
+      expect do
+        service.send(:execute_backfill, account, date, date, 1)
+      end.to raise_error(StandardError, 'toggle failed')
+    end
   end
 
   describe '#prompt_enable_rollup_read_path' do
@@ -49,5 +59,13 @@ describe ReportingEventsRollupBackfill do
 
       service.send(:prompt_enable_rollup_read_path, account)
     end
+
+    it 'skips the prompt when the feature is already enabled' do
+      allow(account).to receive(:feature_enabled?).with(:reporting_events_rollup).and_return(true)
+
+      expect($stdin).not_to receive(:gets)
+
+      service.send(:prompt_enable_rollup_read_path, account)
+    end
   end
 end

From c83546e67a8f29d8134897886d71c3e7ab2b7575 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 12:37:47 +0530
Subject: [PATCH 09/16] style: split specs

---
 .../reporting_events/backfill_service_spec.rb | 96 +++++++++++--------
 1 file changed, 55 insertions(+), 41 deletions(-)

diff --git a/spec/services/reporting_events/backfill_service_spec.rb b/spec/services/reporting_events/backfill_service_spec.rb
index 625f9b4e7..bf18106fb 100644
--- a/spec/services/reporting_events/backfill_service_spec.rb
+++ b/spec/services/reporting_events/backfill_service_spec.rb
@@ -118,57 +118,71 @@ describe ReportingEvents::BackfillService do
       expect(rollup.sum_value_business_hours).to eq(350)
     end
 
-    it 'aggregates grouped rows without instantiating reporting events' do
-      second_user = create(:user, account: account)
-      second_inbox = create(:inbox, account: account)
-      second_conversation = create(:conversation, account: account, inbox: second_inbox, assignee: second_user)
+    context 'when aggregating grouped rows' do
+      let(:second_user) { create(:user, account: account) }
+      let(:second_inbox) { create(:inbox, account: account) }
+      let(:second_conversation) { create(:conversation, account: account, inbox: second_inbox, assignee: second_user) }
 
-      create_backfill_event(name: 'first_response', value: 100, value_in_business_hours: 60, user: user,
-                            inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 14))
-      create_backfill_event(name: 'first_response', value: 40, value_in_business_hours: 20, user: user,
-                            inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 15))
-      create_backfill_event(name: 'conversation_resolved', value: 200, value_in_business_hours: 80, user: second_user,
-                            inbox: second_inbox, conversation: second_conversation, created_at: Time.utc(2026, 2, 11, 16))
-      create_backfill_event(name: 'reply_time', value: 500, value_in_business_hours: 300, user: user,
-                            inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 12, 5))
-
-      reporting_event_instantiations = count_reporting_event_instantiations do
+      before do
+        create_backfill_event(name: 'first_response', value: 100, value_in_business_hours: 60, user: user,
+                              inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 14))
+        create_backfill_event(name: 'first_response', value: 40, value_in_business_hours: 20, user: user,
+                              inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 15))
+        create_backfill_event(name: 'conversation_resolved', value: 200, value_in_business_hours: 80, user: second_user,
+                              inbox: second_inbox, conversation: second_conversation, created_at: Time.utc(2026, 2, 11, 16))
+        create_backfill_event(name: 'reply_time', value: 500, value_in_business_hours: 300, user: user,
+                              inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 12, 5))
         described_class.backfill_date(account, date)
       end
 
-      expect(reporting_event_instantiations).to eq(0)
+      it 'does not instantiate reporting events' do
+        reporting_event_instantiations = count_reporting_event_instantiations do
+          described_class.backfill_date(account, date)
+        end
 
-      rollups = ReportingEventsRollup.where(account_id: account.id, date: date)
-      # 3 dimensions × first_response + 3 dimensions × resolutions_count + 3 dimensions × resolution_time
-      expect(rollups.count).to eq(9)
+        expect(reporting_event_instantiations).to eq(0)
+      end
 
-      # account dimension
-      account_first_response = find_rollup('account', account.id, 'first_response')
-      expect(account_first_response.count).to eq(2)
-      expect(account_first_response.sum_value).to eq(140)
-      expect(account_first_response.sum_value_business_hours).to eq(80)
+      it 'creates the expected number of rollup rows' do
+        rollups = ReportingEventsRollup.where(account_id: account.id, date: date)
+        # 3 dimensions × first_response + 3 dimensions × resolutions_count + 3 dimensions × resolution_time
+        expect(rollups.count).to eq(9)
+      end
 
-      # agent dimension
-      agent_first_response = find_rollup('agent', user.id, 'first_response')
-      expect(agent_first_response.count).to eq(2)
-      expect(agent_first_response.sum_value).to eq(140)
-      expect(agent_first_response.sum_value_business_hours).to eq(80)
+      it 'aggregates first_response at the account dimension' do
+        account_first_response = find_rollup('account', account.id, 'first_response')
+        expect(account_first_response.count).to eq(2)
+        expect(account_first_response.sum_value).to eq(140)
+        expect(account_first_response.sum_value_business_hours).to eq(80)
+      end
 
-      agent_resolution_time = find_rollup('agent', second_user.id, 'resolution_time')
-      expect(agent_resolution_time.count).to eq(1)
-      expect(agent_resolution_time.sum_value).to eq(200)
-      expect(agent_resolution_time.sum_value_business_hours).to eq(80)
+      it 'aggregates first_response at the agent dimension' do
+        agent_first_response = find_rollup('agent', user.id, 'first_response')
+        expect(agent_first_response.count).to eq(2)
+        expect(agent_first_response.sum_value).to eq(140)
+        expect(agent_first_response.sum_value_business_hours).to eq(80)
+      end
 
-      # inbox dimension
-      inbox_first_response = find_rollup('inbox', inbox.id, 'first_response')
-      expect(inbox_first_response.count).to eq(2)
-      expect(inbox_first_response.sum_value).to eq(140)
-      expect(inbox_first_response.sum_value_business_hours).to eq(80)
+      it 'aggregates resolution_time at the agent dimension' do
+        agent_resolution_time = find_rollup('agent', second_user.id, 'resolution_time')
+        expect(agent_resolution_time.count).to eq(1)
+        expect(agent_resolution_time.sum_value).to eq(200)
+        expect(agent_resolution_time.sum_value_business_hours).to eq(80)
+      end
 
-      inbox_resolution_time = find_rollup('inbox', second_inbox.id, 'resolution_time')
-      expect(inbox_resolution_time.count).to eq(1)
-      expect(inbox_resolution_time.sum_value).to eq(200)
-      expect(inbox_resolution_time.sum_value_business_hours).to eq(80)
+      it 'aggregates first_response at the inbox dimension' do
+        inbox_first_response = find_rollup('inbox', inbox.id, 'first_response')
+        expect(inbox_first_response.count).to eq(2)
+        expect(inbox_first_response.sum_value).to eq(140)
+        expect(inbox_first_response.sum_value_business_hours).to eq(80)
+      end
+
+      it 'aggregates resolution_time at the inbox dimension' do
+        inbox_resolution_time = find_rollup('inbox', second_inbox.id, 'resolution_time')
+        expect(inbox_resolution_time.count).to eq(1)
+        expect(inbox_resolution_time.sum_value).to eq(200)
+        expect(inbox_resolution_time.sum_value_business_hours).to eq(80)
+      end
     end
 
     it 'deduplicates distinct-count events per dimension' do

From 7ad8011a1bfd85c3039238d1d6bd14ed93c0a238 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 12:39:42 +0530
Subject: [PATCH 10/16] style: fix ABC size

---
 .../reporting_events/backfill_service.rb      | 27 +++++++++----------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/app/services/reporting_events/backfill_service.rb b/app/services/reporting_events/backfill_service.rb
index 1bc585b81..9afc9fe2d 100644
--- a/app/services/reporting_events/backfill_service.rb
+++ b/app/services/reporting_events/backfill_service.rb
@@ -86,14 +86,17 @@ class ReportingEvents::BackfillService
       event_name, dimension_id, count, sum_value, sum_value_business_hours = unpack_row(row, dimension)
       next if dimension_id.nil?
 
-      ReportingEvents::EventMetricRegistry.metrics_for_aggregate(
-        event_name, count: count, sum_value: sum_value, sum_value_business_hours: sum_value_business_hours
-      ).each do |metric, metric_data|
-        key = [dimension[:type], dimension_id, metric]
-        aggregates[key][:count] += metric_data[:count]
-        aggregates[key][:sum_value] += metric_data[:sum_value].to_f
-        aggregates[key][:sum_value_business_hours] += metric_data[:sum_value_business_hours].to_f
-      end
+      accumulate_metrics(aggregates, dimension[:type], dimension_id, event_name,
+                         { count: count, sum_value: sum_value, sum_value_business_hours: sum_value_business_hours })
+    end
+  end
+
+  def accumulate_metrics(aggregates, dimension_type, dimension_id, event_name, values)
+    ReportingEvents::EventMetricRegistry.metrics_for_aggregate(event_name, **values).each do |metric, metric_data|
+      key = [dimension_type, dimension_id, metric]
+      aggregates[key][:count] += metric_data[:count]
+      aggregates[key][:sum_value] += metric_data[:sum_value].to_f
+      aggregates[key][:sum_value_business_hours] += metric_data[:sum_value_business_hours].to_f
     end
   end
 
@@ -106,12 +109,8 @@ class ReportingEvents::BackfillService
       event_name, dimension_id, count = dimension[:group_column] ? row : [row[0], @account.id, row[1]]
       next if dimension_id.nil?
 
-      ReportingEvents::EventMetricRegistry.metrics_for_aggregate(
-        event_name, count: count, sum_value: 0, sum_value_business_hours: 0
-      ).each do |metric, metric_data|
-        key = [dimension[:type], dimension_id, metric]
-        aggregates[key][:count] += metric_data[:count]
-      end
+      accumulate_metrics(aggregates, dimension[:type], dimension_id, event_name,
+                         { count: count, sum_value: 0, sum_value_business_hours: 0 })
     end
   end
 

From 2fab77d7c740fc39cf49c93efb1766c2e6a8ae9c Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 12:45:26 +0530
Subject: [PATCH 11/16] refactor: split large examples in backfill service spec

---
 .../reporting_events/backfill_service_spec.rb | 185 +++++++-----------
 1 file changed, 69 insertions(+), 116 deletions(-)

diff --git a/spec/services/reporting_events/backfill_service_spec.rb b/spec/services/reporting_events/backfill_service_spec.rb
index bf18106fb..df50006e8 100644
--- a/spec/services/reporting_events/backfill_service_spec.rb
+++ b/spec/services/reporting_events/backfill_service_spec.rb
@@ -9,113 +9,60 @@ describe ReportingEvents::BackfillService do
     let(:conversation) { create(:conversation, account: account, inbox: inbox, assignee: user) }
 
     it 'treats nil metric values as zero during backfill' do
-      reporting_event = create(
-        :reporting_event,
-        account: account,
-        name: 'first_response',
-        value: 100,
-        value_in_business_hours: 50,
-        user: user,
-        inbox: inbox,
-        conversation: conversation,
-        created_at: Time.utc(2026, 2, 11, 15)
+      reporting_event = create_backfill_event(
+        name: 'first_response', value: 100, value_in_business_hours: 50,
+        user: user, inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 15)
       )
       # Simulate a legacy row that already exists in the database with nil metrics.
       # rubocop:disable Rails/SkipsModelValidations
       reporting_event.update_columns(value: nil, value_in_business_hours: nil)
       # rubocop:enable Rails/SkipsModelValidations
 
-      expect do
-        described_class.backfill_date(account, date)
-      end.not_to raise_error
-
-      rollup = ReportingEventsRollup.find_by!(
-        account_id: account.id,
-        date: date,
-        dimension_type: 'account',
-        dimension_id: account.id,
-        metric: 'first_response'
-      )
+      expect { described_class.backfill_date(account, date) }.not_to raise_error
 
+      rollup = find_rollup('account', account.id, 'first_response')
       expect(rollup.count).to eq(1)
       expect(rollup.sum_value).to eq(0)
       expect(rollup.sum_value_business_hours).to eq(0)
     end
 
-    it 'preserves existing rollups when building replacement rows fails' do
-      create(
-        :reporting_events_rollup,
-        account: account,
-        date: date,
-        dimension_type: 'account',
-        dimension_id: account.id,
-        metric: 'first_response',
-        count: 7,
-        sum_value: 700,
-        sum_value_business_hours: 350
-      )
+    context 'when replacing rows fails atomically' do
+      before do
+        create(
+          :reporting_events_rollup,
+          account: account, date: date, dimension_type: 'account', dimension_id: account.id,
+          metric: 'first_response', count: 7, sum_value: 700, sum_value_business_hours: 350
+        )
+      end
 
-      service = described_class.new(account, date)
-      allow(service).to receive(:build_rollup_rows).and_raise(StandardError, 'boom')
+      it 'preserves existing rollups when building replacement rows fails' do
+        service = described_class.new(account, date)
+        allow(service).to receive(:build_rollup_rows).and_raise(StandardError, 'boom')
 
-      expect do
-        service.perform
-      end.to raise_error(StandardError, 'boom')
+        expect { service.perform }.to raise_error(StandardError, 'boom')
 
-      rollup = ReportingEventsRollup.find_by!(
-        account_id: account.id,
-        date: date,
-        dimension_type: 'account',
-        dimension_id: account.id,
-        metric: 'first_response'
-      )
+        rollup = find_rollup('account', account.id, 'first_response')
+        expect(rollup.count).to eq(7)
+        expect(rollup.sum_value).to eq(700)
+        expect(rollup.sum_value_business_hours).to eq(350)
+      end
 
-      expect(rollup.count).to eq(7)
-      expect(rollup.sum_value).to eq(700)
-      expect(rollup.sum_value_business_hours).to eq(350)
-    end
+      it 'preserves existing rollups when bulk insert fails' do
+        create_backfill_event(
+          name: 'first_response', value: 100, value_in_business_hours: 50,
+          user: user, inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 15)
+        )
 
-    it 'preserves existing rollups when replacing rows fails' do
-      create(
-        :reporting_events_rollup,
-        account: account,
-        date: date,
-        dimension_type: 'account',
-        dimension_id: account.id,
-        metric: 'first_response',
-        count: 7,
-        sum_value: 700,
-        sum_value_business_hours: 350
-      )
+        service = described_class.new(account, date)
+        allow(service).to receive(:bulk_insert_rollups).and_raise(StandardError, 'boom')
 
-      create_backfill_event(
-        name: 'first_response',
-        value: 100,
-        value_in_business_hours: 50,
-        user: user,
-        inbox: inbox,
-        conversation: conversation,
-        created_at: Time.utc(2026, 2, 11, 15)
-      )
+        expect { service.perform }.to raise_error(StandardError, 'boom')
 
-      service = described_class.new(account, date)
-      allow(service).to receive(:bulk_insert_rollups).and_raise(StandardError, 'boom')
-
-      expect do
-        service.perform
-      end.to raise_error(StandardError, 'boom')
-
-      rollup = ReportingEventsRollup.find_by!(
-        account_id: account.id,
-        date: date,
-        dimension_type: 'account',
-        dimension_id: account.id,
-        metric: 'first_response'
-      )
-
-      expect(rollup.count).to eq(7)
-      expect(rollup.sum_value).to eq(700)
-      expect(rollup.sum_value_business_hours).to eq(350)
+        rollup = find_rollup('account', account.id, 'first_response')
+        expect(rollup.count).to eq(7)
+        expect(rollup.sum_value).to eq(700)
+        expect(rollup.sum_value_business_hours).to eq(350)
+      end
     end
 
     context 'when aggregating grouped rows' do
@@ -185,39 +132,45 @@ describe ReportingEvents::BackfillService do
       end
     end
 
-    it 'deduplicates distinct-count events per dimension' do
-      second_user = create(:user, account: account)
-      second_inbox = create(:inbox, account: account)
-      conversation_b = create(:conversation, account: account, inbox: inbox, assignee: user)
-      conversation_c = create(:conversation, account: account, inbox: second_inbox, assignee: second_user)
+    context 'when deduplicating distinct-count events' do
+      let(:second_user) { create(:user, account: account) }
+      let(:second_inbox) { create(:inbox, account: account) }
+      let(:conversation_b) { create(:conversation, account: account, inbox: inbox, assignee: user) }
+      let(:conversation_c) { create(:conversation, account: account, inbox: second_inbox, assignee: second_user) }
 
-      # Two events for the same conversation — should count as 1
-      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
-                            inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 14))
-      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
-                            inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 15))
-      # Different conversation, same agent/inbox
-      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
-                            inbox: inbox, conversation: conversation_b, created_at: Time.utc(2026, 2, 11, 16))
-      # Different agent/inbox
-      create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: second_user,
-                            inbox: second_inbox, conversation: conversation_c, created_at: Time.utc(2026, 2, 11, 17))
+      before do
+        # Two events for the same conversation — should count as 1
+        create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
+                              inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 14))
+        create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
+                              inbox: inbox, conversation: conversation, created_at: Time.utc(2026, 2, 11, 15))
+        # Different conversation, same agent/inbox
+        create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: user,
+                              inbox: inbox, conversation: conversation_b, created_at: Time.utc(2026, 2, 11, 16))
+        # Different agent/inbox
+        create_backfill_event(name: 'conversation_bot_handoff', value: 0, value_in_business_hours: 0, user: second_user,
+                              inbox: second_inbox, conversation: conversation_c, created_at: Time.utc(2026, 2, 11, 17))
+        described_class.backfill_date(account, date)
+      end
 
-      described_class.backfill_date(account, date)
+      it 'creates the expected number of rollup rows' do
+        rollups = ReportingEventsRollup.where(account_id: account.id, date: date)
+        expect(rollups.count).to eq(5)
+      end
 
-      rollups = ReportingEventsRollup.where(account_id: account.id, date: date)
-      expect(rollups.count).to eq(5)
+      it 'counts 3 distinct conversations at the account dimension' do
+        expect(find_rollup('account', account.id, 'bot_handoffs_count').count).to eq(3)
+      end
 
-      # account: 3 distinct conversations
-      expect(find_rollup('account', account.id, 'bot_handoffs_count').count).to eq(3)
+      it 'counts distinct conversations per agent' do
+        expect(find_rollup('agent', user.id, 'bot_handoffs_count').count).to eq(2)
+        expect(find_rollup('agent', second_user.id, 'bot_handoffs_count').count).to eq(1)
+      end
 
-      # agent: user has 2 distinct, second_user has 1
-      expect(find_rollup('agent', user.id, 'bot_handoffs_count').count).to eq(2)
-      expect(find_rollup('agent', second_user.id, 'bot_handoffs_count').count).to eq(1)
-
-      # inbox: inbox has 2 distinct, second_inbox has 1
-      expect(find_rollup('inbox', inbox.id, 'bot_handoffs_count').count).to eq(2)
-      expect(find_rollup('inbox', second_inbox.id, 'bot_handoffs_count').count).to eq(1)
+      it 'counts distinct conversations per inbox' do
+        expect(find_rollup('inbox', inbox.id, 'bot_handoffs_count').count).to eq(2)
+        expect(find_rollup('inbox', second_inbox.id, 'bot_handoffs_count').count).to eq(1)
+      end
     end
 
     def create_backfill_event(**attributes)

From a452ce9e84bcd6ee95e34e8433fc08f2b0c732c5 Mon Sep 17 00:00:00 2001
From: Tanmay Deep Sharma <32020192+tds-1@users.noreply.github.com>
Date: Mon, 16 Mar 2026 12:48:16 +0530
Subject: [PATCH 12/16] feat(whatsapp): add webhook registration and status
 endpoints (#13551)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Description

Adds webhook configuration management for WhatsApp Cloud API channels,
allowing administrators to check webhook status and register webhooks
directly from Chatwoot without accessing Meta Business Manager.

## Type of change

- [ ] New feature (non-breaking change which adds functionality)


## Screenshots

<img width="1130" height="676" alt="Screenshot 2026-03-05 at 7 04 18 PM"
src="https://github.com/user-attachments/assets/f5dcd9dd-8827-42c5-a52b-1024012703c2"
/>
<img width="1101" height="651" alt="Screenshot 2026-03-05 at 7 04 29 PM"
src="https://github.com/user-attachments/assets/e0bd59f9-2a90-4f24-87c0-b79f21e721ee"
/>



## Checklist:

- [ ] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my code
- [ ] I have commented on my code, particularly in hard-to-understand
areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my
feature works
- [ ] New and existing unit tests pass locally with my changes
- [ ] Any dependent changes have been merged and published in downstream
modules

---------

Co-authored-by: Muhsin Keloth <muhsinkeramam@gmail.com>
---
 .../concerns/whatsapp_health_management.rb    | 55 +++++++++++++
 .../api/v1/accounts/inboxes_controller.rb     | 40 +---------
 app/javascript/dashboard/api/inboxHealth.js   |  4 +
 .../dashboard/i18n/locale/en/inboxMgmt.json   | 10 +++
 .../dashboard/settings/inbox/Settings.vue     | 24 +++++-
 .../inbox/components/AccountHealth.vue        | 77 +++++++++++++++++++
 app/services/whatsapp/health_service.rb       | 13 +++-
 .../whatsapp/webhook_setup_service.rb         | 15 ++--
 config/routes.rb                              |  1 +
 9 files changed, 194 insertions(+), 45 deletions(-)
 create mode 100644 app/controllers/api/v1/accounts/concerns/whatsapp_health_management.rb

diff --git a/app/controllers/api/v1/accounts/concerns/whatsapp_health_management.rb b/app/controllers/api/v1/accounts/concerns/whatsapp_health_management.rb
new file mode 100644
index 000000000..795d7f2a9
--- /dev/null
+++ b/app/controllers/api/v1/accounts/concerns/whatsapp_health_management.rb
@@ -0,0 +1,55 @@
+module Api::V1::Accounts::Concerns::WhatsappHealthManagement
+  extend ActiveSupport::Concern
+
+  included do
+    skip_before_action :check_authorization, only: [:health, :register_webhook]
+    before_action :check_admin_authorization?, only: [:register_webhook]
+    before_action :validate_whatsapp_cloud_channel, only: [:health, :register_webhook]
+  end
+
+  def sync_templates
+    return render status: :unprocessable_entity, json: { error: 'Template sync is only available for WhatsApp channels' } unless whatsapp_channel?
+
+    trigger_template_sync
+    render status: :ok, json: { message: 'Template sync initiated successfully' }
+  rescue StandardError => e
+    render status: :internal_server_error, json: { error: e.message }
+  end
+
+  def health
+    health_data = Whatsapp::HealthService.new(@inbox.channel).fetch_health_status
+    render json: health_data
+  rescue StandardError => e
+    Rails.logger.error "[INBOX HEALTH] Error fetching health data: #{e.message}"
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  def register_webhook
+    Whatsapp::WebhookSetupService.new(@inbox.channel).register_callback
+
+    render json: { message: 'Webhook registered successfully' }, status: :ok
+  rescue StandardError => e
+    Rails.logger.error "[INBOX WEBHOOK] Webhook registration failed: #{e.message}"
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  def validate_whatsapp_cloud_channel
+    return if @inbox.channel.is_a?(Channel::Whatsapp) && @inbox.channel.provider == 'whatsapp_cloud'
+
+    render json: { error: 'Health data only available for WhatsApp Cloud API channels' }, status: :bad_request
+  end
+
+  def whatsapp_channel?
+    @inbox.whatsapp? || (@inbox.twilio? && @inbox.channel.whatsapp?)
+  end
+
+  def trigger_template_sync
+    if @inbox.whatsapp?
+      Channels::Whatsapp::TemplatesSyncJob.perform_later(@inbox.channel)
+    elsif @inbox.twilio? && @inbox.channel.whatsapp?
+      Channels::Twilio::TemplatesSyncJob.perform_later(@inbox.channel)
+    end
+  end
+end
diff --git a/app/controllers/api/v1/accounts/inboxes_controller.rb b/app/controllers/api/v1/accounts/inboxes_controller.rb
index 322c7c7fe..4ca9a6af8 100644
--- a/app/controllers/api/v1/accounts/inboxes_controller.rb
+++ b/app/controllers/api/v1/accounts/inboxes_controller.rb
@@ -4,8 +4,9 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
   before_action :fetch_agent_bot, only: [:set_agent_bot]
   before_action :validate_limit, only: [:create]
   # we are already handling the authorization in fetch inbox
-  before_action :check_authorization, except: [:show, :health]
-  before_action :validate_whatsapp_cloud_channel, only: [:health]
+  before_action :check_authorization, except: [:show]
+
+  include Api::V1::Accounts::Concerns::WhatsappHealthManagement
 
   def index
     @inboxes = policy_scope(Current.account.inboxes.order_by_name.includes(:channel, { avatar_attachment: [:blob] }))
@@ -70,23 +71,6 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
     render status: :ok, json: { message: I18n.t('messages.inbox_deletetion_response') }
   end
 
-  def sync_templates
-    return render status: :unprocessable_entity, json: { error: 'Template sync is only available for WhatsApp channels' } unless whatsapp_channel?
-
-    trigger_template_sync
-    render status: :ok, json: { message: 'Template sync initiated successfully' }
-  rescue StandardError => e
-    render status: :internal_server_error, json: { error: e.message }
-  end
-
-  def health
-    health_data = Whatsapp::HealthService.new(@inbox.channel).fetch_health_status
-    render json: health_data
-  rescue StandardError => e
-    Rails.logger.error "[INBOX HEALTH] Error fetching health data: #{e.message}"
-    render json: { error: e.message }, status: :unprocessable_entity
-  end
-
   private
 
   def fetch_inbox
@@ -98,12 +82,6 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
     @agent_bot = AgentBot.find(params[:agent_bot]) if params[:agent_bot]
   end
 
-  def validate_whatsapp_cloud_channel
-    return if @inbox.channel.is_a?(Channel::Whatsapp) && @inbox.channel.provider == 'whatsapp_cloud'
-
-    render json: { error: 'Health data only available for WhatsApp Cloud API channels' }, status: :bad_request
-  end
-
   def create_channel
     return unless allowed_channel_types.include?(permitted_params[:channel][:type])
 
@@ -200,18 +178,6 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
   def get_channel_attributes(channel_type)
     channel_type.constantize.const_defined?(:EDITABLE_ATTRS) ? channel_type.constantize::EDITABLE_ATTRS.presence : []
   end
-
-  def whatsapp_channel?
-    @inbox.whatsapp? || (@inbox.twilio? && @inbox.channel.whatsapp?)
-  end
-
-  def trigger_template_sync
-    if @inbox.whatsapp?
-      Channels::Whatsapp::TemplatesSyncJob.perform_later(@inbox.channel)
-    elsif @inbox.twilio? && @inbox.channel.whatsapp?
-      Channels::Twilio::TemplatesSyncJob.perform_later(@inbox.channel)
-    end
-  end
 end
 
 Api::V1::Accounts::InboxesController.prepend_mod_with('Api::V1::Accounts::InboxesController')
diff --git a/app/javascript/dashboard/api/inboxHealth.js b/app/javascript/dashboard/api/inboxHealth.js
index 181b041ba..b8f69fcfe 100644
--- a/app/javascript/dashboard/api/inboxHealth.js
+++ b/app/javascript/dashboard/api/inboxHealth.js
@@ -9,6 +9,10 @@ class InboxHealthAPI extends ApiClient {
   getHealthStatus(inboxId) {
     return axios.get(`${this.url}/${inboxId}/health`);
   }
+
+  registerWebhook(inboxId) {
+    return axios.post(`${this.url}/${inboxId}/register_webhook`);
+  }
 }
 
 export default new InboxHealthAPI();
diff --git a/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json b/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json
index 8b982dc21..0455bdfa1 100644
--- a/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json
+++ b/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json
@@ -685,6 +685,16 @@
           "SANDBOX": "Sandbox",
           "LIVE": "Live"
         }
+      },
+      "WEBHOOK": {
+        "TITLE": "Webhook Configuration",
+        "DESCRIPTION": "Webhook URL is required for your WhatsApp Business Account to receive messages from customers",
+        "ACTION_REQUIRED": "Webhook not configured",
+        "REGISTER_BUTTON": "Register Webhook",
+        "REGISTER_SUCCESS": "Webhook registered successfully",
+        "REGISTER_ERROR": "Failed to register webhook. Please try again.",
+        "CONFIGURED_SUCCESS": "Webhook configured successfully",
+        "URL_MISMATCH": "Webhook URL mismatch"
       }
     },
     "SETTINGS": "Settings",
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
index a3c0bceed..0ff1ac61e 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
@@ -99,6 +99,7 @@ export default {
       healthData: null,
       isLoadingHealth: false,
       healthError: null,
+      isRegisteringWebhook: false,
       widgetBubblePosition: 'right',
       widgetBubbleType: 'standard',
       widgetBubbleLauncherTitle: '',
@@ -424,6 +425,23 @@ export default {
         this.isLoadingHealth = false;
       }
     },
+    async registerWebhook() {
+      if (!this.inbox) return;
+
+      try {
+        this.isRegisteringWebhook = true;
+        await InboxHealthAPI.registerWebhook(this.inbox.id);
+        useAlert(this.$t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.REGISTER_SUCCESS'));
+        await this.fetchHealthData();
+      } catch (error) {
+        useAlert(
+          error.message ||
+            this.$t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.REGISTER_ERROR')
+        );
+      } finally {
+        this.isRegisteringWebhook = false;
+      }
+    },
     handleFeatureFlag(e) {
       this.selectedFeatureFlags = this.toggleInput(
         this.selectedFeatureFlags,
@@ -1162,7 +1180,11 @@ export default {
           <BotConfiguration :inbox="inbox" />
         </div>
         <div v-if="selectedTabKey === 'whatsapp-health'">
-          <AccountHealth :health-data="healthData" />
+          <AccountHealth
+            :health-data="healthData"
+            :is-registering-webhook="isRegisteringWebhook"
+            @register-webhook="registerWebhook"
+          />
         </div>
       </div>
     </section>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/components/AccountHealth.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/components/AccountHealth.vue
index af32e6ad6..04c54ff0d 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/components/AccountHealth.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/components/AccountHealth.vue
@@ -10,8 +10,14 @@ const props = defineProps({
     type: Object,
     default: null,
   },
+  isRegisteringWebhook: {
+    type: Boolean,
+    default: false,
+  },
 });
 
+const emit = defineEmits(['registerWebhook']);
+
 const { t } = useI18n();
 
 const QUALITY_COLORS = {
@@ -133,6 +139,28 @@ const formatModeDisplay = mode =>
 const getModeStatusTextColor = mode => MODE_COLORS[mode] || 'text-n-slate-12';
 
 const getStatusTextColor = status => STATUS_COLORS[status] || 'text-n-slate-12';
+
+const showWebhookSection = computed(
+  () => props.healthData?.webhook_configuration !== undefined
+);
+
+const webhookUrl = computed(
+  () =>
+    props.healthData?.webhook_configuration?.whatsapp_business_account ||
+    props.healthData?.webhook_configuration?.application
+);
+
+const webhookConfigured = computed(() => !!webhookUrl.value);
+
+const webhookUrlMismatch = computed(
+  () =>
+    webhookConfigured.value &&
+    webhookUrl.value !== props.healthData?.expected_webhook_url
+);
+
+const handleRegisterWebhook = () => {
+  emit('registerWebhook');
+};
 </script>
 
 <template>
@@ -211,6 +239,55 @@ const getStatusTextColor = status => STATUS_COLORS[status] || 'text-n-slate-12';
             }}</span>
           </div>
         </div>
+
+        <!-- Webhook configuration card -->
+        <div
+          v-if="showWebhookSection"
+          class="flex flex-col gap-2 p-4 rounded-lg border border-n-weak bg-n-solid-1"
+        >
+          <div class="flex gap-2 items-center">
+            <span class="text-body-main font-medium text-n-slate-11">
+              {{ t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.TITLE') }}
+            </span>
+            <Icon
+              v-tooltip.top="t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.DESCRIPTION')"
+              icon="i-lucide-info"
+              class="flex-shrink-0 w-4 h-4 cursor-help text-n-slate-9"
+            />
+          </div>
+          <div class="flex items-center justify-between gap-3">
+            <span
+              v-if="webhookConfigured && !webhookUrlMismatch"
+              class="inline-flex items-center gap-1.5 px-2 py-0.5 min-h-6 text-label-small rounded-md bg-n-alpha-2 text-n-teal-11"
+            >
+              <Icon icon="i-lucide-check-circle" class="w-3.5 h-3.5" />
+              {{ t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.CONFIGURED_SUCCESS') }}
+            </span>
+            <span
+              v-else
+              class="inline-flex items-center gap-1.5 px-2 py-0.5 min-h-6 text-label-small rounded-md bg-n-alpha-2 text-n-amber-11"
+            >
+              <Icon icon="i-lucide-alert-triangle" class="w-3.5 h-3.5" />
+              {{
+                webhookUrlMismatch
+                  ? t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.URL_MISMATCH')
+                  : t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.ACTION_REQUIRED')
+              }}
+            </span>
+            <ButtonV4
+              v-if="!webhookConfigured || webhookUrlMismatch"
+              sm
+              solid
+              blue
+              :loading="isRegisteringWebhook"
+              :disabled="isRegisteringWebhook"
+              class="flex-shrink-0"
+              @click="handleRegisterWebhook"
+            >
+              {{ t('INBOX_MGMT.ACCOUNT_HEALTH.WEBHOOK.REGISTER_BUTTON') }}
+            </ButtonV4>
+          </div>
+        </div>
       </div>
 
       <div v-else class="pt-8">
diff --git a/app/services/whatsapp/health_service.rb b/app/services/whatsapp/health_service.rb
index 94789ef79..428fb4e6b 100644
--- a/app/services/whatsapp/health_service.rb
+++ b/app/services/whatsapp/health_service.rb
@@ -39,11 +39,11 @@ class Whatsapp::HealthService
 
   def health_fields
     %w[
+      id
       quality_rating
       messaging_limit_tier
       code_verification_status
       account_mode
-      id
       display_phone_number
       name_status
       verified_name
@@ -68,6 +68,7 @@ class Whatsapp::HealthService
 
   def format_health_response(response)
     {
+      id: response['id'],
       display_phone_number: response['display_phone_number'],
       verified_name: response['verified_name'],
       name_status: response['name_status'],
@@ -75,10 +76,20 @@ class Whatsapp::HealthService
       messaging_limit_tier: response['messaging_limit_tier'],
       account_mode: response['account_mode'],
       code_verification_status: response['code_verification_status'],
+      webhook_configuration: response['webhook_configuration'],
+      expected_webhook_url: build_expected_webhook_url,
       throughput: response['throughput'],
       last_onboarded_time: response['last_onboarded_time'],
       platform_type: response['platform_type'],
+      certificate: response['certificate'],
       business_id: @channel.provider_config['business_account_id']
     }
   end
+
+  def build_expected_webhook_url
+    frontend_url = ENV.fetch('FRONTEND_URL', nil)
+    return nil if frontend_url.blank?
+
+    "#{frontend_url}/webhooks/whatsapp/#{@channel.phone_number}"
+  end
 end
diff --git a/app/services/whatsapp/webhook_setup_service.rb b/app/services/whatsapp/webhook_setup_service.rb
index 63fed1e93..97a53eb9a 100644
--- a/app/services/whatsapp/webhook_setup_service.rb
+++ b/app/services/whatsapp/webhook_setup_service.rb
@@ -1,9 +1,9 @@
 class Whatsapp::WebhookSetupService
-  def initialize(channel, waba_id, access_token)
+  def initialize(channel, waba_id = nil, access_token = nil)
     @channel = channel
-    @waba_id = waba_id
-    @access_token = access_token
-    @api_client = Whatsapp::FacebookApiClient.new(access_token)
+    @waba_id = waba_id || channel.provider_config['business_account_id']
+    @access_token = access_token || channel.provider_config['api_key']
+    @api_client = Whatsapp::FacebookApiClient.new(@access_token)
   end
 
   def perform
@@ -17,6 +17,11 @@ class Whatsapp::WebhookSetupService
     setup_webhook
   end
 
+  def register_callback
+    validate_parameters!
+    setup_webhook
+  end
+
   private
 
   def validate_parameters!
@@ -33,8 +38,6 @@ class Whatsapp::WebhookSetupService
     store_pin(pin)
   rescue StandardError => e
     Rails.logger.warn("[WHATSAPP] Phone registration failed but continuing: #{e.message}")
-    # Continue with webhook setup even if registration fails
-    # This is just a warning, not a blocking error
   end
 
   def fetch_or_create_pin
diff --git a/config/routes.rb b/config/routes.rb
index 0992d21a2..5fe70bdca 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -218,6 +218,7 @@ Rails.application.routes.draw do
             delete :avatar, on: :member
             post :sync_templates, on: :member
             get :health, on: :member
+            post :register_webhook, on: :member
             if ChatwootApp.enterprise?
               resource :conference, only: %i[create destroy], controller: 'conference' do
                 get :token, on: :member

From a5c50354fcd32fb61a16a62908c88ecab28808c2 Mon Sep 17 00:00:00 2001
From: Tanmay Deep Sharma <32020192+tds-1@users.noreply.github.com>
Date: Mon, 16 Mar 2026 13:13:37 +0530
Subject: [PATCH 13/16] feat: trigger assignment on resolve (#13780)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Description

When an agent resolves or snoozes a conversation, their capacity frees
up — but under Assignment V2, no new conversation was assigned until the
next event triggered the assignment job. This meant agents could sit
idle despite having queued conversations waiting. This change triggers
the AssignmentJob immediately on resolve/snooze so freed capacity is
utilized right away.

## Type of change

- [ ] New feature (non-breaking change which adds functionality)

## How Has This Been Tested?

- Enable auto assignment v2 on an inbox
- Create a conversation (gets auto-assigned to an available agent)
- Resolve the conversation
- Verify that another unassigned conversation in the inbox gets assigned
to the freed-up agent

## Checklist:

- [ ] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my code
- [ ] I have commented on my code, particularly in hard-to-understand
areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my
feature works
- [ ] New and existing unit tests pass locally with my changes
- [ ] Any dependent changes have been merged and published in downstream
modules

---------

Co-authored-by: tds-1 <tds-1@users.noreply.github.com>
---
 app/models/concerns/auto_assignment_handler.rb | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/app/models/concerns/auto_assignment_handler.rb b/app/models/concerns/auto_assignment_handler.rb
index dca154842..6be7a8d85 100644
--- a/app/models/concerns/auto_assignment_handler.rb
+++ b/app/models/concerns/auto_assignment_handler.rb
@@ -9,9 +9,9 @@ module AutoAssignmentHandler
   private
 
   def run_auto_assignment
-    # Round robin kicks in on conversation create & update
-    # run it only when conversation status changes to open
-    return unless conversation_status_changed_to_open?
+    # Assignment V2: Also trigger assignment when conversation is resolved or snoozed,
+    # bypassing the open-only condition so the AssignmentJob can redistribute capacity.
+    return unless conversation_status_changed_to_open? || conversation_status_changed_to_resolved_or_snoozed?
     return unless should_run_auto_assignment?
 
     if inbox.auto_assignment_v2_enabled?
@@ -25,6 +25,10 @@ module AutoAssignmentHandler
     end
   end
 
+  def conversation_status_changed_to_resolved_or_snoozed?
+    inbox.auto_assignment_v2_enabled? && saved_change_to_status? && (resolved? || snoozed?)
+  end
+
   def team_member_ids_with_capacity
     return [] if team.blank? || team.allow_auto_assign.blank?
 
@@ -33,6 +37,9 @@ module AutoAssignmentHandler
 
   def should_run_auto_assignment?
     return false unless inbox.enable_auto_assignment?
+    # Assignment V2: Resolved/snoozed conversations still have an assignee, so bypass the
+    # assignee-blank check below. The AssignmentJob needs to run to rebalance assignments.
+    return true if conversation_status_changed_to_resolved_or_snoozed?
 
     # run only if assignee is blank or doesn't have access to inbox
     assignee.blank? || inbox.members.exclude?(assignee)

From 69a44ccf4d47110150f6770d5cfb53d0bc600517 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 18:53:23 +0530
Subject: [PATCH 14/16] refactor: wrap rollup action in a rescue block

---
 app/listeners/reporting_event_listener.rb     | 20 ++++++++++++++-----
 .../reporting_event_listener_spec.rb          | 17 ++++++++++++++++
 2 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/app/listeners/reporting_event_listener.rb b/app/listeners/reporting_event_listener.rb
index a216bd174..40aa0b0ac 100644
--- a/app/listeners/reporting_event_listener.rb
+++ b/app/listeners/reporting_event_listener.rb
@@ -21,7 +21,7 @@ class ReportingEventListener < BaseListener
 
     create_bot_resolved_event(conversation, reporting_event)
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
+    safe_rollup(reporting_event)
   end
 
   def first_reply_created(event)
@@ -43,7 +43,7 @@ class ReportingEventListener < BaseListener
     )
 
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
+    safe_rollup(reporting_event)
   end
 
   def reply_created(event)
@@ -68,7 +68,7 @@ class ReportingEventListener < BaseListener
       event_end_time: message.created_at
     )
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
+    safe_rollup(reporting_event)
   end
 
   def conversation_bot_handoff(event)
@@ -95,7 +95,7 @@ class ReportingEventListener < BaseListener
       event_end_time: event_end_time
     )
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
+    safe_rollup(reporting_event)
   end
 
   def conversation_captain_inference_resolved(event)
@@ -172,6 +172,16 @@ class ReportingEventListener < BaseListener
     bot_resolved_event = reporting_event.dup
     bot_resolved_event.name = 'conversation_bot_resolved'
     bot_resolved_event.save!
-    ReportingEvents::RollupService.perform(bot_resolved_event)
+    safe_rollup(bot_resolved_event)
+  end
+
+  def safe_rollup(reporting_event)
+    # Rollups are derived from the raw reporting event. If a transient rollup write
+    # failure bubbles out here, Sidekiq retries the dispatcher job and can insert the
+    # same raw event again. That can temporarily under-report rollups, but the source
+    # event is preserved and rollup data can be rebuilt or re-applied later.
+    ReportingEvents::RollupService.perform(reporting_event)
+  rescue StandardError => e
+    ChatwootExceptionTracker.new(e, account: reporting_event.account).capture_exception
   end
 end
diff --git a/spec/listeners/reporting_event_listener_spec.rb b/spec/listeners/reporting_event_listener_spec.rb
index 34b65e7ab..a497d7dd8 100644
--- a/spec/listeners/reporting_event_listener_spec.rb
+++ b/spec/listeners/reporting_event_listener_spec.rb
@@ -18,6 +18,23 @@ describe ReportingEventListener do
       expect(account.reporting_events.where(name: 'conversation_resolved').count).to be 1
     end
 
+    context 'when rollup creation fails' do
+      let(:event) { Events::Base.new('conversation.resolved', Time.zone.now, conversation: conversation) }
+      let(:error) { StandardError.new('rollup failed') }
+      let(:exception_tracker) { instance_double(ChatwootExceptionTracker, capture_exception: true) }
+
+      before do
+        allow(ReportingEvents::RollupService).to receive(:perform).and_raise(error)
+        allow(ChatwootExceptionTracker).to receive(:new).and_return(exception_tracker)
+      end
+
+      it 'captures the error without interrupting raw event creation' do
+        expect { listener.conversation_resolved(event) }.not_to raise_error
+        expect(ChatwootExceptionTracker).to have_received(:new).with(error, account: account)
+        expect(account.reporting_events.where(name: 'conversation_resolved').count).to be 1
+      end
+    end
+
     context 'when business hours enabled for inbox' do
       let(:created_at) { Time.zone.parse('March 20, 2022 00:00') }
       let(:updated_at) { Time.zone.parse('March 26, 2022 23:59') }

From 6693a4d6f7aecd65db76b52799906b7cf3852836 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 19:05:45 +0530
Subject: [PATCH 15/16] fix: rollup

---
 config/features.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/config/features.yml b/config/features.yml
index 894d94ef0..41515ff64 100644
--- a/config/features.yml
+++ b/config/features.yml
@@ -241,6 +241,3 @@
   display_name: Advanced Assignment
   enabled: false
   premium: true
-- name: reporting_events_rollup
-  display_name: Reporting Events Rollup
-  enabled: false

From 33b3a56d4cb55b661e486a18ac2813d85184a128 Mon Sep 17 00:00:00 2001
From: Shivam Mishra <scm.mymail@gmail.com>
Date: Mon, 16 Mar 2026 19:06:56 +0530
Subject: [PATCH 16/16] fix: feature flag

---
 lib/tasks/reporting_events_rollup.rake | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/tasks/reporting_events_rollup.rake b/lib/tasks/reporting_events_rollup.rake
index c54b155a5..da62feab8 100644
--- a/lib/tasks/reporting_events_rollup.rake
+++ b/lib/tasks/reporting_events_rollup.rake
@@ -211,18 +211,18 @@ class ReportingEventsRollupBackfill # rubocop:disable Metrics/ClassLength
   end
 
   def prompt_enable_rollup_read_path(account)
-    if account.feature_enabled?(:reporting_events_rollup)
-      puts color('reporting_events_rollup is already enabled for this account.', :yellow, :bold)
+    if account.feature_enabled?(:report_rollup)
+      puts color('report_rollup is already enabled for this account.', :yellow, :bold)
       return
     end
 
-    print 'Enable reporting_events_rollup read path now? Only do this after parity verification. (y/N): '
+    print 'Enable report_rollup read path now? Only do this after parity verification. (y/N): '
     confirm = $stdin.gets.to_s.chomp.downcase
     puts ''
     return unless %w[y yes].include?(confirm)
 
-    account.enable_features!('reporting_events_rollup')
-    puts color("Enabled reporting_events_rollup for account #{account.id}", :green, :bold)
+    account.enable_features!('report_rollup')
+    puts color("Enabled report_rollup for account #{account.id}", :green, :bold)
   end
 
   def print_failure(error, days_processed, total_days)