style: remove redundant space

.eslintrc.js

@@ -1,256 +0,0 @@
-module.exports = {
-  extends: [
-    'airbnb-base/legacy',
-    'prettier',
-    'plugin:vue/vue3-recommended',
-    'plugin:vitest-globals/recommended',
-    // use recommended-legacy when upgrading the plugin to v4
-    'plugin:@intlify/vue-i18n/recommended',
-  ],
-  overrides: [
-    {
-      files: ['**/*.spec.{j,t}s?(x)'],
-      env: {
-        'vitest-globals/env': true,
-      },
-    },
-    {
-      files: ['**/*.story.vue'],
-      rules: {
-        'vue/no-undef-components': [
-          'error',
-          {
-            ignorePatterns: ['Variant', 'Story'],
-          },
-        ],
-        // Story files can have static strings, it doesn't need to handle i18n always.
-        'vue/no-bare-strings-in-template': 'off',
-        'no-console': 'off',
-      },
-    },
-  ],
-  plugins: ['html', 'prettier'],
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-  },
-  rules: {
-    'prettier/prettier': ['error'],
-    camelcase: 'off',
-    'no-param-reassign': 'off',
-    'import/no-extraneous-dependencies': 'off',
-    'import/prefer-default-export': 'off',
-    'import/no-named-as-default': 'off',
-    'jsx-a11y/no-static-element-interactions': 'off',
-    'jsx-a11y/click-events-have-key-events': 'off',
-    'jsx-a11y/label-has-associated-control': 'off',
-    'jsx-a11y/label-has-for': 'off',
-    'jsx-a11y/anchor-is-valid': 'off',
-    'import/no-unresolved': 'off',
-    'vue/html-indent': 'off',
-    'vue/multi-word-component-names': 'off',
-    'vue/next-tick-style': ['error', 'callback'],
-    'vue/block-order': [
-      'error',
-      {
-        order: ['script', 'template', 'style'],
-      },
-    ],
-    'vue/component-name-in-template-casing': [
-      'error',
-      'PascalCase',
-      {
-        registeredComponentsOnly: true,
-      },
-    ],
-    'vue/component-options-name-casing': ['error', 'PascalCase'],
-    'vue/custom-event-name-casing': ['error', 'camelCase'],
-    'vue/define-emits-declaration': ['error'],
-    'vue/define-macros-order': [
-      'error',
-      {
-        order: ['defineProps', 'defineEmits'],
-        defineExposeLast: false,
-      },
-    ],
-    'vue/define-props-declaration': ['error', 'runtime'],
-    'vue/match-component-import-name': ['error'],
-    'vue/no-bare-strings-in-template': [
-      'error',
-      {
-        allowlist: [
-          '(',
-          ')',
-          ',',
-          '.',
-          '&',
-          '+',
-          '-',
-          '=',
-          '*',
-          '/',
-          '#',
-          '%',
-          '!',
-          '?',
-          ':',
-          '[',
-          ']',
-          '{',
-          '}',
-          '<',
-          '>',
-          '⌘',
-          '📄',
-          '🎉',
-          '🚀',
-          '💬',
-          '👥',
-          '📥',
-          '🔖',
-          '❌',
-          '✅',
-          '\u00b7',
-          '\u2022',
-          '\u2010',
-          '\u2013',
-          '\u2014',
-          '\u2212',
-          '|',
-        ],
-        attributes: {
-          '/.+/': [
-            'title',
-            'aria-label',
-            'aria-placeholder',
-            'aria-roledescription',
-            'aria-valuetext',
-          ],
-          input: ['placeholder'],
-        },
-        directives: ['v-text'],
-      },
-    ],
-    'vue/no-empty-component-block': 'error',
-    'vue/no-multiple-objects-in-class': 'error',
-    'vue/no-root-v-if': 'warn',
-    'vue/no-static-inline-styles': [
-      'error',
-      {
-        allowBinding: false,
-      },
-    ],
-    'vue/no-template-target-blank': [
-      'error',
-      {
-        allowReferrer: false,
-        enforceDynamicLinks: 'always',
-      },
-    ],
-    'vue/no-required-prop-with-default': [
-      'error',
-      {
-        autofix: false,
-      },
-    ],
-    'vue/no-this-in-before-route-enter': 'error',
-    'vue/no-undef-components': [
-      'error',
-      {
-        ignorePatterns: [
-          '^woot-',
-          '^fluent-',
-          '^multiselect',
-          '^router-link',
-          '^router-view',
-          '^ninja-keys',
-          '^FormulateForm',
-          '^FormulateInput',
-          '^highlightjs',
-        ],
-      },
-    ],
-    'vue/no-unused-emit-declarations': 'error',
-    'vue/no-unused-refs': 'error',
-    'vue/no-use-v-else-with-v-for': 'error',
-    'vue/prefer-true-attribute-shorthand': 'error',
-    'vue/no-useless-v-bind': [
-      'error',
-      {
-        ignoreIncludesComment: false,
-        ignoreStringEscape: false,
-      },
-    ],
-    'vue/no-v-text': 'error',
-    'vue/padding-line-between-blocks': ['error', 'always'],
-    'vue/prefer-separate-static-class': 'error',
-    'vue/require-explicit-slots': 'error',
-    'vue/require-macro-variable-name': [
-      'error',
-      {
-        defineProps: 'props',
-        defineEmits: 'emit',
-        defineSlots: 'slots',
-        useSlots: 'slots',
-        useAttrs: 'attrs',
-      },
-    ],
-    'vue/no-unused-properties': [
-      'error',
-      {
-        groups: ['props'],
-        deepData: false,
-        ignorePublicMembers: false,
-        unreferencedOptions: [],
-      },
-    ],
-    'vue/max-attributes-per-line': [
-      'error',
-      {
-        singleline: {
-          max: 20,
-        },
-        multiline: {
-          max: 1,
-        },
-      },
-    ],
-    'vue/html-self-closing': [
-      'error',
-      {
-        html: {
-          void: 'always',
-          normal: 'always',
-          component: 'always',
-        },
-        svg: 'always',
-        math: 'always',
-      },
-    ],
-    'vue/no-v-html': 'off',
-    'vue/component-definition-name-casing': 'off',
-    'vue/singleline-html-element-content-newline': 'off',
-    'import/extensions': ['off'],
-    'no-console': 'error',
-    '@intlify/vue-i18n/no-dynamic-keys': 'warn',
-    '@intlify/vue-i18n/no-unused-keys': [
-      'warn',
-      {
-        extensions: ['.js', '.vue'],
-      },
-    ],
-  },
-  settings: {
-    'vue-i18n': {
-      localeDir: './app/javascript/*/i18n/**.json',
-    },
-  },
-  env: {
-    browser: true,
-    node: true,
-  },
-  globals: {
-    bus: true,
-    vi: true,
-  },
-};

app/actions/contact_identify_action.rb

@@ -104,7 +104,7 @@ class ContactIdentifyAction
     # blank identifier or email will throw unique index error
     # TODO: replace reject { |_k, v| v.blank? } with compact_blank when rails is upgraded
     @contact.discard_invalid_attrs if discard_invalid_attrs
-    @contact.save! if @contact.changed?
+    @contact.save!
     enqueue_avatar_job
   end
 

app/builders/v2/report_builder.rb

@@ -1,7 +1,6 @@
 class V2::ReportBuilder
   include DateRangeHelper
   include ReportHelper
-
   attr_reader :account, :params
 
   DEFAULT_GROUP_BY = 'day'.freeze

app/builders/v2/reports/agent_summary_builder.rb

@@ -11,6 +11,10 @@ class V2::Reports::AgentSummaryBuilder < V2::Reports::BaseSummaryBuilder
   attr_reader :conversations_count, :resolved_count,
               :avg_resolution_time, :avg_first_response_time, :avg_reply_time
 
+  def fetch_conversations_count
+    account.conversations.where(created_at: range).group('assignee_id').count
+  end
+
   def prepare_report
     account.account_users.map do |account_user|
       build_agent_stats(account_user)

app/builders/v2/reports/base_summary_builder.rb

@@ -1,6 +1,5 @@
 class V2::Reports::BaseSummaryBuilder
   include DateRangeHelper
-  include TimezoneHelper
 
   def build
     load_data
@@ -10,13 +9,37 @@ class V2::Reports::BaseSummaryBuilder
   private
 
   def load_data
-    results = data_source.summary
+    @conversations_count = fetch_conversations_count
+    load_reporting_events_data
+  end
 
-    @conversations_count = results.transform_values { |data| data[:conversations_count] }
-    @resolved_count = results.transform_values { |data| data[:resolved_conversations_count] }
-    @avg_resolution_time = results.transform_values { |data| data[:avg_resolution_time] }
-    @avg_first_response_time = results.transform_values { |data| data[:avg_first_response_time] }
-    @avg_reply_time = results.transform_values { |data| data[:avg_reply_time] }
+  def load_reporting_events_data
+    # Extract the column name for indexing (e.g., 'conversations.team_id' -> 'team_id')
+    index_key = group_by_key.to_s.split('.').last
+
+    results = reporting_events
+              .select(
+                "#{group_by_key} as #{index_key}",
+                "COUNT(CASE WHEN name = 'conversation_resolved' THEN 1 END) as resolved_count",
+                "AVG(CASE WHEN name = 'conversation_resolved' THEN #{average_value_key} END) as avg_resolution_time",
+                "AVG(CASE WHEN name = 'first_response' THEN #{average_value_key} END) as avg_first_response_time",
+                "AVG(CASE WHEN name = 'reply_time' THEN #{average_value_key} END) as avg_reply_time"
+              )
+              .group(group_by_key)
+              .index_by { |record| record.public_send(index_key) }
+
+    @resolved_count = results.transform_values(&:resolved_count)
+    @avg_resolution_time = results.transform_values(&:avg_resolution_time)
+    @avg_first_response_time = results.transform_values(&:avg_first_response_time)
+    @avg_reply_time = results.transform_values(&:avg_reply_time)
+  end
+
+  def reporting_events
+    @reporting_events ||= account.reporting_events.where(created_at: range)
+  end
+
+  def fetch_conversations_count
+    # Override this method
   end
 
   def group_by_key
@@ -27,27 +50,7 @@ class V2::Reports::BaseSummaryBuilder
     # Override this method
   end
 
-  def data_source
-    @data_source ||= Reports::DataSource.for(
-      account: account,
-      metric: nil,
-      dimension_type: summary_dimension_type,
-      dimension_id: nil,
-      scope: nil,
-      range: range,
-      group_by: 'day',
-      timezone: timezone_name_from_params(params[:timezone], params[:timezone_offset]),
-      timezone_offset: params[:timezone_offset],
-      business_hours: params[:business_hours]
-    )
-  end
-
-  def summary_dimension_type
-    {
-      'account_id' => 'account',
-      'user_id' => 'agent',
-      'inbox_id' => 'inbox',
-      'conversations.team_id' => 'team'
-    }.fetch(group_by_key.to_s)
+  def average_value_key
+    ActiveModel::Type::Boolean.new.cast(params[:business_hours]).present? ? :value_in_business_hours : :value
   end
 end

app/builders/v2/reports/conversations/base_report_builder.rb

@@ -3,10 +3,23 @@ class V2::Reports::Conversations::BaseReportBuilder
 
   private
 
-  def builder_class(metric)
-    return unless ReportingEvents::MetricRegistry.supported_metric?(metric)
+  AVG_METRICS = %w[avg_first_response_time avg_resolution_time reply_time].freeze
+  COUNT_METRICS = %w[
+    conversations_count
+    incoming_messages_count
+    outgoing_messages_count
+    resolutions_count
+    bot_resolutions_count
+    bot_handoffs_count
+  ].freeze
 
-    V2::Reports::Timeseries::ReportBuilder
+  def builder_class(metric)
+    case metric
+    when *AVG_METRICS
+      V2::Reports::Timeseries::AverageReportBuilder
+    when *COUNT_METRICS
+      V2::Reports::Timeseries::CountReportBuilder
+    end
   end
 
   def log_invalid_metric

app/builders/v2/reports/inbox_summary_builder.rb

@@ -11,6 +11,15 @@ class V2::Reports::InboxSummaryBuilder < V2::Reports::BaseSummaryBuilder
   attr_reader :conversations_count, :resolved_count,
               :avg_resolution_time, :avg_first_response_time, :avg_reply_time
 
+  def load_data
+    @conversations_count = fetch_conversations_count
+    load_reporting_events_data
+  end
+
+  def fetch_conversations_count
+    account.conversations.where(created_at: range).group(group_by_key).count
+  end
+
   def prepare_report
     account.inboxes.map do |inbox|
       build_inbox_stats(inbox)
@@ -31,4 +40,8 @@ class V2::Reports::InboxSummaryBuilder < V2::Reports::BaseSummaryBuilder
   def group_by_key
     :inbox_id
   end
+
+  def average_value_key
+    ActiveModel::Type::Boolean.new.cast(params[:business_hours]) ? :value_in_business_hours : :value
+  end
 end

app/builders/v2/reports/label_summary_builder.rb

@@ -7,7 +7,8 @@ class V2::Reports::LabelSummaryBuilder < V2::Reports::BaseSummaryBuilder
     @account = account
     @params = params
 
-    @timezone = timezone_name_from_params(params[:timezone], params[:timezone_offset])
+    timezone_offset = (params[:timezone_offset] || 0).to_f
+    @timezone = ActiveSupport::TimeZone[timezone_offset]&.name
   end
   # rubocop:enable Lint/MissingSuper
 

app/builders/v2/reports/team_summary_builder.rb

@@ -6,6 +6,14 @@ class V2::Reports::TeamSummaryBuilder < V2::Reports::BaseSummaryBuilder
   attr_reader :conversations_count, :resolved_count,
               :avg_resolution_time, :avg_first_response_time, :avg_reply_time
 
+  def fetch_conversations_count
+    account.conversations.where(created_at: range).group(:team_id).count
+  end
+
+  def reporting_events
+    @reporting_events ||= account.reporting_events.where(created_at: range).joins(:conversation)
+  end
+
   def prepare_report
     account.teams.map do |team|
       build_team_stats(team)

app/builders/v2/reports/timeseries/average_report_builder.rb

@@ -0,0 +1,48 @@
+class V2::Reports::Timeseries::AverageReportBuilder < V2::Reports::Timeseries::BaseTimeseriesBuilder
+  def timeseries
+    grouped_average_time = reporting_events.average(average_value_key)
+    grouped_event_count = reporting_events.count
+    grouped_average_time.each_with_object([]) do |element, arr|
+      event_date, average_time = element
+      arr << {
+        value: average_time,
+        timestamp: event_date.in_time_zone(timezone).to_i,
+        count: grouped_event_count[event_date]
+      }
+    end
+  end
+
+  def aggregate_value
+    object_scope.average(average_value_key)
+  end
+
+  private
+
+  def event_name
+    metric_to_event_name = {
+      avg_first_response_time: :first_response,
+      avg_resolution_time: :conversation_resolved,
+      reply_time: :reply_time
+    }
+    metric_to_event_name[params[:metric].to_sym]
+  end
+
+  def object_scope
+    scope.reporting_events.where(name: event_name, created_at: range, account_id: account.id)
+  end
+
+  def reporting_events
+    @grouped_values = object_scope.group_by_period(
+      group_by,
+      :created_at,
+      default_value: 0,
+      range: range,
+      permit: %w[day week month year hour],
+      time_zone: timezone
+    )
+  end
+
+  def average_value_key
+    @average_value_key ||= params[:business_hours].present? ? :value_in_business_hours : :value
+  end
+end

app/builders/v2/reports/timeseries/base_timeseries_builder.rb

@@ -1,13 +1,12 @@
 class V2::Reports::Timeseries::BaseTimeseriesBuilder
   include TimezoneHelper
   include DateRangeHelper
-
   DEFAULT_GROUP_BY = 'day'.freeze
 
   pattr_initialize :account, :params
 
   def scope
-    case dimension_type.to_sym
+    case params[:type].to_sym
     when :account
       account
     when :inbox
@@ -21,21 +20,6 @@ class V2::Reports::Timeseries::BaseTimeseriesBuilder
     end
   end
 
-  def data_source
-    @data_source ||= Reports::DataSource.for(
-      account: account,
-      metric: params[:metric],
-      dimension_type: dimension_type,
-      dimension_id: params[:id],
-      scope: scope,
-      range: range,
-      group_by: group_by,
-      timezone: timezone,
-      timezone_offset: params[:timezone_offset],
-      business_hours: params[:business_hours]
-    )
-  end
-
   def inbox
     @inbox ||= account.inboxes.find(params[:id])
   end
@@ -57,12 +41,6 @@ class V2::Reports::Timeseries::BaseTimeseriesBuilder
   end
 
   def timezone
-    @timezone ||= timezone_name_from_params(params[:timezone], params[:timezone_offset])
-  end
-
-  private
-
-  def dimension_type
-    (params[:type].presence || 'account').to_s
+    @timezone ||= timezone_name_from_offset(params[:timezone_offset])
   end
 end

app/builders/v2/reports/timeseries/count_report_builder.rb

@@ -0,0 +1,78 @@
+class V2::Reports::Timeseries::CountReportBuilder < V2::Reports::Timeseries::BaseTimeseriesBuilder
+  def timeseries
+    grouped_count.each_with_object([]) do |element, arr|
+      event_date, event_count = element
+
+      # The `event_date` is in Date format (without time), such as "Wed, 15 May 2024".
+      # We need a timestamp for the start of the day. However, we can't use `event_date.to_time.to_i`
+      # because it converts the date to 12:00 AM server timezone.
+      # The desired output should be 12:00 AM in the specified timezone.
+      arr << { value: event_count, timestamp: event_date.in_time_zone(timezone).to_i }
+    end
+  end
+
+  def aggregate_value
+    object_scope.count
+  end
+
+  private
+
+  def metric
+    @metric ||= params[:metric]
+  end
+
+  def object_scope
+    send("scope_for_#{metric}")
+  end
+
+  def scope_for_conversations_count
+    scope.conversations.where(account_id: account.id, created_at: range)
+  end
+
+  def scope_for_incoming_messages_count
+    scope.messages.where(account_id: account.id, created_at: range).incoming.unscope(:order)
+  end
+
+  def scope_for_outgoing_messages_count
+    scope.messages.where(account_id: account.id, created_at: range).outgoing.unscope(:order)
+  end
+
+  def scope_for_resolutions_count
+    scope.reporting_events.where(
+      name: :conversation_resolved,
+      account_id: account.id,
+      created_at: range
+    )
+  end
+
+  def scope_for_bot_resolutions_count
+    scope.reporting_events.where(
+      name: :conversation_bot_resolved,
+      account_id: account.id,
+      created_at: range
+    )
+  end
+
+  def scope_for_bot_handoffs_count
+    scope.reporting_events.joins(:conversation).select(:conversation_id).where(
+      name: :conversation_bot_handoff,
+      account_id: account.id,
+      created_at: range
+    ).distinct
+  end
+
+  def grouped_count
+    # IMPORTANT: time_zone parameter affects both data grouping AND output timestamps
+    # It converts timestamps to the target timezone before grouping, which means
+    # the same event can fall into different day buckets depending on timezone
+    # Example: 2024-01-15 00:00 UTC becomes 2024-01-14 16:00 PST (falls on different day)
+    @grouped_values = object_scope.group_by_period(
+      group_by,
+      :created_at,
+      default_value: 0,
+      range: range,
+      permit: %w[day week month year hour],
+      time_zone: timezone
+    ).count
+  end
+end

app/builders/v2/reports/timeseries/report_builder.rb

@@ -1,9 +0,0 @@
-class V2::Reports::Timeseries::ReportBuilder < V2::Reports::Timeseries::BaseTimeseriesBuilder
-  def timeseries
-    data_source.timeseries
-  end
-
-  def aggregate_value
-    data_source.aggregate
-  end
-end

app/controllers/api/v2/accounts/reports_controller.rb

@@ -112,7 +112,6 @@ class Api::V2::Accounts::ReportsController < Api::V1::Accounts::BaseController
     common_params.merge({
                           since: range[:current][:since],
                           until: range[:current][:until],
-                          timezone: params[:timezone],
                           timezone_offset: params[:timezone_offset]
                         })
   end
@@ -121,7 +120,6 @@ class Api::V2::Accounts::ReportsController < Api::V1::Accounts::BaseController
     common_params.merge({
                           since: range[:previous][:since],
                           until: range[:previous][:until],
-                          timezone: params[:timezone],
                           timezone_offset: params[:timezone_offset]
                         })
   end
@@ -131,7 +129,6 @@ class Api::V2::Accounts::ReportsController < Api::V1::Accounts::BaseController
                           metric: params[:metric],
                           since: params[:since],
                           until: params[:until],
-                          timezone: params[:timezone],
                           timezone_offset: params[:timezone_offset]
                         })
   end

app/controllers/api/v2/accounts/summary_reports_controller.rb

@@ -3,15 +3,15 @@ class Api::V2::Accounts::SummaryReportsController < Api::V1::Accounts::BaseContr
   before_action :prepare_builder_params, only: [:agent, :team, :inbox, :label, :channel]
 
   def agent
-    render_report_with(V2::Reports::AgentSummaryBuilder, type: :agent)
+    render_report_with(V2::Reports::AgentSummaryBuilder)
   end
 
   def team
-    render_report_with(V2::Reports::TeamSummaryBuilder, type: :team)
+    render_report_with(V2::Reports::TeamSummaryBuilder)
   end
 
   def inbox
-    render_report_with(V2::Reports::InboxSummaryBuilder, type: :inbox)
+    render_report_with(V2::Reports::InboxSummaryBuilder)
   end
 
   def label
@@ -36,18 +36,15 @@ class Api::V2::Accounts::SummaryReportsController < Api::V1::Accounts::BaseContr
       until: permitted_params[:until],
       business_hours: ActiveModel::Type::Boolean.new.cast(permitted_params[:business_hours])
     }
-    @builder_params[:timezone] = permitted_params[:timezone] if permitted_params[:timezone].present?
-    @builder_params[:timezone_offset] = permitted_params[:timezone_offset] if permitted_params[:timezone_offset].present?
   end
 
-  def render_report_with(builder_class, type: nil)
-    builder_params = type.present? ? @builder_params.merge(type: type) : @builder_params
-    builder = builder_class.new(account: Current.account, params: builder_params)
+  def render_report_with(builder_class)
+    builder = builder_class.new(account: Current.account, params: @builder_params)
     render json: builder.build
   end
 
   def permitted_params
-    params.permit(:since, :until, :business_hours, :timezone, :timezone_offset)
+    params.permit(:since, :until, :business_hours)
   end
 
   def date_range_too_long?

app/helpers/timezone_helper.rb

@@ -1,10 +1,4 @@
 module TimezoneHelper
-  def timezone_name_from_params(timezone, offset)
-    return timezone if timezone.present? && ActiveSupport::TimeZone[timezone].present?
-
-    timezone_name_from_offset(offset)
-  end
-
   # ActiveSupport TimeZone is not aware of the current time, so ActiveSupport::Timezone[offset]
   # would return the timezone without considering day light savings. To get the correct timezone,
   # this method uses zone.now.utc_offset for comparison as referenced in the issues below

app/javascript/dashboard/api/ApiClient.js

@@ -13,7 +13,6 @@ class ApiClient {
     return `${this.baseUrl()}/${this.resource}`;
   }
 
-  // eslint-disable-next-line class-methods-use-this
   get accountIdFromRoute() {
     const isInsideAccountScopedURLs =
       window.location.pathname.includes('/app/accounts');

app/javascript/dashboard/api/CacheEnabledApiClient.js

@@ -8,7 +8,6 @@ class CacheEnabledApiClient extends ApiClient {
     this.dataManager = new DataManager(this.accountIdFromRoute);
   }
 
-  // eslint-disable-next-line class-methods-use-this
   get cacheModelName() {
     throw new Error('cacheModelName is not defined');
   }
@@ -25,12 +24,10 @@ class CacheEnabledApiClient extends ApiClient {
     return axios.get(this.url);
   }
 
-  // eslint-disable-next-line class-methods-use-this
   extractDataFromResponse(response) {
     return response.data.payload;
   }
 
-  // eslint-disable-next-line class-methods-use-this
   marshallData(dataToParse) {
     return { data: { payload: dataToParse } };
   }

app/javascript/dashboard/api/changelog.js

@@ -7,7 +7,6 @@ class ChangelogApi extends ApiClient {
     super('changelog', { apiVersion: 'v1' });
   }
 
-  // eslint-disable-next-line class-methods-use-this
   fetchFromHub() {
     return axios.get(CHANGELOG_API_URL);
   }

app/javascript/dashboard/api/channel/voice/voiceAPIClient.js

@@ -7,7 +7,6 @@ class VoiceAPI extends ApiClient {
     super('voice', { accountScoped: true });
   }
 
-  // eslint-disable-next-line class-methods-use-this
   initiateCall(contactId, inboxId) {
     return ContactsAPI.initiateCall(contactId, inboxId).then(r => r.data);
   }

app/javascript/dashboard/api/contacts.js

@@ -72,7 +72,6 @@ class ContactAPI extends ApiClient {
     return axios.get(requestURL);
   }
 
-  // eslint-disable-next-line default-param-last
   filter(page = 1, sortAttr = 'name', queryPayload) {
     let requestURL = `${this.url}/filter?${buildContactParams(page, sortAttr)}`;
     return axios.post(requestURL, queryPayload);

app/javascript/dashboard/api/inboxes.js

@@ -6,7 +6,6 @@ class Inboxes extends CacheEnabledApiClient {
     super('inboxes', { accountScoped: true });
   }
 
-  // eslint-disable-next-line class-methods-use-this
   get cacheModelName() {
     return 'inbox';
   }

app/javascript/dashboard/api/labels.js

@@ -5,7 +5,6 @@ class LabelsAPI extends CacheEnabledApiClient {
     super('labels', { accountScoped: true });
   }
 
-  // eslint-disable-next-line class-methods-use-this
   get cacheModelName() {
     return 'label';
   }

app/javascript/dashboard/api/reports.js

@@ -2,7 +2,6 @@
 import ApiClient from './ApiClient';
 
 const getTimeOffset = () => -new Date().getTimezoneOffset() / 60;
-const getTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
 
 class ReportsAPI extends ApiClient {
   constructor() {
@@ -27,13 +26,11 @@ class ReportsAPI extends ApiClient {
         id,
         group_by: groupBy,
         business_hours: businessHours,
-        timezone: getTimeZone(),
         timezone_offset: getTimeOffset(),
       },
     });
   }
 
-  // eslint-disable-next-line default-param-last
   getSummary(since, until, type = 'account', id, groupBy, businessHours) {
     return axios.get(`${this.url}/summary`, {
       params: {
@@ -43,7 +40,6 @@ class ReportsAPI extends ApiClient {
         id,
         group_by: groupBy,
         business_hours: businessHours,
-        timezone: getTimeZone(),
         timezone_offset: getTimeOffset(),
       },
     });
@@ -108,8 +104,6 @@ class ReportsAPI extends ApiClient {
         type: 'account',
         group_by: groupBy,
         business_hours: businessHours,
-        timezone: getTimeZone(),
-        timezone_offset: getTimeOffset(),
       },
     });
   }

app/javascript/dashboard/api/specs/reports.spec.js

@@ -2,8 +2,6 @@ import reportsAPI from '../reports';
 import ApiClient from '../ApiClient';
 
 describe('#Reports API', () => {
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-
   it('creates correct instance', () => {
     expect(reportsAPI).toBeInstanceOf(ApiClient);
     expect(reportsAPI.apiVersion).toBe('/api/v2');
@@ -48,7 +46,6 @@ describe('#Reports API', () => {
           since: 1621103400,
           until: 1621621800,
           type: 'account',
-          timezone,
           timezone_offset: -0,
         },
       });
@@ -62,7 +59,6 @@ describe('#Reports API', () => {
           group_by: undefined,
           id: undefined,
           since: 1621103400,
-          timezone,
           timezone_offset: -0,
           type: 'account',
           until: 1621621800,
@@ -144,8 +140,6 @@ describe('#Reports API', () => {
             type: 'account',
             group_by: 'date',
             business_hours: true,
-            timezone,
-            timezone_offset: -0,
           },
         }
       );

app/javascript/dashboard/api/specs/summaryReports.spec.js

@@ -1,47 +0,0 @@
-import summaryReportsAPI from '../summaryReports';
-import ApiClient from '../ApiClient';
-
-describe('#Summary Reports API', () => {
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-
-  it('creates correct instance', () => {
-    expect(summaryReportsAPI).toBeInstanceOf(ApiClient);
-    expect(summaryReportsAPI.apiVersion).toBe('/api/v2');
-  });
-
-  describe('API calls', () => {
-    const originalAxios = window.axios;
-    const axiosMock = {
-      get: vi.fn(() => Promise.resolve()),
-    };
-
-    beforeEach(() => {
-      window.axios = axiosMock;
-    });
-
-    afterEach(() => {
-      window.axios = originalAxios;
-    });
-
-    it('includes timezone data in summary report requests', () => {
-      summaryReportsAPI.getAgentReports({
-        since: 1621103400,
-        until: 1621621800,
-        businessHours: true,
-      });
-
-      expect(axiosMock.get).toHaveBeenCalledWith(
-        '/api/v2/summary_reports/agent',
-        {
-          params: {
-            since: 1621103400,
-            until: 1621621800,
-            business_hours: true,
-            timezone,
-            timezone_offset: -0,
-          },
-        }
-      );
-    });
-  });
-});

app/javascript/dashboard/api/summaryReports.js

@@ -1,9 +1,6 @@
 /* global axios */
 import ApiClient from './ApiClient';
 
-const getTimeOffset = () => -new Date().getTimezoneOffset() / 60;
-const getTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
-
 class SummaryReportsAPI extends ApiClient {
   constructor() {
     super('summary_reports', { accountScoped: true, apiVersion: 'v2' });
@@ -15,8 +12,6 @@ class SummaryReportsAPI extends ApiClient {
         since,
         until,
         business_hours: businessHours,
-        timezone: getTimeZone(),
-        timezone_offset: getTimeOffset(),
       },
     });
   }
@@ -27,8 +22,6 @@ class SummaryReportsAPI extends ApiClient {
         since,
         until,
         business_hours: businessHours,
-        timezone: getTimeZone(),
-        timezone_offset: getTimeOffset(),
       },
     });
   }
@@ -39,8 +32,6 @@ class SummaryReportsAPI extends ApiClient {
         since,
         until,
         business_hours: businessHours,
-        timezone: getTimeZone(),
-        timezone_offset: getTimeOffset(),
       },
     });
   }
@@ -51,8 +42,6 @@ class SummaryReportsAPI extends ApiClient {
         since,
         until,
         business_hours: businessHours,
-        timezone: getTimeZone(),
-        timezone_offset: getTimeOffset(),
       },
     });
   }

app/javascript/dashboard/api/teams.js

@@ -7,17 +7,14 @@ export class TeamsAPI extends CacheEnabledApiClient {
     super('teams', { accountScoped: true });
   }
 
-  // eslint-disable-next-line class-methods-use-this
   get cacheModelName() {
     return 'team';
   }
 
-  // eslint-disable-next-line class-methods-use-this
   extractDataFromResponse(response) {
     return response.data;
   }
 
-  // eslint-disable-next-line class-methods-use-this
   marshallData(dataToParse) {
     return { data: dataToParse };
   }

app/javascript/dashboard/components-next/Campaigns/Pages/CampaignPage/LiveChatCampaign/LiveChatCampaignForm.vue

@@ -56,7 +56,6 @@ const state = reactive({ ...initialState });
 const urlValidators = {
   shouldBeAValidURLPattern: value => {
     try {
-      // eslint-disable-next-line
       new URLPattern(value);
       return true;
     } catch {

app/javascript/dashboard/components-next/captain/assistant/AssistantPlayground.vue

@@ -18,18 +18,10 @@ const newMessage = ref('');
 const isLoading = ref(false);
 
 const formatMessagesForApi = () => {
-  return messages.value.map(message => {
-    const payload = {
-      role: message.sender,
-      content: message.content,
-    };
-
-    if (message.sender === 'assistant' && message.agentName) {
-      payload.agent_name = message.agentName;
-    }
-
-    return payload;
-  });
+  return messages.value.map(message => ({
+    role: message.sender,
+    content: message.content,
+  }));
 };
 
 const resetConversation = () => {
@@ -70,7 +62,6 @@ const sendMessage = async () => {
     messages.value.push({
       content: data.response,
       sender: 'assistant',
-      agentName: data.agent_name,
       timestamp: new Date().toISOString(),
     });
   } catch (error) {
@@ -80,12 +71,6 @@ const sendMessage = async () => {
     isLoading.value = false;
   }
 };
-
-const handleEnterKey = event => {
-  if (event.isComposing) return;
-  event.preventDefault();
-  sendMessage();
-};
 </script>
 
 <template>
@@ -119,7 +104,7 @@ const handleEnterKey = event => {
         v-model="newMessage"
         class="flex-1 bg-transparent border-none focus:outline-none text-sm mb-0 text-n-slate-12 placeholder:text-n-slate-10"
         :placeholder="t('CAPTAIN.PLAYGROUND.MESSAGE_PLACEHOLDER')"
-        @keydown.enter.exact="handleEnterKey"
+        @keyup.enter="sendMessage"
       />
       <NextButton
         ghost

app/javascript/dashboard/components-next/copilot/CopilotInput.vue

@@ -29,12 +29,6 @@ const handleInput = () => {
   nextTick(adjustHeight);
 };
 
-const handleEnterKey = event => {
-  if (event.isComposing) return;
-  event.preventDefault();
-  sendMessage();
-};
-
 onMounted(() => {
   nextTick(adjustHeight);
 });
@@ -49,7 +43,7 @@ onMounted(() => {
       class="w-full reset-base bg-n-alpha-3 ltr:pl-4 ltr:pr-12 rtl:pl-12 rtl:pr-4 py-3 text-sm border border-n-weak rounded-lg focus:outline-0 focus:outline-none focus:ring-2 focus:ring-n-blue-11 focus:border-n-blue-11 resize-none overflow-hidden max-h-[200px] mb-0 text-n-slate-12"
       rows="1"
       @input="handleInput"
-      @keydown.enter.exact="handleEnterKey"
+      @keydown.enter.exact.prevent="sendMessage"
     />
     <button
       class="absolute ltr:right-1 rtl:left-1 top-1/2 -translate-y-1/2 h-9 w-10 flex items-center justify-center text-n-slate-11 hover:text-n-blue-11"

app/javascript/dashboard/components-next/message/Message.vue

@@ -99,7 +99,6 @@ import { useBranding } from 'shared/composables/useBranding';
  * @property {number} inboxId - The ID of the inbox to which the message belongs
  */
 
-// eslint-disable-next-line vue/define-macros-order
 const props = defineProps({
   id: { type: Number, required: true },
   messageType: {
@@ -124,12 +123,12 @@ const props = defineProps({
   createdAt: { type: Number, required: true }, // eslint-disable-line vue/no-unused-properties
   currentUserId: { type: Number, required: true }, // eslint-disable-line vue/no-unused-properties
   groupWithNext: { type: Boolean, default: false },
-  inboxId: { type: Number, default: null }, // eslint-disable-line vue/no-unused-properties
+  inboxId: { type: Number, default: null },
   inboxSupportsReplyTo: { type: Object, default: () => ({}) },
   inReplyTo: { type: Object, default: null }, // eslint-disable-line vue/no-unused-properties
   isEmailInbox: { type: Boolean, default: false },
   private: { type: Boolean, default: false },
-  additionalAttributes: { type: Object, default: () => ({}) }, // eslint-disable-line vue/no-unused-properties
+  additionalAttributes: { type: Object, default: () => ({}) },
   sender: { type: Object, default: null },
   senderId: { type: Number, default: null },
   senderType: { type: String, default: null },

app/javascript/dashboard/components/widgets/WootWriter/CopilotEditor.vue

@@ -107,8 +107,7 @@ function onKeydown(view, event) {
   emit('keydown');
 
   // Handle Enter key to send message (Shift+Enter for new line)
-  // Skip if IME composition is active (CJK character confirmation)
-  if (event.key === 'Enter' && !event.shiftKey && !event.isComposing) {
+  if (event.key === 'Enter' && !event.shiftKey) {
     event.preventDefault();
     handleSubmit();
     return true; // Prevent ProseMirror's default Enter handling

app/javascript/dashboard/components/widgets/WootWriter/FullEditor.vue

@@ -18,9 +18,7 @@ const MAXIMUM_FILE_UPLOAD_SIZE = 4; // in MB
 const createState = (
   content,
   placeholder,
-  // eslint-disable-next-line default-param-last
   plugins = [],
-  // eslint-disable-next-line default-param-last
   methods = {},
   enabledMenuOptions
 ) => {

app/javascript/dashboard/components/widgets/WootWriter/ReplyBottomPanel.vue

@@ -35,8 +35,7 @@ export default {
       default: '00:00',
     },
     // inbox prop is used in /mixins/inboxMixin,
-    // remove this props when refactoring to composable if not needed
-    // eslint-disable-next-line vue/no-unused-properties
+    // remove this props when refactoring to composable if not neededs
     inbox: {
       type: Object,
       default: () => ({}),

app/javascript/dashboard/components/widgets/WootWriter/utils/mp3ConversionUtils.js

@@ -1,7 +1,6 @@
 import lamejs from '@breezystack/lamejs';
 
 const writeString = (view, offset, string) => {
-  // eslint-disable-next-line no-plusplus
   for (let i = 0; i < string.length; i++) {
     view.setUint8(offset + i, string.charCodeAt(i));
   }
@@ -29,9 +28,8 @@ const bufferToWav = async (buffer, numChannels, sampleRate) => {
 
   // WAV Data
   const offset = 44;
-  // eslint-disable-next-line no-plusplus
+
   for (let i = 0; i < buffer.length; i++) {
-    // eslint-disable-next-line no-plusplus
     for (let channel = 0; channel < numChannels; channel++) {
       const sample = Math.max(
         -1,

app/javascript/dashboard/composables/spec/useAutomation.spec.js

@@ -38,7 +38,7 @@ describe('useAutomation', () => {
     });
     useMapGetter.mockImplementation(getter => {
       const getterMap = {
-        'agents/getVerifiedAgents': agents,
+        'agents/getAgents': agents,
         'campaigns/getAllCampaigns': campaigns,
         'contacts/getContacts': contacts,
         'inboxes/getInboxes': inboxes,

app/javascript/dashboard/composables/spec/useMacros.spec.js

@@ -111,7 +111,7 @@ describe('useMacros', () => {
     useStoreGetters.mockReturnValue({
       'labels/getLabels': { value: mockLabels },
       'teams/getTeams': { value: mockTeams },
-      'agents/getVerifiedAgents': { value: mockAgents },
+      'agents/getAgents': { value: mockAgents },
     });
   });
 
@@ -167,7 +167,7 @@ describe('useMacros', () => {
     useStoreGetters.mockReturnValue({
       'labels/getLabels': { value: [] },
       'teams/getTeams': { value: [] },
-      'agents/getVerifiedAgents': { value: [] },
+      'agents/getAgents': { value: [] },
     });
 
     const { getMacroDropdownValues } = useMacros();

app/javascript/dashboard/composables/useAutomationValues.js

@@ -20,7 +20,7 @@ import {
 export default function useAutomationValues() {
   const getters = useStoreGetters();
   const { t } = useI18n();
-  const agents = useMapGetter('agents/getVerifiedAgents');
+  const agents = useMapGetter('agents/getAgents');
   const campaigns = useMapGetter('campaigns/getAllCampaigns');
   const contacts = useMapGetter('contacts/getContacts');
   const inboxes = useMapGetter('inboxes/getInboxes');

app/javascript/dashboard/composables/useMacros.js

@@ -13,7 +13,7 @@ export const useMacros = () => {
 
   const labels = computed(() => getters['labels/getLabels'].value);
   const teams = computed(() => getters['teams/getTeams'].value);
-  const agents = computed(() => getters['agents/getVerifiedAgents'].value);
+  const agents = computed(() => getters['agents/getAgents'].value);
 
   /**
    * Get dropdown values based on the specified type

app/javascript/dashboard/helper/actionCable.js

@@ -37,12 +37,10 @@ class ActionCableConnector extends BaseActionCableConnector {
     };
   }
 
-  // eslint-disable-next-line class-methods-use-this
   onReconnect = () => {
     emitter.emit(BUS_EVENTS.WEBSOCKET_RECONNECT);
   };
 
-  // eslint-disable-next-line class-methods-use-this
   onDisconnected = () => {
     emitter.emit(BUS_EVENTS.WEBSOCKET_DISCONNECT);
   };
@@ -90,7 +88,6 @@ class ActionCableConnector extends BaseActionCableConnector {
     this.app.$store.dispatch('updateConversation', data);
   };
 
-  // eslint-disable-next-line class-methods-use-this
   onLogout = () => AuthAPI.logout();
 
   onMessageCreated = data => {
@@ -106,7 +103,6 @@ class ActionCableConnector extends BaseActionCableConnector {
     });
   };
 
-  // eslint-disable-next-line class-methods-use-this
   onReload = () => window.location.reload();
 
   onStatusChange = data => {
@@ -161,7 +157,6 @@ class ActionCableConnector extends BaseActionCableConnector {
     }, 30000);
   };
 
-  // eslint-disable-next-line class-methods-use-this
   fetchConversationStats = () => {
     emitter.emit('fetch_conversation_stats');
   };

app/javascript/dashboard/helper/automationHelper.js

@@ -212,9 +212,8 @@ export const isCustomAttribute = (attrs, key) => {
 };
 
 export const generateCustomAttributes = (
-  // eslint-disable-next-line default-param-last
   conversationAttributes = [],
-  // eslint-disable-next-line default-param-last
+
   contactAttributes = [],
   conversationlabel,
   contactlabel

app/javascript/dashboard/helper/emailQuoteExtractor.js

@@ -61,7 +61,6 @@ export class EmailQuoteExtractor {
     tempDiv.innerHTML = DOMPurify.sanitize(htmlContent);
 
     // Check for class-based quotes
-    // eslint-disable-next-line no-restricted-syntax
     for (const selector of QUOTE_INDICATORS) {
       if (tempDiv.querySelector(selector)) {
         return true;

app/javascript/dashboard/helper/pushHelper.js

@@ -18,7 +18,6 @@ export const verifyServiceWorkerExistence = (callback = () => {}) => {
     .register('/sw.js')
     .then(registration => callback(registration))
     .catch(registrationError => {
-      // eslint-disable-next-line
       console.log('SW registration failed: ', registrationError);
     });
 };
@@ -69,7 +68,6 @@ export const registerSubscription = (onSuccess = () => {}) => {
       onSuccess();
     })
     .catch(error => {
-      // eslint-disable-next-line no-console
       console.error('Push subscription registration failed:', error);
       useAlert('This browser does not support desktop notification');
     });
@@ -77,7 +75,6 @@ export const registerSubscription = (onSuccess = () => {}) => {
 
 export const requestPushPermissions = ({ onSuccess }) => {
   if (!('Notification' in window)) {
-    // eslint-disable-next-line no-console
     console.warn('Notification is not supported');
     useAlert('This browser does not support desktop notification');
   } else if (Notification.permission === 'granted') {

app/javascript/dashboard/helper/specs/templateHelper.spec.js

@@ -288,10 +288,9 @@ describe('templateHelper', () => {
     });
 
     it('should handle special characters in template variables', () => {
-      /* eslint-disable no-template-curly-in-string */
       const templateText =
         'Welcome {{user_name}}, your order #{{order_id}} costs ${{amount}}';
-      /* eslint-enable no-template-curly-in-string */
+
       const processedParams = {
         body: {
           user_name: 'John & Jane',

app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Facebook.vue

@@ -1,5 +1,4 @@
 <script>
-/* eslint-env browser */
 /* global FB */
 import { useVuelidate } from '@vuelidate/core';
 import { useAlert } from 'dashboard/composables';

app/javascript/shared/helpers/AudioNotificationHelper.js

@@ -10,7 +10,6 @@ export const getAudioContext = () => {
   return audioCtx;
 };
 
-// eslint-disable-next-line default-param-last
 export const getAlertAudio = async (baseUrl = '', requestContext) => {
   const audioCtx = getAudioContext();
   const playSound = audioBuffer => {
@@ -34,7 +33,6 @@ export const getAlertAudio = async (baseUrl = '', requestContext) => {
       .then(response => response.arrayBuffer())
       .then(buffer => {
         audioCtx.decodeAudioData(buffer).then(playSound);
-        // eslint-disable-next-line no-promise-executor-return
         return new Promise(res => res());
       })
       .catch(() => {

app/javascript/shared/helpers/BaseActionCableConnector.js

@@ -74,10 +74,8 @@ class BaseActionCableConnector {
     }, RECONNECT_INTERVAL);
   };
 
-  // eslint-disable-next-line class-methods-use-this
   onReconnect = () => {};
 
-  // eslint-disable-next-line class-methods-use-this
   onDisconnected = () => {};
 
   disconnect() {

app/javascript/shared/helpers/CustomErrors.js

@@ -1,4 +1,3 @@
-/* eslint-disable max-classes-per-file */
 export class DuplicateContactException extends Error {
   constructor(data) {
     super('DUPLICATE_CONTACT');

app/javascript/widget/components/UnreadMessage.vue

@@ -48,7 +48,6 @@ export default {
       }`;
     },
     avatarUrl() {
-      // eslint-disable-next-line
       const displayImage = this.useInboxAvatarForBot
         ? this.inboxAvatarUrl
         : '/assets/images/chatwoot_bot.png';

app/javascript/widget/helpers/actionCable.js

@@ -96,7 +96,6 @@ class ActionCableConnector extends BaseActionCableConnector {
     this.app.$store.dispatch('agent/updatePresence', data.users);
   };
 
-  // eslint-disable-next-line class-methods-use-this
   onContactMerge = data => {
     const { pubsub_token: pubsubToken } = data;
     ActionCableConnector.refreshConnector(pubsubToken);

app/javascript/widget/helpers/uuid.js

@@ -1,8 +1,6 @@
 const getUuid = () =>
   'xxxxxxxx4xxx'.replace(/[xy]/g, c => {
-    // eslint-disable-next-line
     const r = (Math.random() * 16) | 0;
-    // eslint-disable-next-line
     const v = c === 'x' ? r : (r & 0x3) | 0x8;
     return v.toString(16);
   });

app/listeners/reporting_event_listener.rb

@@ -3,25 +3,23 @@ class ReportingEventListener < BaseListener
 
   def conversation_resolved(event)
     conversation = extract_conversation_and_account(event)[0]
-    event_end_time = event.timestamp
-    time_to_resolve = event_end_time.to_i - conversation.created_at.to_i
+    time_to_resolve = conversation.updated_at.to_i - conversation.created_at.to_i
 
     reporting_event = ReportingEvent.new(
       name: 'conversation_resolved',
       value: time_to_resolve,
       value_in_business_hours: business_hours(conversation.inbox, conversation.created_at,
-                                              event_end_time),
+                                              conversation.updated_at),
       account_id: conversation.account_id,
       inbox_id: conversation.inbox_id,
       user_id: conversation.assignee_id,
       conversation_id: conversation.id,
       event_start_time: conversation.created_at,
-      event_end_time: event_end_time
+      event_end_time: conversation.updated_at
     )
 
     create_bot_resolved_event(conversation, reporting_event)
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
   end
 
   def first_reply_created(event)
@@ -43,7 +41,6 @@ class ReportingEventListener < BaseListener
     )
 
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
   end
 
   def reply_created(event)
@@ -68,57 +65,45 @@ class ReportingEventListener < BaseListener
       event_end_time: message.created_at
     )
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
   end
 
   def conversation_bot_handoff(event)
     conversation = extract_conversation_and_account(event)[0]
-    event_end_time = event.timestamp
 
     # check if a conversation_bot_handoff event exists for this conversation
     bot_handoff_event = ReportingEvent.find_by(conversation_id: conversation.id, name: 'conversation_bot_handoff')
     return if bot_handoff_event.present?
 
-    time_to_handoff = event_end_time.to_i - conversation.created_at.to_i
+    time_to_handoff = conversation.updated_at.to_i - conversation.created_at.to_i
 
     reporting_event = ReportingEvent.new(
       name: 'conversation_bot_handoff',
       value: time_to_handoff,
-      value_in_business_hours: business_hours(conversation.inbox, conversation.created_at, event_end_time),
+      value_in_business_hours: business_hours(conversation.inbox, conversation.created_at, conversation.updated_at),
       account_id: conversation.account_id,
       inbox_id: conversation.inbox_id,
       user_id: conversation.assignee_id,
       conversation_id: conversation.id,
       event_start_time: conversation.created_at,
-      event_end_time: event_end_time
+      event_end_time: conversation.updated_at
     )
     reporting_event.save!
-    ReportingEvents::RollupService.perform(reporting_event)
-  end
-
-  def conversation_captain_inference_resolved(event)
-    create_captain_inference_event(event, 'conversation_captain_inference_resolved')
-  end
-
-  def conversation_captain_inference_handoff(event)
-    create_captain_inference_event(event, 'conversation_captain_inference_handoff')
   end
 
   def conversation_opened(event)
     conversation = extract_conversation_and_account(event)[0]
-    event_end_time = event.timestamp
 
     # Find the most recent resolved event for this conversation
     last_resolved_event = ReportingEvent.where(
       conversation_id: conversation.id,
       name: 'conversation_resolved'
-    ).where('event_end_time <= ?', event_end_time).order(event_end_time: :desc).first
+    ).order(event_end_time: :desc).first
 
     # For first-time openings, value is 0
     # For reopenings, calculate time since resolution
     if last_resolved_event
-      time_since_resolved = event_end_time.to_i - last_resolved_event.event_end_time.to_i
-      business_hours_value = business_hours(conversation.inbox, last_resolved_event.event_end_time, event_end_time)
+      time_since_resolved = conversation.updated_at.to_i - last_resolved_event.event_end_time.to_i
+      business_hours_value = business_hours(conversation.inbox, last_resolved_event.event_end_time, conversation.updated_at)
       start_time = last_resolved_event.event_end_time
     else
       time_since_resolved = 0
@@ -126,12 +111,12 @@ class ReportingEventListener < BaseListener
       start_time = conversation.created_at
     end
 
-    create_conversation_opened_event(conversation, time_since_resolved, business_hours_value, start_time, event_end_time)
+    create_conversation_opened_event(conversation, time_since_resolved, business_hours_value, start_time)
   end
 
   private
 
-  def create_conversation_opened_event(conversation, time_since_resolved, business_hours_value, start_time, event_end_time)
+  def create_conversation_opened_event(conversation, time_since_resolved, business_hours_value, start_time)
     reporting_event = ReportingEvent.new(
       name: 'conversation_opened',
       value: time_since_resolved,
@@ -141,27 +126,11 @@ class ReportingEventListener < BaseListener
       user_id: conversation.assignee_id,
       conversation_id: conversation.id,
       event_start_time: start_time,
-      event_end_time: event_end_time
+      event_end_time: conversation.updated_at
     )
     reporting_event.save!
   end
 
-  def create_captain_inference_event(event, event_name)
-    conversation = extract_conversation_and_account(event)[0]
-    time_to_event = event.timestamp.to_i - conversation.created_at.to_i
-
-    ReportingEvent.create!(
-      name: event_name,
-      value: time_to_event,
-      account_id: conversation.account_id,
-      inbox_id: conversation.inbox_id,
-      user_id: conversation.assignee_id,
-      conversation_id: conversation.id,
-      event_start_time: conversation.created_at,
-      event_end_time: event.timestamp
-    )
-  end
-
   def create_bot_resolved_event(conversation, reporting_event)
     return unless conversation.inbox.active_bot?
     # We don't want to create a bot_resolved event if there is user interaction on the conversation
@@ -170,6 +139,5 @@ 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)
   end
 end

app/models/account.rb

@@ -85,13 +85,11 @@ class Account < ApplicationRecord
   validates_with JsonSchemaValidator,
                  schema: SETTINGS_PARAMS_SCHEMA,
                  attribute_resolver: ->(record) { record.settings }
-  validate :validate_reporting_timezone
 
   store_accessor :settings, :auto_resolve_after, :auto_resolve_message, :auto_resolve_ignore_waiting
 
   store_accessor :settings, :audio_transcriptions, :auto_resolve_label
   store_accessor :settings, :captain_models, :captain_features
-  store_accessor :settings, :reporting_timezone
   store_accessor :settings, :keep_pending_on_bot_failure
   store_accessor :settings, :captain_disable_auto_resolve
 
@@ -216,12 +214,6 @@ class Account < ApplicationRecord
     # method overridden in enterprise module
   end
 
-  def validate_reporting_timezone
-    return if reporting_timezone.blank? || ActiveSupport::TimeZone[reporting_timezone].present?
-
-    errors.add(:reporting_timezone, I18n.t('errors.account.reporting_timezone.invalid'))
-  end
-
   def remove_account_sequences
     ActiveRecord::Base.connection.exec_query("drop sequence IF EXISTS camp_dpid_seq_#{id}")
     ActiveRecord::Base.connection.exec_query("drop sequence IF EXISTS conv_dpid_seq_#{id}")

app/models/message.rb

@@ -81,8 +81,6 @@ class Message < ApplicationRecord
 
   # when you have a temperory id in your frontend and want it echoed back via action cable
   attr_accessor :echo_id
-  # Transient flag used to skip waiting_since clearing for specific bot/system messages.
-  attr_accessor :preserve_waiting_since
 
   enum message_type: { incoming: 0, outgoing: 1, activity: 2, template: 3 }
   enum content_type: {
@@ -127,7 +125,7 @@ class Message < ApplicationRecord
 
   belongs_to :account
   belongs_to :inbox
-  belongs_to :conversation
+  belongs_to :conversation, touch: true
   belongs_to :sender, polymorphic: true, optional: true
 
   has_many :attachments, dependent: :destroy, autosave: true, before_add: :validate_attachments_limit
@@ -325,24 +323,20 @@ class Message < ApplicationRecord
   end
 
   def update_waiting_since
-    clear_waiting_since_on_outgoing_response if conversation.waiting_since.present? && !private
-    set_waiting_since_on_incoming_message
-  end
+    waiting_present = conversation.waiting_since.present?
 
-  def clear_waiting_since_on_outgoing_response
-    if human_response?
-      Rails.configuration.dispatcher.dispatch(
-        REPLY_CREATED, Time.zone.now, waiting_since: conversation.waiting_since, message: self
-      )
-      conversation.update(waiting_since: nil)
-      return
+    if waiting_present && !private
+      if human_response?
+        Rails.configuration.dispatcher.dispatch(
+          REPLY_CREATED, Time.zone.now, waiting_since: conversation.waiting_since, message: self
+        )
+        conversation.update(waiting_since: nil)
+      elsif bot_response?
+        # Bot responses also clear waiting_since (simpler than checking on next customer message)
+        conversation.update(waiting_since: nil)
+      end
     end
 
-    # Bot responses also clear waiting_since (simpler than checking on next customer message)
-    conversation.update(waiting_since: nil) if bot_response? && !preserve_waiting_since
-  end
-
-  def set_waiting_since_on_incoming_message
     # Set waiting_since when customer sends a message (if currently blank)
     conversation.update(waiting_since: created_at) if incoming? && conversation.waiting_since.blank?
   end
@@ -435,7 +429,7 @@ class Message < ApplicationRecord
 
   def set_conversation_activity
     # rubocop:disable Rails/SkipsModelValidations
-    conversation.update_columns(last_activity_at: created_at, updated_at: Time.current)
+    conversation.update_columns(last_activity_at: created_at)
     # rubocop:enable Rails/SkipsModelValidations
   end
 

app/models/reporting_events_rollup.rb

@@ -1,48 +0,0 @@
-# == Schema Information
-#
-# Table name: reporting_events_rollups
-#
-#  id                        :bigint           not null, primary key
-#  count                     :bigint           default(0), not null
-#  date                      :date             not null
-#  dimension_id              :bigint           not null
-#  dimension_type            :string           not null
-#  metric                    :string           not null
-#  sum_value                 :float            default(0.0), not null
-#  sum_value_business_hours  :float            default(0.0), not null
-#  created_at                :datetime         not null
-#  updated_at                :datetime         not null
-#  account_id                :integer          not null
-#
-# Indexes
-#
-#  index_rollup_summary     (account_id,dimension_type,date)
-#  index_rollup_timeseries  (account_id,metric,date)
-#  index_rollup_unique_key  (account_id,date,dimension_type,dimension_id,metric) UNIQUE
-#
-
-class ReportingEventsRollup < ApplicationRecord
-  belongs_to :account
-
-  # Store string values directly in the database for better readability and debugging
-  enum :dimension_type, %w[account agent inbox team].index_by(&:itself)
-  enum :metric, %w[
-    resolutions_count
-    first_response
-    resolution_time
-    reply_time
-    bot_resolutions_count
-    bot_handoffs_count
-  ].index_by(&:itself)
-
-  validates :account_id, presence: true
-  validates :date, presence: true
-  validates :dimension_type, presence: true
-  validates :dimension_id, presence: true
-  validates :metric, presence: true
-  validates :count, numericality: { greater_than_or_equal_to: 0 }
-
-  scope :for_date_range, ->(start_date, end_date) { where(date: start_date..end_date) }
-  scope :for_dimension, ->(type, id) { where(dimension_type: type, dimension_id: id) }
-  scope :for_metric, ->(metric) { where(metric: metric) }
-end

app/services/action_service.rb

@@ -47,9 +47,7 @@ class ActionService
 
     @agent = @account.users.find_by(id: agent_ids)
 
-    return unless @agent.present? && @agent.confirmed?
-
-    @conversation.update!(assignee_id: @agent.id)
+    @conversation.update!(assignee_id: @agent.id) if @agent.present?
   end
 
   def remove_label(labels)

app/services/reporting_events/backfill_service.rb

@@ -1,125 +0,0 @@
-# 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
-
-  def self.backfill_date(account, date)
-    new(account, date).perform
-  end
-
-  def initialize(account, date)
-    @account = account
-    @date = date
-  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?
-  end
-
-  private
-
-  def delete_existing_rollups
-    ReportingEventsRollup.where(account_id: @account.id, date: @date).delete_all
-  end
-
-  def date_boundaries_in_utc
-    tz = ActiveSupport::TimeZone[@account.reporting_timezone]
-    start_in_tz = tz.parse(@date.to_s)
-    end_in_tz = start_in_tz + 1.day
-    [start_in_tz.utc, end_in_tz.utc]
-  end
-
-  def build_rollup_rows(start_utc, end_utc)
-    aggregates = build_aggregates(start_utc, end_utc)
-
-    aggregates.map do |(dimension_type, dimension_id, metric), data|
-      {
-        account_id: @account.id,
-        date: @date,
-        dimension_type: dimension_type,
-        dimension_id: dimension_id,
-        metric: metric,
-        count: data[:count],
-        sum_value: data[:sum_value],
-        sum_value_business_hours: data[:sum_value_business_hours],
-        created_at: Time.current,
-        updated_at: Time.current
-      }
-    end
-  end
-
-  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 } }
-
-    grouped_events(start_utc, end_utc).each { |grouped_event| accumulate_grouped_aggregates(aggregates, grouped_event) }
-
-    aggregates
-  end
-
-  def grouped_events(start_utc, end_utc)
-    @account.reporting_events
-            .where(name: ReportingEvents::MetricRegistry::EVENT_METRICS.keys, created_at: start_utc...end_utc)
-            .group(:name, :user_id, :inbox_id)
-            .pluck(*AGGREGATE_SELECTS)
-            .map { |grouped_row| grouped_event_attributes(grouped_row) }
-  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::MetricRegistry.event_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)
-    end
-  end
-
-  def grouped_event_attributes(grouped_row)
-    event_name, user_id, inbox_id, count, sum_value, sum_value_business_hours = grouped_row
-
-    {
-      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
-
-  def accumulate_metric_aggregates(aggregates, dimensions, metric, metric_data)
-    dimensions.each do |dimension_type, dimension_id|
-      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
-    end
-  end
-
-  def bulk_insert_rollups(rollup_rows)
-    # rubocop:disable Rails/SkipsModelValidations
-    ReportingEventsRollup.insert_all(rollup_rows)
-    # rubocop:enable Rails/SkipsModelValidations
-  end
-end

app/services/reporting_events/metric_registry.rb

@@ -1,127 +0,0 @@
-# Raw reporting events and rollup rows do not share a single metric namespace; this registry keeps write and read paths aligned.
-module ReportingEvents::MetricRegistry
-  SUMMARY_METRICS = {
-    resolutions_count: :resolved_conversations_count,
-    avg_resolution_time: :avg_resolution_time,
-    avg_first_response_time: :avg_first_response_time,
-    reply_time: :avg_reply_time
-  }.freeze
-
-  EVENT_METRICS = {
-    'conversation_resolved' => lambda do |values|
-      {
-        resolutions_count: count_metric(values[:count]),
-        resolution_time: duration_metric(values)
-      }
-    end,
-    'first_response' => ->(values) { { first_response: duration_metric(values) } },
-    'reply_time' => ->(values) { { reply_time: duration_metric(values) } },
-    'conversation_bot_resolved' => ->(values) { { bot_resolutions_count: count_metric(values[:count]) } },
-    'conversation_bot_handoff' => ->(values) { { bot_handoffs_count: count_metric(values[:count]) } }
-  }.freeze
-
-  REPORT_METRICS = {
-    conversations_count: { aggregate: :count }.freeze,
-    incoming_messages_count: { aggregate: :count }.freeze,
-    outgoing_messages_count: { aggregate: :count }.freeze,
-    avg_first_response_time: {
-      raw_event_name: :first_response,
-      rollup_metric: :first_response,
-      aggregate: :average
-    }.freeze,
-    avg_resolution_time: {
-      raw_event_name: :conversation_resolved,
-      rollup_metric: :resolution_time,
-      aggregate: :average
-    }.freeze,
-    reply_time: {
-      raw_event_name: :reply_time,
-      rollup_metric: :reply_time,
-      aggregate: :average
-    }.freeze,
-    resolutions_count: {
-      raw_event_name: :conversation_resolved,
-      rollup_metric: :resolutions_count,
-      aggregate: :count
-    }.freeze,
-    bot_resolutions_count: {
-      raw_event_name: :conversation_bot_resolved,
-      rollup_metric: :bot_resolutions_count,
-      aggregate: :count
-    }.freeze,
-    bot_handoffs_count: {
-      raw_event_name: :conversation_bot_handoff,
-      rollup_metric: :bot_handoffs_count,
-      aggregate: :count,
-      raw_count_strategy: :distinct_conversation
-    }.freeze
-  }.freeze
-
-  module_function
-
-  def event_metrics_for(event)
-    return {} if event.blank?
-    return {} unless EVENT_METRICS.key?(event.name.to_s)
-
-    event_metrics_for_aggregate(
-      event.name,
-      count: 1,
-      sum_value: event.try(:value),
-      sum_value_business_hours: event.try(:value_in_business_hours)
-    )
-  end
-
-  def event_metrics_for_aggregate(event_name, count:, sum_value:, sum_value_business_hours:)
-    values = {
-      count: count.to_i,
-      sum_value: sum_value.to_f,
-      sum_value_business_hours: sum_value_business_hours.to_f
-    }
-
-    EVENT_METRICS[event_name.to_s]&.call(values) || {}
-  end
-
-  def report_metric(metric)
-    return if metric.blank?
-
-    REPORT_METRICS[metric.to_sym]
-  end
-
-  def supported_metric?(metric)
-    report_metric(metric).present?
-  end
-
-  def aggregate_for(metric)
-    report_metric(metric)&.dig(:aggregate)
-  end
-
-  def rollup_supported_metric?(metric)
-    rollup_metric_for(metric).present?
-  end
-
-  def rollup_metric_for(metric)
-    report_metric(metric)&.dig(:rollup_metric)
-  end
-
-  def raw_event_name_for(metric)
-    report_metric(metric)&.dig(:raw_event_name)
-  end
-
-  def summary_metrics
-    SUMMARY_METRICS.map do |metric_name, summary_key|
-      report_metric(metric_name).merge(metric_name: metric_name, summary_key: summary_key)
-    end
-  end
-
-  private_class_method def count_metric(count)
-    { count: count, sum_value: 0, sum_value_business_hours: 0 }
-  end
-
-  private_class_method def duration_metric(values)
-    {
-      count: values[:count],
-      sum_value: values[:sum_value],
-      sum_value_business_hours: values[:sum_value_business_hours]
-    }
-  end
-end

app/services/reporting_events/rollup_service.rb

@@ -1,81 +0,0 @@
-class ReportingEvents::RollupService
-  def self.perform(reporting_event)
-    new(reporting_event).perform
-  end
-
-  def initialize(reporting_event)
-    @reporting_event = reporting_event
-    @account = reporting_event.account
-  end
-
-  def perform
-    return unless rollup_enabled?
-
-    rows = build_rollup_rows
-    return if rows.empty?
-
-    upsert_rollups(rows)
-  end
-
-  private
-
-  # NOTE: This is intentionally not gated by the reporting_events_rollup feature flag.
-  # Rollup data is collected for all accounts with a valid reporting timezone (soft toggle).
-  # The feature flag only controls the read path — whether reports query rollups or raw events.
-  def rollup_enabled?
-    @account.reporting_timezone.present? && ActiveSupport::TimeZone[@account.reporting_timezone].present?
-  end
-
-  def event_date
-    @event_date ||= @reporting_event.created_at.in_time_zone(@account.reporting_timezone).to_date
-  end
-
-  def dimensions
-    {
-      account: @account.id,
-      agent: @reporting_event.user_id,
-      inbox: @reporting_event.inbox_id
-    }
-  end
-
-  def build_rollup_rows
-    event_metrics = ReportingEvents::MetricRegistry.event_metrics_for(@reporting_event)
-
-    dimensions.each_with_object([]) do |(dimension_type, dimension_id), rows|
-      next if dimension_id.nil?
-
-      event_metrics.each do |metric, metric_data|
-        rows << rollup_attributes(dimension_type, dimension_id, metric, metric_data)
-      end
-    end
-  end
-
-  def upsert_rollups(rows)
-    # rubocop:disable Rails/SkipsModelValidations
-    ReportingEventsRollup.upsert_all(
-      rows,
-      unique_by: [:account_id, :date, :dimension_type, :dimension_id, :metric],
-      on_duplicate: upsert_on_duplicate_sql
-    )
-    # rubocop:enable Rails/SkipsModelValidations
-  end
-
-  def rollup_attributes(dimension_type, dimension_id, metric, metric_data)
-    {
-      account_id: @account.id, date: event_date,
-      dimension_type: dimension_type, dimension_id: dimension_id, metric: metric,
-      count: metric_data[:count], sum_value: metric_data[:sum_value].to_f,
-      sum_value_business_hours: metric_data[:sum_value_business_hours].to_f,
-      created_at: Time.current, updated_at: Time.current
-    }
-  end
-
-  def upsert_on_duplicate_sql
-    Arel.sql(
-      'count = reporting_events_rollups.count + EXCLUDED.count, ' \
-      'sum_value = reporting_events_rollups.sum_value + EXCLUDED.sum_value, ' \
-      'sum_value_business_hours = reporting_events_rollups.sum_value_business_hours + EXCLUDED.sum_value_business_hours, ' \
-      'updated_at = EXCLUDED.updated_at'
-    )
-  end
-end

app/services/reports/data_source.rb

@@ -1,106 +0,0 @@
-class Reports::DataSource
-  SUPPORTED_ROLLUP_DIMENSIONS = %w[account agent inbox].freeze
-
-  attr_reader :account, :metric, :dimension_type, :dimension_id,
-              :scope, :range, :group_by, :timezone,
-              :timezone_offset, :business_hours
-
-  class << self
-    def for(**context)
-      adapter_class_for(**context).new(**context)
-    end
-
-    def rollup_eligible?(**context)
-      account = context[:account]
-
-      rollup_enabled_for_account?(account) &&
-        !hourly_grouping?(context[:group_by]) &&
-        supported_dimension?(context[:dimension_type]) &&
-        timezone_matches_account?(account, context[:timezone], context[:timezone_offset]) &&
-        supported_metric?(context[:metric])
-    end
-
-    def timezone_matches_account?(account, timezone, timezone_offset)
-      return normalized_timezone_identifier(timezone) == normalized_timezone_identifier(account.reporting_timezone) if timezone.present?
-
-      return false if timezone_offset.blank?
-
-      offset_in_seconds = timezone_offset.to_f * 3600
-      account_zone = ActiveSupport::TimeZone[account.reporting_timezone]
-      account_zone&.now&.utc_offset == offset_in_seconds
-    end
-
-    private
-
-    def adapter_class_for(**context)
-      rollup_eligible?(**context) ? Reports::RollupDataSource : Reports::RawDataSource
-    end
-
-    def rollup_enabled_for_account?(account)
-      account.reporting_timezone.present? && account.feature_enabled?('reporting_events_rollup')
-    end
-
-    def hourly_grouping?(group_by)
-      group_by.to_s == 'hour'
-    end
-
-    def supported_dimension?(dimension_type)
-      SUPPORTED_ROLLUP_DIMENSIONS.include?((dimension_type.presence || 'account').to_s)
-    end
-
-    def supported_metric?(metric)
-      metric.blank? || ReportingEvents::MetricRegistry.rollup_supported_metric?(metric)
-    end
-
-    def normalized_timezone_identifier(timezone)
-      ActiveSupport::TimeZone[timezone]&.tzinfo&.name
-    end
-  end
-
-  def initialize(**context)
-    @account = context[:account]
-    @metric = context[:metric]
-    @dimension_type = (context[:dimension_type].presence || 'account').to_s
-    @dimension_id = context[:dimension_id]
-    @scope = context[:scope]
-    @range = context[:range]
-    @group_by = context[:group_by].to_s.presence || 'day'
-    @timezone = context[:timezone]
-    @timezone_offset = context[:timezone_offset]
-    @business_hours = context[:business_hours]
-  end
-
-  private
-
-  def report_metric
-    @report_metric ||= ReportingEvents::MetricRegistry.report_metric(metric)
-  end
-
-  def average_metric?
-    report_metric&.dig(:aggregate) == :average
-  end
-
-  def count_metric?
-    !average_metric?
-  end
-
-  def rollup_metric
-    report_metric&.dig(:rollup_metric)
-  end
-
-  def raw_event_name
-    report_metric&.dig(:raw_event_name)
-  end
-
-  def raw_count_strategy
-    report_metric&.dig(:raw_count_strategy)
-  end
-
-  def summary_metrics
-    @summary_metrics ||= ReportingEvents::MetricRegistry.summary_metrics
-  end
-
-  def use_business_hours?
-    ActiveModel::Type::Boolean.new.cast(business_hours)
-  end
-end

app/services/reports/raw_data_source.rb

@@ -1,156 +0,0 @@
-class Reports::RawDataSource < Reports::DataSource
-  def timeseries
-    average_metric? ? average_timeseries : count_timeseries
-  end
-
-  def aggregate
-    average_metric? ? average_scope.average(average_value_key) : count_scope.count
-  end
-
-  def summary
-    metric_results = summary_scope
-                     .select(*summary_select_fields)
-                     .group(summary_group_by_key)
-                     .index_by { |record| record.public_send(summary_index_key) }
-
-    merge_summary_results(metric_results, summary_conversation_counts)
-  end
-
-  private
-
-  def count_timeseries
-    grouped_count.map do |event_date, event_count|
-      { value: event_count, timestamp: event_date.in_time_zone(timezone).to_i }
-    end
-  end
-
-  def average_timeseries
-    grouped_average_time = grouped_average_scope.average(average_value_key)
-    grouped_event_count = grouped_average_scope.count
-
-    grouped_average_time.each_with_object([]) do |(event_date, average_time), results|
-      results << {
-        value: average_time,
-        timestamp: event_date.in_time_zone(timezone).to_i,
-        count: grouped_event_count[event_date]
-      }
-    end
-  end
-
-  def grouped_average_scope
-    average_scope.group_by_period(
-      group_by,
-      :created_at,
-      default_value: 0,
-      range: range,
-      permit: %w[day week month year hour],
-      time_zone: timezone
-    )
-  end
-
-  def grouped_count
-    count_scope.group_by_period(
-      group_by,
-      :created_at,
-      default_value: 0,
-      range: range,
-      permit: %w[day week month year hour],
-      time_zone: timezone
-    ).count
-  end
-
-  def average_scope
-    scope.reporting_events.where(name: raw_event_name, created_at: range, account_id: account.id)
-  end
-
-  def count_scope
-    case metric.to_s
-    when 'conversations_count'
-      scope.conversations.where(account_id: account.id, created_at: range)
-    when 'incoming_messages_count'
-      scope.messages.where(account_id: account.id, created_at: range).incoming.unscope(:order)
-    when 'outgoing_messages_count'
-      scope.messages.where(account_id: account.id, created_at: range).outgoing.unscope(:order)
-    else
-      reporting_event_count_scope
-    end
-  end
-
-  def reporting_event_count_scope
-    events = scope.reporting_events.where(
-      name: raw_event_name,
-      account_id: account.id,
-      created_at: range
-    )
-
-    return events unless raw_count_strategy == :distinct_conversation
-
-    events.joins(:conversation).select(:conversation_id).distinct
-  end
-
-  def summary_scope
-    scope = account.reporting_events.where(created_at: range)
-    return scope.joins(:conversation) if dimension_type == 'team'
-
-    scope
-  end
-
-  def summary_conversation_counts
-    account.conversations
-           .where(created_at: range)
-           .group(summary_conversation_group_by_key)
-           .count
-  end
-
-  def merge_summary_results(metric_results, conversation_counts)
-    (metric_results.keys | conversation_counts.keys).each_with_object({}) do |dimension_id, results|
-      record = metric_results[dimension_id]
-      results[dimension_id] = summary_attributes_for(record, conversation_counts[dimension_id])
-    end
-  end
-
-  def summary_select_fields
-    ["#{summary_group_by_key} as #{summary_index_key}"] + summary_metrics.map { |definition| summary_select_field(definition) }
-  end
-
-  def summary_select_field(definition)
-    if definition[:aggregate] == :count
-      "COUNT(CASE WHEN name = '#{definition[:raw_event_name]}' THEN 1 END) as #{definition[:summary_key]}"
-    else
-      "AVG(CASE WHEN name = '#{definition[:raw_event_name]}' THEN #{average_value_key} END) as #{definition[:summary_key]}"
-    end
-  end
-
-  def summary_attributes_for(record, conversations_count = 0)
-    summary_metrics.each_with_object({ conversations_count: conversations_count.to_i }) do |definition, attributes|
-      value = record&.public_send(definition[:summary_key])
-      attributes[definition[:summary_key]] = definition[:aggregate] == :count ? value.to_i : value
-    end
-  end
-
-  def summary_group_by_key
-    {
-      'account' => :account_id,
-      'agent' => :user_id,
-      'inbox' => :inbox_id,
-      'team' => 'conversations.team_id'
-    }[dimension_type]
-  end
-
-  def summary_conversation_group_by_key
-    {
-      'account' => :account_id,
-      'agent' => :assignee_id,
-      'inbox' => :inbox_id,
-      'team' => :team_id
-    }[dimension_type]
-  end
-
-  def summary_index_key
-    summary_group_by_key.to_s.split('.').last
-  end
-
-  def average_value_key
-    use_business_hours? ? :value_in_business_hours : :value
-  end
-end

app/services/reports/rollup_data_source.rb

@@ -1,199 +0,0 @@
-class Reports::RollupDataSource < Reports::DataSource
-  def timeseries
-    count_metric? ? count_timeseries : average_timeseries
-  end
-
-  def aggregate
-    count_metric? ? count_aggregate : average_aggregate
-  end
-
-  def summary
-    metric_results = summary_rows.index_by(&:dimension_id)
-
-    merge_summary_results(metric_results, summary_conversation_counts)
-  end
-
-  private
-
-  def count_timeseries
-    grouped_data = all_periods_in_range.index_with { 0 }
-
-    rollup_scope.each do |row|
-      date_key = normalized_period_key(row.date)
-      grouped_data[date_key] ||= 0
-      grouped_data[date_key] += row.count
-    end
-
-    results = grouped_data.map do |date_key, count|
-      { value: count, timestamp: date_key.in_time_zone(timezone).to_i }
-    end
-
-    results.sort_by { |result| result[:timestamp] }
-  end
-
-  def average_timeseries
-    grouped_data = all_periods_in_range.index_with { { count: 0, sum_value: 0.0 } }
-
-    rollup_scope.each { |row| accumulate_average_row(grouped_data, row) }
-
-    results = grouped_data.map do |date_key, data|
-      {
-        value: data[:count].zero? ? 0 : data[:sum_value] / data[:count],
-        timestamp: date_key.in_time_zone(timezone).to_i,
-        count: data[:count]
-      }
-    end
-
-    results.sort_by { |result| result[:timestamp] }
-  end
-
-  def count_aggregate
-    rollup_scope.sum(:count).to_i
-  end
-
-  def average_aggregate
-    result = rollup_scope.pick(Arel.sql("SUM(count), SUM(#{rollup_value_column})"))
-    return nil if result.blank? || result[0].to_i.zero?
-
-    result[1].to_f / result[0].to_i
-  end
-
-  def rollup_scope
-    ReportingEventsRollup.where(
-      account_id: account.id,
-      metric: rollup_metric,
-      dimension_type: dimension_type,
-      dimension_id: dimension_id_for_rollup,
-      date: rollup_date_range
-    )
-  end
-
-  def summary_rows
-    ReportingEventsRollup.where(
-      account_id: account.id,
-      dimension_type: dimension_type,
-      date: rollup_date_range
-    ).group(:dimension_id).select(*summary_select_fields)
-  end
-
-  def summary_conversation_counts
-    account.conversations
-           .where(created_at: range)
-           .group(summary_conversation_group_by_key)
-           .count
-  end
-
-  def merge_summary_results(metric_results, conversation_counts)
-    (metric_results.keys | conversation_counts.keys).index_with do |dimension_id|
-      summary_attributes_for(metric_results[dimension_id], conversation_counts[dimension_id])
-    end
-  end
-
-  def summary_select_fields
-    ['dimension_id'] + summary_metrics.flat_map { |definition| summary_select_fields_for_metric(definition) }
-  end
-
-  def summary_select_fields_for_metric(definition)
-    return [sum_count_select(definition[:rollup_metric], definition[:summary_key])] if definition[:aggregate] == :count
-
-    [
-      sum_count_select(definition[:rollup_metric], summary_count_alias(definition)),
-      sum_value_select(definition[:rollup_metric], summary_sum_alias(definition))
-    ]
-  end
-
-  def sum_count_select(rollup_metric_name, alias_name)
-    "SUM(CASE WHEN metric = '#{rollup_metric_name}' THEN count ELSE 0 END) as #{alias_name}"
-  end
-
-  def sum_value_select(rollup_metric_name, alias_name)
-    "SUM(CASE WHEN metric = '#{rollup_metric_name}' THEN #{rollup_value_column} ELSE 0 END) as #{alias_name}"
-  end
-
-  def summary_attributes_for(row, conversations_count = 0)
-    summary_metrics.each_with_object({ conversations_count: conversations_count.to_i }) do |definition, attributes|
-      attributes[definition[:summary_key]] = summary_value_for(row, definition)
-    end
-  end
-
-  def summary_value_for(row, definition)
-    return row&.public_send(definition[:summary_key]).to_i if definition[:aggregate] == :count
-
-    average_from(row&.public_send(summary_sum_alias(definition)), row&.public_send(summary_count_alias(definition)))
-  end
-
-  def summary_count_alias(definition)
-    "#{definition[:summary_key]}_count"
-  end
-
-  def summary_sum_alias(definition)
-    "#{definition[:summary_key]}_sum_value"
-  end
-
-  def dimension_id_for_rollup
-    dimension_type == 'account' ? account.id : scope.id
-  end
-
-  def summary_conversation_group_by_key
-    {
-      'account' => :account_id,
-      'agent' => :assignee_id,
-      'inbox' => :inbox_id,
-      'team' => :team_id
-    }[dimension_type]
-  end
-
-  def rollup_value_column
-    use_business_hours? ? :sum_value_business_hours : :sum_value
-  end
-
-  def rollup_date_range
-    tz = ActiveSupport::TimeZone[account.reporting_timezone]
-    start_date = range.first.in_time_zone(tz).to_date
-    end_date = (range.last - 1.second).in_time_zone(tz).to_date
-    start_date..end_date
-  end
-
-  def all_periods_in_range
-    current = normalized_period_key(rollup_date_range.first)
-    periods = []
-
-    while current <= rollup_date_range.last
-      periods << current
-      current = advance_period(current)
-    end
-
-    periods
-  end
-
-  def accumulate_average_row(grouped_data, row)
-    date_key = normalized_period_key(row.date)
-    grouped_data[date_key] ||= { count: 0, sum_value: 0.0 }
-    grouped_data[date_key][:count] += row.count
-    grouped_data[date_key][:sum_value] += row.public_send(rollup_value_column)
-  end
-
-  def normalized_period_key(date)
-    case group_by
-    when 'week' then date.beginning_of_week(:sunday)
-    when 'month' then date.beginning_of_month
-    when 'year' then date.beginning_of_year
-    else date
-    end
-  end
-
-  def advance_period(date)
-    case group_by
-    when 'week' then date + 1.week
-    when 'month' then date + 1.month
-    when 'year' then date + 1.year
-    else date + 1.day
-    end
-  end
-
-  def average_from(sum_value, count)
-    return nil if count.to_i.zero?
-
-    sum_value.to_f / count.to_i
-  end
-end

config/features.yml

@@ -191,6 +191,7 @@
 - name: assignment_v2
   display_name: Assignment V2
   enabled: false
+  chatwoot_internal: true
 - name: twilio_content_templates
   display_name: Twilio Content Templates
   enabled: false
@@ -241,6 +242,3 @@
   display_name: Advanced Assignment
   enabled: false
   premium: true
-- name: reporting_events_rollup
-  display_name: Reporting Events Rollup
-  enabled: false

config/locales/en.yml

@@ -48,9 +48,6 @@ en:
     inbox_deletetion_response: Your inbox deletion request will be processed in some time.
 
   errors:
-    account:
-      reporting_timezone:
-        invalid: is not a valid timezone
     validations:
       presence: must not be blank
     webhook:
@@ -238,10 +235,8 @@ en:
     activity:
       captain:
         resolved: 'Conversation was marked resolved by %{user_name} due to inactivity'
-        resolved_with_reason: 'Conversation was marked resolved by %{user_name} (%{reason})'
         resolved_by_tool: 'Conversation was marked resolved by %{user_name}: %{reason}'
         open: 'Conversation was marked open by %{user_name}'
-        open_with_reason: 'Conversation was marked open by %{user_name} (%{reason})'
         auto_opened_after_agent_reply: 'Conversation was marked open automatically after an agent reply'
       agent_bot:
         error_moved_to_open: 'Conversation was marked open by system due to an error with the agent bot.'

db/migrate/20260211145813_create_reporting_events_rollup.rb

@@ -1,39 +0,0 @@
-class CreateReportingEventsRollup < ActiveRecord::Migration[7.1]
-  disable_ddl_transaction!
-
-  def change
-    create_rollups_table
-    add_rollups_indexes
-  end
-
-  private
-
-  def create_rollups_table
-    create_table :reporting_events_rollups do |t|
-      t.integer :account_id, null: false
-      t.date :date, null: false
-      t.string :dimension_type, null: false
-      t.bigint :dimension_id, null: false
-      t.string :metric, null: false
-      t.bigint :count, default: 0, null: false
-      t.float :sum_value, default: 0.0, null: false
-      t.float :sum_value_business_hours, default: 0.0, null: false
-
-      t.timestamps
-    end
-  end
-
-  def add_rollups_indexes
-    add_index :reporting_events_rollups,
-              [:account_id, :date, :dimension_type, :dimension_id, :metric],
-              unique: true, name: 'index_rollup_unique_key', algorithm: :concurrently
-
-    add_index :reporting_events_rollups,
-              [:account_id, :metric, :date],
-              name: 'index_rollup_timeseries', algorithm: :concurrently
-
-    add_index :reporting_events_rollups,
-              [:account_id, :dimension_type, :date],
-              name: 'index_rollup_summary', algorithm: :concurrently
-  end
-end

db/schema.rb

@@ -1124,22 +1124,6 @@ ActiveRecord::Schema[7.1].define(version: 2026_02_26_153427) do
     t.index ["user_id"], name: "index_reporting_events_on_user_id"
   end
 
-  create_table "reporting_events_rollups", force: :cascade do |t|
-    t.integer "account_id", null: false
-    t.date "date", null: false
-    t.string "dimension_type", null: false
-    t.bigint "dimension_id", null: false
-    t.string "metric", null: false
-    t.bigint "count", default: 0, null: false
-    t.float "sum_value", default: 0.0, null: false
-    t.float "sum_value_business_hours", default: 0.0, null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["account_id", "date", "dimension_type", "dimension_id", "metric"], name: "index_rollup_unique_key", unique: true
-    t.index ["account_id", "dimension_type", "date"], name: "index_rollup_summary"
-    t.index ["account_id", "metric", "date"], name: "index_rollup_timeseries"
-  end
-
   create_table "sla_events", force: :cascade do |t|
     t.bigint "applied_sla_id", null: false
     t.bigint "conversation_id", null: false

enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb

@@ -24,16 +24,10 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
   end
 
   def playground
-    response = if captain_v2_enabled?
-                 Captain::Assistant::AgentRunnerService.new(assistant: @assistant, source: 'playground').generate_response(
-                   message_history: playground_message_history
-                 )
-               else
-                 Captain::Llm::AssistantChatService.new(assistant: @assistant, source: 'playground').generate_response(
-                   additional_message: playground_params[:message_content],
-                   message_history: message_history
-                 )
-               end
+    response = Captain::Llm::AssistantChatService.new(assistant: @assistant).generate_response(
+      additional_message: params[:message_content],
+      message_history: message_history
+    )
 
     render json: response
   end
@@ -70,31 +64,10 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
   end
 
   def playground_params
-    params.require(:assistant).permit(:message_content, message_history: [:role, :content, :agent_name])
+    params.require(:assistant).permit(:message_content, message_history: [:role, :content])
   end
 
   def message_history
-    (playground_params[:message_history] || []).map do |message|
-      {
-        role: message[:role],
-        content: message[:content],
-        agent_name: message[:agent_name]
-      }.compact
-    end
-  end
-
-  def playground_message_history
-    history = message_history
-    current_message = playground_params[:message_content]
-    return history if current_message.blank?
-
-    current_user_message = { role: 'user', content: current_message }
-    return history if history.last == current_user_message
-
-    history + [current_user_message]
-  end
-
-  def captain_v2_enabled?
-    @assistant.account.feature_enabled?('captain_integration_v2')
+    (playground_params[:message_history] || []).map { |message| { role: message[:role], content: message[:content] } }
   end
 end

enterprise/app/helpers/captain/chat_helper.rb

@@ -5,6 +5,7 @@ module Captain::ChatHelper
 
   def request_chat_completion
     log_chat_completion_request
+
     chat = build_chat
 
     add_messages_to_chat(chat)
@@ -85,8 +86,7 @@ module Captain::ChatHelper
       temperature: temperature,
       metadata: {
         assistant_id: @assistant&.id,
-        channel_type: resolved_channel_type,
-        source: @source
+        channel_type: resolved_channel_type
       }.compact
     }
   end
@@ -130,6 +130,7 @@ module Captain::ChatHelper
   end
 
   def log_chat_completion_request
-    Rails.logger.info("#{self.class.name} Assistant: #{@assistant.id}, requesting completion for #{@messages} with #{@tools&.length || 0} tools")
+    Rails.logger.info("#{self.class.name} Assistant: #{@assistant.id}, Requesting chat completion " \
+                      "for messages #{@messages} with #{@tools&.length || 0} tools")
   end
 end

enterprise/app/jobs/captain/inbox_pending_conversations_resolution_job.rb

@@ -1,16 +1,15 @@
 class Captain::InboxPendingConversationsResolutionJob < ApplicationJob
-  CAPTAIN_INFERENCE_RESOLVE_ACTIVITY_REASON = 'no outstanding questions'.freeze
-  CAPTAIN_INFERENCE_HANDOFF_ACTIVITY_REASON = 'pending clarification from customer'.freeze
-
   queue_as :low
 
   def perform(inbox)
     return if inbox.account.captain_disable_auto_resolve
 
-    if inbox.account.feature_enabled?('captain_tasks')
-      perform_with_evaluation(inbox)
-    else
-      perform_time_based(inbox)
+    Current.executed_by = inbox.captain_assistant
+
+    resolvable_conversations = inbox.conversations.pending.where('last_activity_at < ? ', Time.now.utc - 1.hour).limit(Limits::BULK_ACTIONS_LIMIT)
+    resolvable_conversations.each do |conversation|
+      create_outgoing_message(conversation, inbox)
+      conversation.resolved!
     end
   ensure
     Current.reset
@@ -18,118 +17,18 @@ class Captain::InboxPendingConversationsResolutionJob < ApplicationJob
 
   private
 
-  def perform_time_based(inbox)
-    Current.executed_by = inbox.captain_assistant
-
-    resolvable_pending_conversations(inbox).each do |conversation|
-      create_resolution_message(conversation, inbox)
-      conversation.resolved!
-    end
-  end
-
-  def perform_with_evaluation(inbox)
-    Current.executed_by = inbox.captain_assistant
-
-    resolvable_pending_conversations(inbox).each do |conversation|
-      evaluation = evaluate_conversation(conversation, inbox)
-      next unless still_resolvable_after_evaluation?(conversation)
-
-      if evaluation[:complete]
-        resolve_conversation(conversation, inbox, evaluation[:reason])
-      else
-        handoff_conversation(conversation, inbox, evaluation[:reason])
-      end
-    end
-  end
-
-  def evaluate_conversation(conversation, inbox)
-    Captain::ConversationCompletionService.new(
-      account: inbox.account,
-      conversation_display_id: conversation.display_id
-    ).perform
-  end
-
-  def resolvable_pending_conversations(inbox)
-    inbox.conversations.pending
-         .where('last_activity_at < ?', auto_resolve_cutoff_time)
-         .limit(Limits::BULK_ACTIONS_LIMIT)
-  end
-
-  def still_resolvable_after_evaluation?(conversation)
-    conversation.reload
-    conversation.pending? && conversation.last_activity_at < auto_resolve_cutoff_time
-  rescue ActiveRecord::RecordNotFound
-    false
-  end
-
-  def auto_resolve_cutoff_time
-    Time.now.utc - 1.hour
-  end
-
-  def resolve_conversation(conversation, inbox, reason)
-    create_private_note(conversation, inbox, "Auto-resolved: #{reason}")
-    create_resolution_message(conversation, inbox)
-    conversation.with_captain_activity_context(
-      reason: CAPTAIN_INFERENCE_RESOLVE_ACTIVITY_REASON,
-      reason_type: :inference
-    ) { conversation.resolved! }
-    conversation.dispatch_captain_inference_resolved_event
-  end
-
-  def handoff_conversation(conversation, inbox, reason)
-    create_private_note(conversation, inbox, "Auto-handoff: #{reason}")
-    create_handoff_message(conversation, inbox)
-    conversation.with_captain_activity_context(
-      reason: CAPTAIN_INFERENCE_HANDOFF_ACTIVITY_REASON,
-      reason_type: :inference
-    ) { conversation.bot_handoff! }
-    conversation.dispatch_captain_inference_handoff_event
-    send_out_of_office_message_if_applicable(conversation.reload)
-  end
-
-  def send_out_of_office_message_if_applicable(conversation)
-    # Campaign conversations should never receive OOO templates — the campaign itself
-    # serves as the initial outreach, and OOO would be confusing in that context.
-    return if conversation.campaign.present?
-
-    ::MessageTemplates::Template::OutOfOffice.perform_if_applicable(conversation)
-  end
-
-  def create_private_note(conversation, inbox, content)
-    conversation.messages.create!(
-      message_type: :outgoing,
-      private: true,
-      sender: inbox.captain_assistant,
-      account_id: conversation.account_id,
-      inbox_id: conversation.inbox_id,
-      content: content
-    )
-  end
-
-  def create_resolution_message(conversation, inbox)
+  def create_outgoing_message(conversation, inbox)
     I18n.with_locale(inbox.account.locale) do
       resolution_message = inbox.captain_assistant.config['resolution_message']
       conversation.messages.create!(
-        message_type: :outgoing,
-        account_id: conversation.account_id,
-        inbox_id: conversation.inbox_id,
-        content: resolution_message.presence || I18n.t('conversations.activity.auto_resolution_message'),
-        sender: inbox.captain_assistant
+        {
+          message_type: :outgoing,
+          account_id: conversation.account_id,
+          inbox_id: conversation.inbox_id,
+          content: resolution_message.presence || I18n.t('conversations.activity.auto_resolution_message'),
+          sender: inbox.captain_assistant
+        }
       )
     end
   end
-
-  def create_handoff_message(conversation, inbox)
-    handoff_message = inbox.captain_assistant.config['handoff_message']
-    return if handoff_message.blank?
-
-    conversation.messages.create!(
-      message_type: :outgoing,
-      sender: inbox.captain_assistant,
-      account_id: conversation.account_id,
-      inbox_id: conversation.inbox_id,
-      content: handoff_message,
-      preserve_waiting_since: true
-    )
-  end
 end

enterprise/app/models/captain/assistant.rb

@@ -106,7 +106,7 @@ class Captain::Assistant < ApplicationRecord
       scenarios: scenarios.enabled.map do |scenario|
         {
           title: scenario.title,
-          key: scenario.handoff_key,
+          key: scenario.title.parameterize.underscore,
           description: scenario.description
         }
       end,

enterprise/app/models/captain/scenario.rb

@@ -24,19 +24,6 @@ class Captain::Scenario < ApplicationRecord
   include Concerns::CaptainToolsHelpers
   include Concerns::Agentable
 
-  # OpenAI enforces a 64-char limit on function names. The ai-agents gem
-  # prepends "handoff_to_" (11 chars), so we keep a safety margin and cap
-  # the full tool name to MAX_HANDOFF_TOOL_NAME_LENGTH (60 chars).
-  # Format: "scenario_{id}_{slug}_agent" for persisted records (stable + readable),
-  # and "scenario_draft_{slug}_agent" for unsaved records, with slug truncated
-  # based on the available length budget.
-  HANDOFF_TOOL_PREFIX = 'handoff_to_'.freeze
-  HANDOFF_KEY_PREFIX = 'scenario'.freeze
-  HANDOFF_KEY_SUFFIX = 'agent'.freeze
-  MAX_HANDOFF_TOOL_NAME_LENGTH = 60
-  MAX_AGENT_NAME_LENGTH = MAX_HANDOFF_TOOL_NAME_LENGTH - HANDOFF_TOOL_PREFIX.length
-  MAX_HANDOFF_SLUG_LENGTH = 24
-
   self.table_name = 'captain_scenarios'
 
   belongs_to :assistant, class_name: 'Captain::Assistant'
@@ -55,10 +42,6 @@ class Captain::Scenario < ApplicationRecord
 
   before_save :resolve_tool_references
 
-  def handoff_key
-    [handoff_id_key, compact_handoff_slug, HANDOFF_KEY_SUFFIX].compact.join('_')
-  end
-
   def prompt_context
     {
       title: title,
@@ -73,28 +56,7 @@ class Captain::Scenario < ApplicationRecord
   private
 
   def agent_name
-    handoff_key
-  end
-
-  def handoff_id_key
-    return "#{HANDOFF_KEY_PREFIX}_#{id}" if id.present?
-
-    "#{HANDOFF_KEY_PREFIX}_draft"
-  end
-
-  def compact_handoff_slug
-    slug = title.to_s.parameterize(separator: '_').presence
-    return nil if slug.blank?
-
-    max_slug_length = [MAX_HANDOFF_SLUG_LENGTH, dynamic_slug_max_length].min
-    return nil if max_slug_length <= 0
-
-    slug.first(max_slug_length).sub(/_+\z/, '').presence
-  end
-
-  def dynamic_slug_max_length
-    # handoff_to_#{scenario_<id>_<slug>_agent}
-    MAX_AGENT_NAME_LENGTH - handoff_id_key.length - HANDOFF_KEY_SUFFIX.length - 2
+    "#{title} Agent".parameterize(separator: '_')
   end
 
   def agent_tools

enterprise/app/models/enterprise/activity_message_handler.rb

@@ -6,30 +6,18 @@ module Enterprise::ActivityMessageHandler
     key = captain_activity_key
     return unless key
 
-    I18n.t(key, user_name: Current.executed_by.name, reason: captain_status_reason, locale: locale)
+    I18n.t(key, user_name: Current.executed_by.name, reason: Current.captain_resolve_reason, locale: locale)
   end
 
   private
 
-  def captain_status_reason
-    captain_activity_reason.presence
-  end
-
   def captain_activity_key
-    return captain_resolved_activity_key if resolved?
-    return captain_open_activity_key if open?
-  end
-
-  def captain_resolved_activity_key
-    return 'conversations.activity.captain.resolved_by_tool' if captain_activity_reason_type == :tool && captain_status_reason.present?
-    return 'conversations.activity.captain.resolved_with_reason' if captain_status_reason.present?
-
-    'conversations.activity.captain.resolved'
-  end
-
-  def captain_open_activity_key
-    return 'conversations.activity.captain.open_with_reason' if captain_status_reason.present?
-
-    'conversations.activity.captain.open'
+    if resolved? && Current.captain_resolve_reason.present?
+      'conversations.activity.captain.resolved_by_tool'
+    elsif resolved?
+      'conversations.activity.captain.resolved'
+    elsif open?
+      'conversations.activity.captain.open'
+    end
   end
 end

enterprise/app/models/enterprise/conversation.rb

@@ -1,30 +1,8 @@
 module Enterprise::Conversation
-  attr_accessor :captain_activity_reason, :captain_activity_reason_type
-
-  def dispatch_captain_inference_resolved_event
-    dispatch_captain_inference_event(Events::Types::CONVERSATION_CAPTAIN_INFERENCE_RESOLVED)
-  end
-
-  def dispatch_captain_inference_handoff_event
-    dispatch_captain_inference_event(Events::Types::CONVERSATION_CAPTAIN_INFERENCE_HANDOFF)
-  end
-
   def list_of_keys
     super + %w[sla_policy_id]
   end
 
-  def with_captain_activity_context(reason:, reason_type:)
-    previous_reason = captain_activity_reason
-    previous_reason_type = captain_activity_reason_type
-
-    self.captain_activity_reason = reason
-    self.captain_activity_reason_type = reason_type
-    yield
-  ensure
-    self.captain_activity_reason = previous_reason
-    self.captain_activity_reason_type = previous_reason_type
-  end
-
   # Include select additional_attributes keys (call related) for update events
   def allowed_keys?
     return true if super
@@ -35,10 +13,4 @@ module Enterprise::Conversation
     changed_attr_keys = attrs_change[1].keys
     changed_attr_keys.intersect?(%w[call_status])
   end
-
-  private
-
-  def dispatch_captain_inference_event(event_name)
-    dispatcher_dispatch(event_name)
-  end
 end

enterprise/app/services/captain/assistant/agent_runner_service.rb

@@ -19,11 +19,11 @@ class Captain::Assistant::AgentRunnerService
   CONTACT_INBOX_STATE_ATTRIBUTES = %i[id hmac_verified].freeze
 
   CAMPAIGN_STATE_ATTRIBUTES = %i[id title message campaign_type description].freeze
-  def initialize(assistant:, conversation: nil, callbacks: {}, source: nil)
+
+  def initialize(assistant:, conversation: nil, callbacks: {})
     @assistant = assistant
     @conversation = conversation
     @callbacks = callbacks
-    @source = source
   end
 
   def generate_response(message_history: [])
@@ -32,7 +32,8 @@ class Captain::Assistant::AgentRunnerService
 
     process_agent_result(result)
   rescue StandardError => e
-    # In rake/local runs, conversation may not be present, so account is optional here.
+    # when running the agent runner service in a rake task, the conversation might not have an account associated
+    # for regular production usage, it will run just fine
     ChatwootExceptionTracker.new(e, account: @conversation&.account).capture_exception
     Rails.logger.error "[Captain V2] AgentRunnerService error: #{e.message}"
     Rails.logger.error e.backtrace.join("\n")
@@ -127,7 +128,6 @@ class Captain::Assistant::AgentRunnerService
       assistant_id: @assistant.id,
       assistant_config: @assistant.config
     }
-    state[:source] = @source if @source.present?
 
     build_conversation_state(state) if @conversation
     state
@@ -140,7 +140,8 @@ class Captain::Assistant::AgentRunnerService
     state[:campaign] = @conversation.campaign.attributes.symbolize_keys.slice(*CAMPAIGN_STATE_ATTRIBUTES) if @conversation.campaign
     return unless @conversation.contact_inbox
 
-    state[:contact_inbox] = @conversation.contact_inbox.attributes.symbolize_keys.slice(*CONTACT_INBOX_STATE_ATTRIBUTES)
+    state[:contact_inbox] =
+      @conversation.contact_inbox.attributes.symbolize_keys.slice(*CONTACT_INBOX_STATE_ATTRIBUTES)
   end
 
   def build_and_wire_agents
@@ -179,7 +180,6 @@ class Captain::Assistant::AgentRunnerService
       format(ATTR_LANGFUSE_METADATA, 'conversation_id') => conversation[:id],
       format(ATTR_LANGFUSE_METADATA, 'conversation_display_id') => conversation[:display_id],
       format(ATTR_LANGFUSE_METADATA, 'channel_type') => state[:channel_type],
-      format(ATTR_LANGFUSE_METADATA, 'source') => state[:source],
       ATTR_LANGFUSE_TRACE_INPUT => trace_input,
       ATTR_LANGFUSE_OBSERVATION_INPUT => trace_input
     }.compact.transform_values(&:to_s)

enterprise/app/services/captain/llm/assistant_chat_service.rb

@@ -1,12 +1,11 @@
 class Captain::Llm::AssistantChatService < Llm::BaseAiService
   include Captain::ChatHelper
 
-  def initialize(assistant: nil, conversation_id: nil, source: nil)
+  def initialize(assistant: nil, conversation_id: nil)
     super()
 
     @assistant = assistant
     @conversation_id = conversation_id
-    @source = source
 
     @messages = [system_message]
     @response = ''

enterprise/lib/captain/conversation_completion_schema.rb

@@ -1,4 +0,0 @@
-class Captain::ConversationCompletionSchema < RubyLLM::Schema
-  boolean :complete, description: 'Whether the conversation is complete and can be closed'
-  string :reason, description: 'Brief explanation of why the conversation is complete or incomplete'
-end

enterprise/lib/captain/conversation_completion_service.rb

@@ -1,68 +0,0 @@
-# Evaluates whether a conversation is complete and can be auto-resolved.
-# Used by InboxPendingConversationsResolutionJob to determine if inactive
-# conversations should be resolved or handed off to human agents.
-#
-# NOTE: This service intentionally does NOT count toward Captain usage limits.
-# The response excludes the :message key that Enterprise::Captain::BaseTaskService
-# checks for usage tracking. This is an internal operational evaluation,
-# not a customer-facing value-add, so we don't charge for it.
-class Captain::ConversationCompletionService < Captain::BaseTaskService
-  RESPONSE_SCHEMA = Captain::ConversationCompletionSchema
-
-  pattr_initialize [:account!, :conversation_display_id!]
-
-  def perform
-    content = format_messages_as_string
-    return default_incomplete_response('No messages found') if content.blank?
-
-    response = make_api_call(
-      model: InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_MODEL')&.value.presence || GPT_MODEL,
-      messages: [
-        { role: 'system', content: prompt_from_file('conversation_completion') },
-        { role: 'user', content: content }
-      ],
-      schema: RESPONSE_SCHEMA
-    )
-
-    return default_incomplete_response(response[:error]) if response[:error].present?
-
-    parse_response(response[:message])
-  end
-
-  private
-
-  def prompt_from_file(file_name)
-    Rails.root.join('enterprise/lib/captain/prompts', "#{file_name}.liquid").read
-  end
-
-  def format_messages_as_string
-    messages = conversation_messages(start_from: 0)
-    messages.map do |msg|
-      sender_type = msg[:role] == 'user' ? 'Customer' : 'Assistant'
-      "#{sender_type}: #{msg[:content]}"
-    end.join("\n")
-  end
-
-  def parse_response(message)
-    return default_incomplete_response('Invalid response format') unless message.is_a?(Hash)
-
-    {
-      complete: message['complete'] == true,
-      reason: message['reason'] || 'No reason provided'
-    }
-  end
-
-  def default_incomplete_response(reason)
-    { complete: false, reason: reason }
-  end
-
-  def event_name
-    'captain.conversation_completion'
-  end
-
-  def build_follow_up_context?
-    false
-  end
-end
-
-Captain::ConversationCompletionService.prepend_mod_with('Captain::ConversationCompletionService')

enterprise/lib/captain/prompts/conversation_completion.liquid

@@ -1,21 +0,0 @@
-You are evaluating whether a customer support conversation is complete and can be safely closed. When in doubt, keep the conversation OPEN. It is far better to hand off to a human agent unnecessarily than to close a conversation where the customer still needs help.
-
-The conversation may be in any language. Apply these criteria based on the intent and meaning of messages, regardless of language.
-
-A conversation is INCOMPLETE (keep open) if ANY of these apply:
-- The assistant suggested the customer try something or take an action — they may still be attempting it
-- The assistant directed the customer to an external resource, link, or contact — they may still be following up
-- The assistant asked a question or requested information that the customer hasn't provided
-- The customer asked a question that wasn't fully answered
-- The customer asked for something the assistant couldn't do — even if the assistant explained why, the customer's need is unmet
-- The customer raised multiple questions or issues and not all were addressed
-
-A conversation is COMPLETE only if ALL of these are true:
-- The assistant's answer fully addressed the customer's question or issue and is self-contained — it requires no further action from the customer
-- There are no unanswered questions, unmet requests, or outstanding follow-ups from either side
-- Note: customers often do not explicitly say thanks or confirm resolution. If the assistant gave a complete, self-contained answer and the customer had no follow-up, that is sufficient. Do not require explicit gratitude or confirmation.
-
-Analyze the conversation and respond with ONLY a JSON object (no other text):
-{"complete": true, "reason": "brief explanation"}
-or
-{"complete": false, "reason": "brief explanation"}

enterprise/lib/captain/tools/resolve_conversation_tool.rb

@@ -10,7 +10,12 @@ class Captain::Tools::ResolveConversationTool < Captain::Tools::BasePublicTool
 
     log_tool_usage('resolve_conversation', { conversation_id: conversation.id, reason: reason })
 
-    conversation.with_captain_activity_context(reason: reason, reason_type: :tool) { conversation.resolved! }
+    Current.captain_resolve_reason = reason
+    begin
+      conversation.resolved!
+    ensure
+      Current.captain_resolve_reason = nil
+    end
 
     "Conversation ##{conversation.display_id} resolved#{" (Reason: #{reason})" if reason}"
   end

enterprise/lib/enterprise/captain/conversation_completion_service.rb

@@ -1,12 +0,0 @@
-# Overrides the quota check from Enterprise::Captain::BaseTaskService
-# so that conversation completion evaluation always runs regardless of
-# the customer's Captain usage quota. This is an internal operational
-# check, not a customer-facing feature — it should never be blocked
-# by quota exhaustion.
-module Enterprise::Captain::ConversationCompletionService
-  private
-
-  def responses_available?
-    true
-  end
-end

eslint.config.js

@@ -0,0 +1,246 @@
+const js = require('@eslint/js');
+const pluginVue = require('eslint-plugin-vue');
+const pluginVueI18n = require('@intlify/eslint-plugin-vue-i18n');
+const prettierRecommended = require('eslint-plugin-prettier/recommended');
+const globals = require('globals');
+
+const vitestGlobals = {
+  describe: 'readonly',
+  it: 'readonly',
+  test: 'readonly',
+  expect: 'readonly',
+  beforeEach: 'readonly',
+  afterEach: 'readonly',
+  beforeAll: 'readonly',
+  afterAll: 'readonly',
+  vi: 'readonly',
+  vitest: 'readonly',
+  suite: 'readonly',
+};
+
+module.exports = [
+  { ignores: ['node_modules/**', 'public/**', 'vendor/**'] },
+
+  js.configs.recommended,
+  ...pluginVue.configs['flat/recommended'],
+  ...pluginVueI18n.configs['flat/recommended'],
+  prettierRecommended,
+
+  {
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+        bus: 'writable',
+        vi: 'readonly',
+      },
+    },
+    settings: {
+      'vue-i18n': {
+        localeDir: './app/javascript/*/i18n/**.json',
+      },
+    },
+    rules: {
+      // Carried from airbnb-base/legacy
+      eqeqeq: ['error', 'always', { null: 'ignore' }],
+      'no-alert': 'error',
+      'no-eval': 'error',
+      'no-implied-eval': 'error',
+      'no-new-func': 'error',
+      'no-proto': 'error',
+      'no-return-assign': 'error',
+      'no-script-url': 'error',
+      'no-sequences': 'error',
+      'no-shadow': 'error',
+      'no-throw-literal': 'error',
+      'no-unused-expressions': 'error',
+      'no-useless-call': 'error',
+      'prefer-promise-reject-errors': 'error',
+
+      camelcase: 'off',
+      'no-console': 'error',
+      'no-param-reassign': 'off',
+      'no-unused-vars': ['error', { caughtErrors: 'none', ignoreRestSiblings: true }],
+      'no-useless-assignment': 'warn',
+      'preserve-caught-error': 'off',
+
+      // Vue
+      'vue/block-order': ['error', { order: ['script', 'template', 'style'] }],
+      'vue/component-definition-name-casing': 'off',
+      'vue/component-name-in-template-casing': [
+        'error',
+        'PascalCase',
+        { registeredComponentsOnly: true },
+      ],
+      'vue/component-options-name-casing': ['error', 'PascalCase'],
+      'vue/custom-event-name-casing': ['error', 'camelCase'],
+      'vue/define-emits-declaration': ['error'],
+      'vue/define-macros-order': [
+        'error',
+        { order: ['defineProps', 'defineEmits'], defineExposeLast: false },
+      ],
+      'vue/define-props-declaration': ['error', 'runtime'],
+      'vue/html-indent': 'off',
+      'vue/html-self-closing': [
+        'error',
+        {
+          html: { void: 'always', normal: 'always', component: 'always' },
+          svg: 'always',
+          math: 'always',
+        },
+      ],
+      'vue/match-component-import-name': ['error'],
+      'vue/max-attributes-per-line': [
+        'error',
+        { singleline: { max: 20 }, multiline: { max: 1 } },
+      ],
+      'vue/multi-word-component-names': 'off',
+      'vue/next-tick-style': ['error', 'callback'],
+      'vue/no-bare-strings-in-template': [
+        'error',
+        {
+          allowlist: [
+            '(',
+            ')',
+            ',',
+            '.',
+            '&',
+            '+',
+            '-',
+            '=',
+            '*',
+            '/',
+            '#',
+            '%',
+            '!',
+            '?',
+            ':',
+            '[',
+            ']',
+            '{',
+            '}',
+            '<',
+            '>',
+            '⌘',
+            '📄',
+            '🎉',
+            '🚀',
+            '💬',
+            '👥',
+            '📥',
+            '🔖',
+            '❌',
+            '✅',
+            '\u00b7',
+            '\u2022',
+            '\u2010',
+            '\u2013',
+            '\u2014',
+            '\u2212',
+            '|',
+          ],
+          attributes: {
+            '/.+/': [
+              'title',
+              'aria-label',
+              'aria-placeholder',
+              'aria-roledescription',
+              'aria-valuetext',
+            ],
+            input: ['placeholder'],
+          },
+          directives: ['v-text'],
+        },
+      ],
+      'vue/no-empty-component-block': 'error',
+      'vue/no-multiple-objects-in-class': 'error',
+      'vue/no-required-prop-with-default': ['error', { autofix: false }],
+      'vue/no-root-v-if': 'warn',
+      'vue/no-static-inline-styles': ['error', { allowBinding: false }],
+      'vue/no-template-target-blank': [
+        'error',
+        { allowReferrer: false, enforceDynamicLinks: 'always' },
+      ],
+      'vue/no-this-in-before-route-enter': 'error',
+      'vue/no-undef-components': [
+        'error',
+        {
+          ignorePatterns: [
+            '^woot-',
+            '^fluent-',
+            '^multiselect',
+            '^router-link',
+            '^router-view',
+            '^ninja-keys',
+            '^FormulateForm',
+            '^FormulateInput',
+            '^highlightjs',
+          ],
+        },
+      ],
+      'vue/no-unused-emit-declarations': 'error',
+      'vue/no-unused-properties': [
+        'error',
+        {
+          groups: ['props'],
+          deepData: false,
+          ignorePublicMembers: false,
+          unreferencedOptions: [],
+        },
+      ],
+      'vue/no-unused-refs': 'error',
+      'vue/no-use-v-else-with-v-for': 'error',
+      'vue/no-useless-v-bind': [
+        'error',
+        { ignoreIncludesComment: false, ignoreStringEscape: false },
+      ],
+      'vue/no-v-html': 'off',
+      'vue/no-v-text': 'error',
+      'vue/padding-line-between-blocks': ['error', 'always'],
+      'vue/prefer-separate-static-class': 'error',
+      'vue/prefer-true-attribute-shorthand': 'error',
+      'vue/require-explicit-slots': 'error',
+      'vue/require-macro-variable-name': [
+        'error',
+        {
+          defineProps: 'props',
+          defineEmits: 'emit',
+          defineSlots: 'slots',
+          useSlots: 'slots',
+          useAttrs: 'attrs',
+        },
+      ],
+      'vue/singleline-html-element-content-newline': 'off',
+
+      // Vue i18n
+      '@intlify/vue-i18n/no-dynamic-keys': 'warn',
+      '@intlify/vue-i18n/no-unused-keys': [
+        'warn',
+        { extensions: ['.js', '.vue'] },
+      ],
+    },
+  },
+
+  // Spec files
+  {
+    files: ['**/*.spec.{j,t}s?(x)'],
+    languageOptions: {
+      globals: vitestGlobals,
+    },
+  },
+
+  // Story files
+  {
+    files: ['**/*.story.vue'],
+    rules: {
+      'vue/no-undef-components': [
+        'error',
+        { ignorePatterns: ['Variant', 'Story'] },
+      ],
+      'vue/no-bare-strings-in-template': 'off',
+      'no-console': 'off',
+    },
+  },
+];

lib/captain/base_task_service.rb

@@ -36,7 +36,7 @@ class Captain::BaseTaskService
     "#{endpoint}/v1"
   end
 
-  def make_api_call(model:, messages:, schema: nil, tools: [])
+  def make_api_call(model:, messages:, tools: [])
     # Community edition prerequisite checks
     # Enterprise module handles these with more specific error messages (cloud vs self-hosted)
     return { error: I18n.t('captain.disabled'), error_code: 403 } unless captain_tasks_enabled?
@@ -46,7 +46,7 @@ class Captain::BaseTaskService
     instrumentation_method = tools.any? ? :instrument_tool_session : :instrument_llm_call
 
     response = send(instrumentation_method, instrumentation_params) do
-      execute_ruby_llm_request(model: model, messages: messages, schema: schema, tools: tools)
+      execute_ruby_llm_request(model: model, messages: messages, tools: tools)
     end
 
     return response unless build_follow_up_context? && response[:message].present?
@@ -54,9 +54,9 @@ class Captain::BaseTaskService
     response.merge(follow_up_context: build_follow_up_context(messages, response))
   end
 
-  def execute_ruby_llm_request(model:, messages:, schema: nil, tools: [])
+  def execute_ruby_llm_request(model:, messages:, tools: [])
     Llm::Config.with_api_key(api_key, api_base: api_base) do |context|
-      chat = build_chat(context, model: model, messages: messages, schema: schema, tools: tools)
+      chat = build_chat(context, model: model, messages: messages, tools: tools)
 
       conversation_messages = messages.reject { |m| m[:role] == 'system' }
       return { error: 'No conversation messages provided', error_code: 400, request_messages: messages } if conversation_messages.empty?
@@ -69,11 +69,10 @@ class Captain::BaseTaskService
     { error: e.message, request_messages: messages }
   end
 
-  def build_chat(context, model:, messages:, schema: nil, tools: [])
+  def build_chat(context, model:, messages:, tools: [])
     chat = context.chat(model: model)
     system_msg = messages.find { |m| m[:role] == 'system' }
     chat.with_instructions(system_msg[:content]) if system_msg
-    chat.with_schema(schema) if schema
 
     if tools.any?
       tools.each { |tool| chat = chat.with_tool(tool) }
@@ -132,8 +131,7 @@ class Captain::BaseTaskService
                 .reorder('id desc')
                 .each do |message|
       content = message.content_for_llm
-      next if content.blank?
-      break if character_count + content.length > TOKEN_LIMIT
+      break unless content.present? && character_count + content.length <= TOKEN_LIMIT
 
       messages.prepend({ role: (message.incoming? ? 'user' : 'assistant'), content: content })
       character_count += content.length

lib/current.rb

@@ -4,6 +4,7 @@ module Current
   thread_mattr_accessor :account_user
   thread_mattr_accessor :executed_by
   thread_mattr_accessor :contact
+  thread_mattr_accessor :captain_resolve_reason
 
   def self.reset
     Current.user = nil
@@ -11,5 +12,6 @@ module Current
     Current.account_user = nil
     Current.executed_by = nil
     Current.contact = nil
+    Current.captain_resolve_reason = nil
   end
 end

lib/events/types.rb

@@ -21,8 +21,6 @@ module Events::Types
   # FIXME: deprecate the opened and resolved events in future in favor of status changed event.
   CONVERSATION_OPENED = 'conversation.opened'
   CONVERSATION_RESOLVED = 'conversation.resolved'
-  CONVERSATION_CAPTAIN_INFERENCE_RESOLVED = 'conversation.captain_inference_resolved'
-  CONVERSATION_CAPTAIN_INFERENCE_HANDOFF = 'conversation.captain_inference_handoff'
 
   CONVERSATION_STATUS_CHANGED = 'conversation.status_changed'
   CONVERSATION_CONTACT_CHANGED = 'conversation.contact_changed'

lib/integrations/llm_instrumentation_completion_helpers.rb

@@ -66,7 +66,7 @@ module Integrations::LlmInstrumentationCompletionHelpers
     return if message.blank?
 
     span.set_attribute(ATTR_GEN_AI_COMPLETION_ROLE, 'assistant')
-    span.set_attribute(ATTR_GEN_AI_COMPLETION_CONTENT, message.is_a?(String) ? message : message.to_json)
+    span.set_attribute(ATTR_GEN_AI_COMPLETION_CONTENT, message)
   end
 
   def set_usage_metrics(span, result)

lib/tasks/reporting_events_rollup.rake

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-namespace :reporting_events_rollup do
-  desc 'Backfill rollup table from historical reporting events'
-  task backfill: :environment do
-    ReportingEventsRollupBackfill.new.run
-  end
-end
-
-class ReportingEventsRollupBackfill # rubocop:disable Metrics/ClassLength
-  def run
-    print_header
-    account = prompt_account
-    timezone = resolve_timezone(account)
-    first_event, last_event = discover_events(account)
-    start_date, end_date, total_days = resolve_date_range(account, timezone, first_event, last_event)
-    dry_run = prompt_dry_run?
-    print_plan(account, timezone, start_date, end_date, total_days, first_event, last_event, dry_run)
-    return if dry_run
-
-    confirm_and_execute(account, start_date, end_date, total_days)
-  end
-
-  private
-
-  def print_header
-    puts ''
-    puts color('=' * 70, :cyan)
-    puts color('Reporting Events Rollup Backfill', :bold, :cyan)
-    puts color('=' * 70, :cyan)
-    puts color('Plan:', :bold, :yellow)
-    puts '1. Ensure account.reporting_timezone is set before running this task.'
-    puts '2. Wait for the current day to end in that account timezone.'
-    puts '3. Run backfill for closed days only (today is skipped by default).'
-    puts '4. Verify parity, then enable reporting_events_rollup read path.'
-    puts ''
-    puts color('Note:', :bold, :yellow)
-    puts '- This task always uses account.reporting_timezone.'
-    puts '- Default range is first event day -> yesterday (in account timezone).'
-    puts ''
-  end
-
-  def prompt_account
-    print 'Enter Account ID: '
-    account_id = $stdin.gets.chomp
-    abort color('Error: Account ID is required', :red, :bold) if account_id.blank?
-
-    account = Account.find_by(id: account_id)
-    abort color("Error: Account with ID #{account_id} not found", :red, :bold) unless account
-
-    puts color("Found account: #{account.name}", :gray)
-    puts ''
-    account
-  end
-
-  def resolve_timezone(account)
-    timezone = account.reporting_timezone
-    abort color("Error: Account #{account.id} must have reporting_timezone set", :red, :bold) if timezone.blank?
-    abort color("Error: Account #{account.id} has invalid reporting_timezone '#{timezone}'", :red, :bold) if ActiveSupport::TimeZone[timezone].blank?
-
-    puts color("Using account reporting timezone: #{timezone}", :gray)
-    puts ''
-    timezone
-  end
-
-  def discover_events(account)
-    first_event = account.reporting_events.order(:created_at).first
-    last_event = account.reporting_events.order(:created_at).last
-
-    if first_event.nil?
-      puts ''
-      puts "No reporting events found for account #{account.id}"
-      puts 'Nothing to backfill.'
-      exit(0)
-    end
-
-    [first_event, last_event]
-  end
-
-  def resolve_date_range(account, timezone, first_event, last_event)
-    dates = discovered_dates(timezone, first_event, last_event)
-    print_discovered_date_range(account, dates)
-    build_date_range(dates)
-  end
-
-  def prompt_dry_run?
-    print 'Dry run? (y/N): '
-    input = $stdin.gets.chomp.downcase
-    puts ''
-    %w[y yes].include?(input)
-  end
-
-  # rubocop:disable Metrics/ParameterLists
-  def print_plan(account, timezone, start_date, end_date, total_days, first_event, last_event, dry_run)
-    zone = ActiveSupport::TimeZone[timezone]
-    print_plan_summary(account, timezone, start_date, end_date, total_days, zone, first_event, last_event, dry_run)
-
-    return unless dry_run
-
-    puts color("DRY RUN MODE: Would process #{total_days} days", :yellow, :bold)
-    puts "Would use account reporting_timezone '#{timezone}'"
-    puts 'Run without dry run to execute backfill'
-  end
-  # rubocop:enable Metrics/ParameterLists
-
-  def print_plan_summary(account, timezone, start_date, end_date, total_days, zone, first_event, last_event, dry_run) # rubocop:disable Metrics/ParameterLists
-    puts color('=' * 70, :cyan)
-    puts color('Backfill Plan Summary', :bold, :cyan)
-    puts color('=' * 70, :cyan)
-    puts "Account:     #{account.name} (ID: #{account.id})"
-    puts "Timezone:    #{timezone}"
-    puts "Date Range:  #{start_date} to #{end_date} (#{total_days} days)"
-    puts "First Event: #{format_event_time(first_event, zone)}"
-    puts "Last Event:  #{format_event_time(last_event, zone)}"
-    puts "Dry Run:     #{dry_run ? 'YES (no data will be written)' : 'NO'}"
-    puts color('=' * 70, :cyan)
-    puts ''
-  end
-
-  def format_event_time(event, zone)
-    event.created_at.in_time_zone(zone).strftime('%Y-%m-%d %H:%M:%S %Z')
-  end
-
-  def discovered_dates(timezone, first_event, last_event)
-    tz = ActiveSupport::TimeZone[timezone]
-    discovered_start = first_event.created_at.in_time_zone(tz).to_date
-    discovered_end = last_event.created_at.in_time_zone(tz).to_date
-
-    {
-      discovered_start: discovered_start,
-      discovered_end: discovered_end,
-      discovered_days: (discovered_end - discovered_start).to_i + 1,
-      default_end: [discovered_end, Time.current.in_time_zone(tz).to_date - 1.day].min
-    }
-  end
-
-  def print_discovered_date_range(account, dates)
-    message = "Discovered date range: #{dates[:discovered_start]} to #{dates[:discovered_end]} " \
-              "(#{dates[:discovered_days]} days) [Account: #{account.name}]"
-    puts color(message, :gray)
-    puts color("Default end date (excluding today): #{dates[:default_end]}", :gray)
-    puts ''
-  end
-
-  def build_date_range(dates)
-    start_date = dates[:discovered_start]
-    end_date = dates[:default_end]
-    total_days = (end_date - start_date).to_i + 1
-
-    abort_no_closed_days if total_days <= 0
-
-    [start_date, end_date, total_days]
-  end
-
-  def abort_no_closed_days
-    puts 'No closed days available to backfill in the default range.'
-    exit(0)
-  end
-
-  def confirm_and_execute(account, start_date, end_date, total_days)
-    if total_days > 730
-      puts color("WARNING: Large backfill detected (#{total_days} days / #{(total_days / 365.0).round(1)} years)", :yellow, :bold)
-      puts ''
-    end
-
-    print 'Proceed with backfill? (y/N): '
-    confirm = $stdin.gets.chomp.downcase
-    abort 'Backfill cancelled' unless %w[y yes].include?(confirm)
-
-    puts ''
-    execute_backfill(account, start_date, end_date, total_days)
-  end
-
-  def execute_backfill(account, start_date, end_date, total_days)
-    puts 'Processing dates...'
-    puts ''
-
-    start_time = Time.current
-    days_processed = 0
-
-    (start_date..end_date).each do |date|
-      ReportingEvents::BackfillService.backfill_date(account, date)
-      days_processed += 1
-      percentage = (days_processed.to_f / total_days * 100).round(1)
-      print "\r#{date} | #{days_processed}/#{total_days} days | #{percentage}%    "
-      $stdout.flush
-    end
-
-    print_success(account, days_processed, total_days, Time.current - start_time)
-  rescue StandardError => e
-    print_failure(e, days_processed, total_days)
-  end
-
-  def print_success(account, days_processed, _total_days, elapsed_time)
-    puts "\n\n"
-    puts color('=' * 70, :green)
-    puts color('BACKFILL COMPLETE', :bold, :green)
-    puts color('=' * 70, :green)
-    puts "Total Days Processed: #{days_processed}"
-    puts "Total Time:           #{elapsed_time.round(2)} seconds"
-    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 '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 print_failure(error, days_processed, total_days)
-    puts "\n\n"
-    puts color('=' * 70, :red)
-    puts color('BACKFILL FAILED', :bold, :red)
-    puts color('=' * 70, :red)
-    print_error_details(error)
-    print_progress(days_processed, total_days)
-    exit(1)
-  end
-
-  def print_error_details(error)
-    puts color("Error: #{error.class.name} - #{error.message}", :red, :bold)
-    puts ''
-    puts 'Stack trace:'
-    puts error.backtrace.first(10).map { |line| "  #{line}" }.join("\n")
-    puts ''
-  end
-
-  def print_progress(days_processed, total_days)
-    percentage = (days_processed.to_f / total_days * 100).round(1)
-    puts "Processed: #{days_processed}/#{total_days} days (#{percentage}%)"
-    puts color('=' * 70, :red)
-  end
-
-  ANSI_COLORS = {
-    reset: "\e[0m",
-    bold: "\e[1m",
-    red: "\e[31m",
-    green: "\e[32m",
-    yellow: "\e[33m",
-    cyan: "\e[36m",
-    gray: "\e[90m"
-  }.freeze
-
-  def color(text, *styles)
-    return text unless $stdout.tty?
-
-    codes = styles.filter_map { |style| ANSI_COLORS[style] }.join
-    "#{codes}#{text}#{ANSI_COLORS[:reset]}"
-  end
-end

lib/tasks/reporting_events_rollup_timezone_setup.rake

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-namespace :reporting_events_rollup do
-  desc 'Interactively set account.reporting_timezone and show recommended backfill run times'
-  task set_timezone: :environment do
-    ReportingEventsRollupTimezoneSetup.new.run
-  end
-end
-
-class ReportingEventsRollupTimezoneSetup
-  def run
-    print_header
-    account = prompt_account
-    print_current_timezone(account)
-    timezone = prompt_timezone
-    confirm_and_update(account, timezone)
-    print_next_steps(account, timezone)
-  end
-
-  private
-
-  def print_header
-    puts ''
-    puts color('=' * 70, :cyan)
-    puts color('Reporting Events Rollup Timezone Setup', :bold, :cyan)
-    puts color('=' * 70, :cyan)
-    puts color('Help:', :bold, :yellow)
-    puts '1. This task writes a valid account.reporting_timezone.'
-    puts '2. Backfill uses this timezone and skips today by default.'
-    puts '3. Run backfill only after the account timezone day closes.'
-    puts ''
-  end
-
-  def prompt_account
-    print 'Enter Account ID: '
-    account_id = $stdin.gets.chomp
-    abort color('Error: Account ID is required', :red, :bold) if account_id.blank?
-
-    account = Account.find_by(id: account_id)
-    abort color("Error: Account with ID #{account_id} not found", :red, :bold) unless account
-
-    puts color("Found account: #{account.name}", :gray)
-    puts ''
-    account
-  end
-
-  def print_current_timezone(account)
-    current_timezone = account.reporting_timezone.presence || '(not set)'
-    puts color("Current reporting_timezone: #{current_timezone}", :gray)
-    puts ''
-  end
-
-  def prompt_timezone
-    loop do
-      print 'Enter UTC offset to pick timezone (e.g., +5:30, -8, 0): '
-      offset_input = $stdin.gets.chomp
-      abort color('Error: UTC offset is required', :red, :bold) if offset_input.blank?
-
-      matching_zones = find_matching_zones(offset_input)
-      abort color("Error: No timezones found for offset '#{offset_input}'", :red, :bold) if matching_zones.empty?
-
-      display_matching_zones(matching_zones, offset_input)
-      timezone = select_timezone(matching_zones)
-      return timezone if timezone.present?
-    end
-  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)
-
-    ActiveSupport::TimeZone.all.select { |tz| tz.utc_offset == total_seconds }
-  end
-
-  def display_matching_zones(zones, offset_input)
-    puts ''
-    puts color("Timezones matching UTC#{offset_input}:", :yellow, :bold)
-    puts ''
-    zones.each_with_index do |tz, index|
-      puts "  #{index + 1}. #{tz.name} (#{tz.tzinfo.identifier})"
-    end
-    puts '  0. Re-enter UTC offset'
-    puts ''
-  end
-
-  def select_timezone(zones)
-    print "Select timezone (1-#{zones.size}, 0 to go back): "
-    selection = $stdin.gets.chomp.to_i
-    return if selection.zero?
-
-    abort color('Error: Invalid selection', :red, :bold) if selection < 1 || selection > zones.size
-
-    timezone = zones[selection - 1].tzinfo.identifier
-    puts color("Selected timezone: #{timezone}", :gray)
-    puts ''
-    timezone
-  end
-
-  def confirm_and_update(account, timezone)
-    print "Update account #{account.id} reporting_timezone to '#{timezone}'? (y/N): "
-    confirm = $stdin.gets.chomp.downcase
-    abort 'Timezone setup cancelled' unless %w[y yes].include?(confirm)
-
-    account.update!(reporting_timezone: timezone)
-    puts ''
-    puts color("Updated reporting_timezone for account '#{account.name}' to '#{timezone}'", :green, :bold)
-    puts ''
-  end
-
-  def print_next_steps(account, timezone)
-    run_times = recommended_run_times(timezone)
-    print_next_steps_header
-    print_next_steps_schedule(timezone, run_times)
-    print_next_steps_backfill(account)
-    puts color('=' * 70, :green)
-  end
-
-  def print_next_steps_header
-    puts color('=' * 70, :green)
-    puts color('Next Steps', :bold, :green)
-    puts color('=' * 70, :green)
-  end
-
-  def print_next_steps_schedule(timezone, run_times)
-    puts "1. Wait for today's day-boundary to pass in #{timezone}."
-    puts '2. Recommended earliest backfill start time:'
-    puts "   - #{timezone}: #{format_time(run_times[:account_tz])}"
-    puts "   - UTC:        #{format_time(run_times[:utc])}"
-    puts "   - IST:        #{format_time(run_times[:ist])}"
-    puts "   - PCT/PT:     #{format_time(run_times[:pct])}"
-  end
-
-  def print_next_steps_backfill(account)
-    puts '3. Run backfill:'
-    puts '   bundle exec rake reporting_events_rollup:backfill'
-    puts "4. Backfill will use account.reporting_timezone and skip today by default for account #{account.id}."
-  end
-
-  def recommended_run_times(timezone)
-    account_zone = ActiveSupport::TimeZone[timezone]
-    next_day = Time.current.in_time_zone(account_zone).to_date + 1.day
-    account_time = account_zone.parse(next_day.to_s) + 30.minutes
-
-    {
-      account_tz: account_time,
-      utc: account_time.in_time_zone('UTC'),
-      ist: account_time.in_time_zone('Asia/Kolkata'),
-      pct: account_time.in_time_zone('Pacific Time (US & Canada)')
-    }
-  end
-
-  def format_time(time)
-    time.strftime('%Y-%m-%d %H:%M:%S %Z')
-  end
-
-  ANSI_COLORS = {
-    reset: "\e[0m",
-    bold: "\e[1m",
-    red: "\e[31m",
-    green: "\e[32m",
-    yellow: "\e[33m",
-    cyan: "\e[36m",
-    gray: "\e[90m"
-  }.freeze
-
-  def color(text, *styles)
-    return text unless $stdout.tty?
-
-    codes = styles.filter_map { |style| ANSI_COLORS[style] }.join
-    "#{codes}#{text}#{ANSI_COLORS[:reset]}"
-  end
-end

package.json

@@ -122,16 +122,14 @@
     "@size-limit/file": "^8.2.4",
     "@vitest/coverage-v8": "3.0.5",
     "@vue/test-utils": "^2.4.6",
+    "@eslint/js": "^10.0.0",
     "autoprefixer": "^10.4.20",
-    "eslint": "^8.57.0",
-    "eslint-config-airbnb-base": "15.0.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint": "^10.0.0",
+    "eslint-config-prettier": "^10.0.0",
     "eslint-interactive": "^11.1.0",
-    "eslint-plugin-html": "7.1.0",
-    "eslint-plugin-import": "2.30.0",
-    "eslint-plugin-prettier": "5.2.1",
-    "eslint-plugin-vitest-globals": "^1.5.0",
-    "eslint-plugin-vue": "^9.28.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-vue": "^10.8.0",
+    "globals": "^16.0.0",
     "fake-indexeddb": "^6.0.0",
     "histoire": "0.17.15",
     "husky": "^7.0.0",
@@ -161,8 +159,7 @@
       "vite-node": "2.0.1",
       "vite": "5.4.21",
       "vitest": "3.0.5",
-      "minimatch@<4": "3.1.5",
-      "minimatch@>=9.0.0 <9.0.7": "9.0.9"
+      "vue-eslint-parser": "^10.0.0"
     }
   },
   "lint-staged": {

spec/actions/contact_identify_action_spec.rb

@@ -145,24 +145,5 @@ describe ContactIdentifyAction do
         expect(contact.phone_number).to be_nil
       end
     end
-
-    context 'when params have not changed' do
-      it 'skips save and does not issue an UPDATE query' do
-        contact.update!(name: 'test', identifier: 'test_id', custom_attributes: { test: 'test', test1: 'test1' })
-        params = { name: 'test', identifier: 'test_id', custom_attributes: { test: 'test', test1: 'test1' } }
-
-        # any_instance is needed because merge lookup can reassign @contact to a different Ruby object
-        expect_any_instance_of(Contact).not_to receive(:save!) # rubocop:disable RSpec/AnyInstance
-        described_class.new(contact: contact, params: params).perform
-      end
-
-      it 'still enqueues avatar job even when attributes have not changed' do
-        contact.update!(name: 'test')
-        params = { name: 'test', avatar_url: 'https://chatwoot-assets.local/sample.png' }
-
-        expect(Avatar::AvatarFromUrlJob).to receive(:perform_later).with(contact, params[:avatar_url]).once
-        described_class.new(contact: contact, params: params).perform
-      end
-    end
   end
 end

spec/builders/v2/reports/conversations/metric_builder_spec.rb

@@ -5,10 +5,12 @@ RSpec.describe V2::Reports::Conversations::MetricBuilder, type: :model do
 
   let(:account) { create(:account) }
   let(:params) { { since: '2023-01-01', until: '2024-01-01' } }
-  let(:builder_instance) { instance_double(V2::Reports::Timeseries::ReportBuilder, aggregate_value: 42) }
+  let(:count_builder_instance) { instance_double(V2::Reports::Timeseries::CountReportBuilder, aggregate_value: 42) }
+  let(:avg_builder_instance) { instance_double(V2::Reports::Timeseries::AverageReportBuilder, aggregate_value: 42) }
 
   before do
-    allow(V2::Reports::Timeseries::ReportBuilder).to receive(:new).and_return(builder_instance)
+    allow(V2::Reports::Timeseries::CountReportBuilder).to receive(:new).and_return(count_builder_instance)
+    allow(V2::Reports::Timeseries::AverageReportBuilder).to receive(:new).and_return(avg_builder_instance)
   end
 
   describe '#summary' do
@@ -29,8 +31,8 @@ RSpec.describe V2::Reports::Conversations::MetricBuilder, type: :model do
 
     it 'creates builders with proper params' do
       subject.summary
-      expect(V2::Reports::Timeseries::ReportBuilder).to have_received(:new).with(account, params.merge(metric: 'conversations_count'))
-      expect(V2::Reports::Timeseries::ReportBuilder).to have_received(:new).with(account, params.merge(metric: 'avg_first_response_time'))
+      expect(V2::Reports::Timeseries::CountReportBuilder).to have_received(:new).with(account, params.merge(metric: 'conversations_count'))
+      expect(V2::Reports::Timeseries::AverageReportBuilder).to have_received(:new).with(account, params.merge(metric: 'avg_first_response_time'))
     end
   end
 

spec/builders/v2/reports/conversations/report_builder_spec.rb

@@ -4,19 +4,19 @@ describe V2::Reports::Conversations::ReportBuilder do
   subject { described_class.new(account, params) }
 
   let(:account) { create(:account) }
-  let(:builder) { V2::Reports::Timeseries::ReportBuilder }
+  let(:average_builder) { V2::Reports::Timeseries::AverageReportBuilder }
+  let(:count_builder) { V2::Reports::Timeseries::CountReportBuilder }
 
-  shared_examples 'valid metric handler' do |metric, method|
+  shared_examples 'valid metric handler' do |metric, method, builder|
     context 'when a valid metric is given' do
       let(:params) { { metric: metric } }
 
-      it "calls the shared #{method} builder for #{metric}" do
+      it "calls the correct #{method} builder for #{metric}" do
         builder_instance = instance_double(builder)
         allow(builder).to receive(:new).and_return(builder_instance)
-        allow(builder_instance).to receive(method).and_return(:result)
+        allow(builder_instance).to receive(method)
 
-        expect(subject.public_send(method)).to eq(:result)
-        expect(builder).to have_received(:new).with(account, params)
+        builder_instance.public_send(method)
         expect(builder_instance).to have_received(method)
       end
     end
@@ -33,12 +33,12 @@ describe V2::Reports::Conversations::ReportBuilder do
   end
 
   describe '#timeseries' do
-    it_behaves_like 'valid metric handler', 'avg_first_response_time', :timeseries
-    it_behaves_like 'valid metric handler', 'conversations_count', :timeseries
+    it_behaves_like 'valid metric handler', 'avg_first_response_time', :timeseries, V2::Reports::Timeseries::AverageReportBuilder
+    it_behaves_like 'valid metric handler', 'conversations_count', :timeseries, V2::Reports::Timeseries::CountReportBuilder
   end
 
   describe '#aggregate_value' do
-    it_behaves_like 'valid metric handler', 'avg_first_response_time', :aggregate_value
-    it_behaves_like 'valid metric handler', 'conversations_count', :aggregate_value
+    it_behaves_like 'valid metric handler', 'avg_first_response_time', :aggregate_value, V2::Reports::Timeseries::AverageReportBuilder
+    it_behaves_like 'valid metric handler', 'conversations_count', :aggregate_value, V2::Reports::Timeseries::CountReportBuilder
   end
 end

spec/builders/v2/reports/label_summary_builder_spec.rb

@@ -33,13 +33,7 @@ RSpec.describe V2::Reports::LabelSummaryBuilder do
 
     it 'sets timezone from timezone_offset' do
       builder_with_offset = described_class.new(account: account, params: { timezone_offset: -8 })
-      expected_timezone = ActiveSupport::TimeZone.all.find { |zone| zone.now.utc_offset == -8.hours }.name
-      expect(builder_with_offset.instance_variable_get(:@timezone)).to eq(expected_timezone)
-    end
-
-    it 'prefers timezone when it is provided' do
-      builder_with_timezone = described_class.new(account: account, params: { timezone: 'Asia/Kolkata', timezone_offset: -8 })
-      expect(builder_with_timezone.instance_variable_get(:@timezone)).to eq('Asia/Kolkata')
+      expect(builder_with_offset.instance_variable_get(:@timezone)).to eq('Pacific Time (US & Canada)')
     end
 
     it 'defaults timezone when timezone_offset is not provided' do

spec/builders/v2/reports/timeseries/average_report_builder_spec.rb

@@ -0,0 +1,174 @@
+require 'rails_helper'
+
+describe V2::Reports::Timeseries::AverageReportBuilder do
+  subject { described_class.new(account, params) }
+
+  let(:account) { create(:account) }
+  let(:team) { create(:team, account: account) }
+  let(:inbox) { create(:inbox, account: account) }
+  let(:label) { create(:label, title: 'spec-billing', account: account) }
+  let!(:conversation) { create(:conversation, account: account, inbox: inbox, team: team) }
+  let(:current_time) { '26.10.2020 10:00'.to_datetime }
+
+  let(:params) do
+    {
+      type: filter_type,
+      business_hours: business_hours,
+      timezone_offset: timezone_offset,
+      group_by: group_by,
+      metric: metric,
+      since: (current_time - 1.week).beginning_of_day.to_i.to_s,
+      until: current_time.end_of_day.to_i.to_s,
+      id: filter_id
+    }
+  end
+  let(:timezone_offset) { nil }
+  let(:group_by) { 'day' }
+  let(:metric) { 'avg_first_response_time' }
+  let(:business_hours) { false }
+  let(:filter_type) { :account }
+  let(:filter_id) { '' }
+
+  before do
+    travel_to current_time
+    conversation.label_list.add(label.title)
+    conversation.save!
+    create(:reporting_event, name: 'first_response', value: 80, value_in_business_hours: 10, account: account, created_at: Time.zone.now,
+                             conversation: conversation, inbox: inbox)
+    create(:reporting_event, name: 'first_response', value: 100, value_in_business_hours: 20, account: account, created_at: 1.hour.ago)
+    create(:reporting_event, name: 'first_response', value: 93, value_in_business_hours: 30, account: account, created_at: 1.week.ago)
+  end
+
+  describe '#timeseries' do
+    context 'when there is no filter applied' do
+      it 'returns the correct values' do
+        timeseries_values = subject.timeseries
+
+        expect(timeseries_values).to eq(
+          [
+            { count: 1, timestamp: 1_603_065_600, value: 93.0 },
+            { count: 0, timestamp: 1_603_152_000, value: 0 },
+            { count: 0, timestamp: 1_603_238_400, value: 0 },
+            { count: 0, timestamp: 1_603_324_800, value: 0 },
+            { count: 0, timestamp: 1_603_411_200, value: 0 },
+            { count: 0, timestamp: 1_603_497_600, value: 0 },
+            { count: 0, timestamp: 1_603_584_000, value: 0 },
+            { count: 2, timestamp: 1_603_670_400, value: 90.0 }
+          ]
+        )
+      end
+
+      context 'when business hours is provided' do
+        let(:business_hours) { true }
+
+        it 'returns correct timeseries' do
+          timeseries_values = subject.timeseries
+
+          expect(timeseries_values).to eq(
+            [
+              { count: 1, timestamp: 1_603_065_600, value: 30.0 },
+              { count: 0, timestamp: 1_603_152_000, value: 0 },
+              { count: 0, timestamp: 1_603_238_400, value: 0 },
+              { count: 0, timestamp: 1_603_324_800, value: 0 },
+              { count: 0, timestamp: 1_603_411_200, value: 0 },
+              { count: 0, timestamp: 1_603_497_600, value: 0 },
+              { count: 0, timestamp: 1_603_584_000, value: 0 },
+              { count: 2, timestamp: 1_603_670_400, value: 15.0 }
+            ]
+          )
+        end
+      end
+
+      context 'when group_by is provided' do
+        let(:group_by) { 'week' }
+
+        it 'returns correct timeseries' do
+          timeseries_values = subject.timeseries
+          expect(timeseries_values).to eq(
+            [
+              { count: 1, timestamp: (current_time - 1.week).beginning_of_week(:sunday).to_i, value: 93.0 },
+              { count: 2, timestamp: current_time.beginning_of_week(:sunday).to_i, value: 90.0 }
+            ]
+          )
+        end
+      end
+
+      context 'when timezone offset is provided' do
+        let(:timezone_offset) { '5.5' }
+        let(:group_by) { 'week' }
+
+        it 'returns correct timeseries' do
+          timeseries_values = subject.timeseries
+          expect(timeseries_values).to eq(
+            [
+              { count: 1, timestamp: (current_time - 1.week).in_time_zone('Chennai').beginning_of_week(:sunday).to_i, value: 93.0 },
+              { count: 2, timestamp: current_time.in_time_zone('Chennai').beginning_of_week(:sunday).to_i, value: 90.0 }
+            ]
+          )
+        end
+      end
+    end
+
+    context 'when the label filter is applied' do
+      let(:group_by) { 'week' }
+      let(:filter_type) { 'label' }
+      let(:filter_id) { label.id }
+
+      it 'returns correct timeseries' do
+        timeseries_values = subject.timeseries
+        start_of_the_week = current_time.beginning_of_week(:sunday).to_i
+        last_week_start_of_the_week = (current_time - 1.week).beginning_of_week(:sunday).to_i
+        expect(timeseries_values).to eq(
+          [
+            { count: 0, timestamp: last_week_start_of_the_week, value: 0 },
+            { count: 1, timestamp: start_of_the_week, value: 80.0 }
+          ]
+        )
+      end
+    end
+
+    context 'when the inbox filter is applied' do
+      let(:group_by) { 'week' }
+      let(:filter_type) { 'inbox' }
+      let(:filter_id) { inbox.id }
+
+      it 'returns correct timeseries' do
+        timeseries_values = subject.timeseries
+        start_of_the_week = current_time.beginning_of_week(:sunday).to_i
+        last_week_start_of_the_week = (current_time - 1.week).beginning_of_week(:sunday).to_i
+        expect(timeseries_values).to eq(
+          [
+            { count: 0, timestamp: last_week_start_of_the_week, value: 0 },
+            { count: 1, timestamp: start_of_the_week, value: 80.0 }
+          ]
+        )
+      end
+    end
+
+    context 'when the team filter is applied' do
+      let(:group_by) { 'week' }
+      let(:filter_type) { 'team' }
+      let(:filter_id) { team.id }
+
+      it 'returns correct timeseries' do
+        timeseries_values = subject.timeseries
+        start_of_the_week = current_time.beginning_of_week(:sunday).to_i
+        last_week_start_of_the_week = (current_time - 1.week).beginning_of_week(:sunday).to_i
+        expect(timeseries_values).to eq(
+          [
+            { count: 0, timestamp: last_week_start_of_the_week, value: 0 },
+            { count: 1, timestamp: start_of_the_week, value: 80.0 }
+          ]
+        )
+      end
+    end
+  end
+
+  describe '#aggregate_value' do
+    context 'when there is no filter applied' do
+      it 'returns the correct average value' do
+        expect(subject.aggregate_value).to eq 91.0
+      end
+    end
+  end
+end

spec/builders/v2/reports/timeseries/count_report_builder_spec.rb

@@ -0,0 +1,113 @@
+require 'rails_helper'
+
+describe V2::Reports::Timeseries::CountReportBuilder do
+  subject { described_class.new(account, params) }
+
+  let(:account) { create(:account) }
+  let(:account2) { create(:account) }
+  let(:user) { create(:user, email: 'agent1@example.com') }
+  let(:inbox) { create(:inbox, account: account) }
+  let(:inbox2) { create(:inbox, account: account2) }
+  let(:current_time) { Time.current }
+
+  let(:params) do
+    {
+      type: 'agent',
+      metric: 'resolutions_count',
+      since: (current_time - 1.day).beginning_of_day.to_i.to_s,
+      until: current_time.end_of_day.to_i.to_s,
+      id: user.id.to_s
+    }
+  end
+
+  before do
+    travel_to current_time
+
+    # Add the same user to both accounts
+    create(:account_user, account: account, user: user)
+    create(:account_user, account: account2, user: user)
+
+    # Create conversations in account1
+    conversation1 = create(:conversation, account: account, inbox: inbox, assignee: user)
+    conversation2 = create(:conversation, account: account, inbox: inbox, assignee: user)
+
+    # Create conversations in account2
+    conversation3 = create(:conversation, account: account2, inbox: inbox2, assignee: user)
+    conversation4 = create(:conversation, account: account2, inbox: inbox2, assignee: user)
+
+    # User resolves 2 conversations in account1
+    create(:reporting_event,
+           name: 'conversation_resolved',
+           account: account,
+           user: user,
+           conversation: conversation1,
+           created_at: current_time - 12.hours)
+
+    create(:reporting_event,
+           name: 'conversation_resolved',
+           account: account,
+           user: user,
+           conversation: conversation2,
+           created_at: current_time - 6.hours)
+
+    # Same user resolves 3 conversations in account2 - these should NOT be counted for account1
+    create(:reporting_event,
+           name: 'conversation_resolved',
+           account: account2,
+           user: user,
+           conversation: conversation3,
+           created_at: current_time - 8.hours)
+
+    create(:reporting_event,
+           name: 'conversation_resolved',
+           account: account2,
+           user: user,
+           conversation: conversation4,
+           created_at: current_time - 4.hours)
+
+    # Create another conversation in account2 for testing
+    conversation5 = create(:conversation, account: account2, inbox: inbox2, assignee: user)
+    create(:reporting_event,
+           name: 'conversation_resolved',
+           account: account2,
+           user: user,
+           conversation: conversation5,
+           created_at: current_time - 2.hours)
+  end
+
+  describe '#aggregate_value' do
+    it 'returns only resolutions performed by the user in the specified account' do
+      # User should have 2 resolutions in account1, not 5 (total across both accounts)
+      expect(subject.aggregate_value).to eq(2)
+    end
+
+    context 'when querying account2' do
+      subject { described_class.new(account2, params) }
+
+      it 'returns only resolutions for account2' do
+        # User should have 3 resolutions in account2
+        expect(subject.aggregate_value).to eq(3)
+      end
+    end
+  end
+
+  describe '#timeseries' do
+    it 'filters resolutions by account' do
+      result = subject.timeseries
+      # Should only count the 2 resolutions from account1
+      total_count = result.sum { |r| r[:value] }
+      expect(total_count).to eq(2)
+    end
+  end
+
+  describe 'account isolation' do
+    it 'does not leak data between accounts' do
+      # If account isolation works correctly, the counts should be different
+      account1_count = described_class.new(account, params).aggregate_value
+      account2_count = described_class.new(account2, params).aggregate_value
+
+      expect(account1_count).to eq(2)
+      expect(account2_count).to eq(3)
+    end
+  end
+end

spec/builders/v2/reports/timeseries/report_builder_spec.rb

@@ -1,470 +0,0 @@
-require 'rails_helper'
-
-describe V2::Reports::Timeseries::ReportBuilder do
-  describe 'average metrics' do
-    subject { described_class.new(account, params) }
-
-    let(:account) { create(:account) }
-    let(:team) { create(:team, account: account) }
-    let(:inbox) { create(:inbox, account: account) }
-    let(:label) { create(:label, title: 'spec-billing', account: account) }
-    let!(:conversation) { create(:conversation, account: account, inbox: inbox, team: team) }
-    let(:current_time) { '26.10.2020 10:00'.to_datetime }
-
-    let(:params) do
-      {
-        type: filter_type,
-        business_hours: business_hours,
-        timezone: timezone,
-        timezone_offset: timezone_offset,
-        group_by: group_by,
-        metric: metric,
-        since: (current_time - 1.week).beginning_of_day.to_i.to_s,
-        until: current_time.end_of_day.to_i.to_s,
-        id: filter_id
-      }
-    end
-    let(:timezone) { nil }
-    let(:timezone_offset) { nil }
-    let(:group_by) { 'day' }
-    let(:metric) { 'avg_first_response_time' }
-    let(:business_hours) { false }
-    let(:filter_type) { :account }
-    let(:filter_id) { '' }
-
-    before do
-      travel_to current_time
-      conversation.label_list.add(label.title)
-      conversation.save!
-      create(:reporting_event, name: 'first_response', value: 80, value_in_business_hours: 10, account: account, created_at: Time.zone.now,
-                               conversation: conversation, inbox: inbox)
-      create(:reporting_event, name: 'first_response', value: 100, value_in_business_hours: 20, account: account, created_at: 1.hour.ago)
-      create(:reporting_event, name: 'first_response', value: 93, value_in_business_hours: 30, account: account, created_at: 1.week.ago)
-    end
-
-    describe '#timeseries' do
-      it 'returns the correct values' do
-        timeseries_values = subject.timeseries
-
-        expect(timeseries_values).to eq(
-          [
-            { count: 1, timestamp: 1_603_065_600, value: 93.0 },
-            { count: 0, timestamp: 1_603_152_000, value: 0 },
-            { count: 0, timestamp: 1_603_238_400, value: 0 },
-            { count: 0, timestamp: 1_603_324_800, value: 0 },
-            { count: 0, timestamp: 1_603_411_200, value: 0 },
-            { count: 0, timestamp: 1_603_497_600, value: 0 },
-            { count: 0, timestamp: 1_603_584_000, value: 0 },
-            { count: 2, timestamp: 1_603_670_400, value: 90.0 }
-          ]
-        )
-      end
-
-      context 'when business hours is provided' do
-        let(:business_hours) { true }
-
-        it 'returns correct timeseries' do
-          timeseries_values = subject.timeseries
-
-          expect(timeseries_values).to eq(
-            [
-              { count: 1, timestamp: 1_603_065_600, value: 30.0 },
-              { count: 0, timestamp: 1_603_152_000, value: 0 },
-              { count: 0, timestamp: 1_603_238_400, value: 0 },
-              { count: 0, timestamp: 1_603_324_800, value: 0 },
-              { count: 0, timestamp: 1_603_411_200, value: 0 },
-              { count: 0, timestamp: 1_603_497_600, value: 0 },
-              { count: 0, timestamp: 1_603_584_000, value: 0 },
-              { count: 2, timestamp: 1_603_670_400, value: 15.0 }
-            ]
-          )
-        end
-      end
-
-      context 'when rollups are enabled' do
-        let(:timezone_offset) { '5.5' }
-
-        before do
-          account.update!(reporting_timezone: 'Chennai')
-          allow(account).to receive(:feature_enabled?).with('reporting_events_rollup').and_return(true)
-
-          create(:reporting_events_rollup,
-                 account: account,
-                 date: (current_time - 1.week).to_date,
-                 dimension_type: 'account',
-                 dimension_id: account.id,
-                 metric: 'first_response',
-                 count: 1,
-                 sum_value: 93.0,
-                 sum_value_business_hours: 30.0)
-
-          create(:reporting_events_rollup,
-                 account: account,
-                 date: current_time.to_date,
-                 dimension_type: 'account',
-                 dimension_id: account.id,
-                 metric: 'first_response',
-                 count: 2,
-                 sum_value: 180.0,
-                 sum_value_business_hours: 30.0)
-        end
-
-        it 'preserves empty buckets in the timeseries' do
-          rollup_timezone = ActiveSupport::TimeZone['Chennai']
-          rollup_start_date = DateTime.strptime(params[:since], '%s').in_time_zone(rollup_timezone).to_date
-          rollup_end_date = (DateTime.strptime(params[:until], '%s') - 1.second).in_time_zone(rollup_timezone).to_date
-          rollup_dates = rollup_start_date..rollup_end_date
-
-          expected_timeseries = rollup_dates.map do |date|
-            value = if date == (current_time - 1.week).to_date
-                      93.0
-                    elsif date == current_time.to_date
-                      90.0
-                    else
-                      0
-                    end
-
-            count = if date == (current_time - 1.week).to_date
-                      1
-                    elsif date == current_time.to_date
-                      2
-                    else
-                      0
-                    end
-
-            { count: count, timestamp: date.in_time_zone('Chennai').to_i, value: value }
-          end
-
-          expect(subject.timeseries).to eq(expected_timeseries)
-        end
-      end
-
-      context 'when group_by is provided' do
-        let(:group_by) { 'week' }
-
-        it 'returns correct timeseries' do
-          timeseries_values = subject.timeseries
-          expect(timeseries_values).to eq(
-            [
-              { count: 1, timestamp: (current_time - 1.week).beginning_of_week(:sunday).to_i, value: 93.0 },
-              { count: 2, timestamp: current_time.beginning_of_week(:sunday).to_i, value: 90.0 }
-            ]
-          )
-        end
-      end
-
-      context 'when timezone offset is provided' do
-        let(:timezone_offset) { '5.5' }
-        let(:group_by) { 'week' }
-
-        it 'returns correct timeseries' do
-          timeseries_values = subject.timeseries
-          expect(timeseries_values).to eq(
-            [
-              { count: 1, timestamp: (current_time - 1.week).in_time_zone('Chennai').beginning_of_week(:sunday).to_i, value: 93.0 },
-              { count: 2, timestamp: current_time.in_time_zone('Chennai').beginning_of_week(:sunday).to_i, value: 90.0 }
-            ]
-          )
-        end
-      end
-
-      context 'when timezone is provided' do
-        let(:timezone) { 'Asia/Kolkata' }
-        let(:timezone_offset) { '0' }
-        let(:group_by) { 'week' }
-
-        it 'uses the timezone name instead of the offset for timestamps' do
-          expect(subject.timeseries).to eq(
-            [
-              { count: 1, timestamp: (current_time - 1.week).in_time_zone('Asia/Kolkata').beginning_of_week(:sunday).to_i, value: 93.0 },
-              { count: 2, timestamp: current_time.in_time_zone('Asia/Kolkata').beginning_of_week(:sunday).to_i, value: 90.0 }
-            ]
-          )
-        end
-      end
-
-      context 'when weekly rollups are enabled' do
-        let(:group_by) { 'week' }
-        let(:timezone_offset) { '5.5' }
-
-        before do
-          account.update!(reporting_timezone: 'Chennai')
-          allow(account).to receive(:feature_enabled?).with('reporting_events_rollup').and_return(true)
-
-          create(:reporting_events_rollup,
-                 account: account,
-                 date: current_time.to_date - 1.day,
-                 dimension_type: 'account',
-                 dimension_id: account.id,
-                 metric: 'first_response',
-                 count: 1,
-                 sum_value: 80.0,
-                 sum_value_business_hours: 10.0)
-
-          create(:reporting_events_rollup,
-                 account: account,
-                 date: current_time.to_date,
-                 dimension_type: 'account',
-                 dimension_id: account.id,
-                 metric: 'first_response',
-                 count: 1,
-                 sum_value: 100.0,
-                 sum_value_business_hours: 20.0)
-        end
-
-        it 'groups weeks using sunday boundaries' do
-          expect(subject.timeseries).to eq(
-            [
-              { count: 0, timestamp: (current_time - 1.week).in_time_zone('Chennai').beginning_of_week(:sunday).to_i, value: 0 },
-              { count: 2, timestamp: current_time.in_time_zone('Chennai').beginning_of_week(:sunday).to_i, value: 90.0 }
-            ]
-          )
-        end
-      end
-
-      context 'when the label filter is applied' do
-        let(:group_by) { 'week' }
-        let(:filter_type) { 'label' }
-        let(:filter_id) { label.id }
-
-        it 'returns correct timeseries' do
-          timeseries_values = subject.timeseries
-          start_of_the_week = current_time.beginning_of_week(:sunday).to_i
-          last_week_start_of_the_week = (current_time - 1.week).beginning_of_week(:sunday).to_i
-          expect(timeseries_values).to eq(
-            [
-              { count: 0, timestamp: last_week_start_of_the_week, value: 0 },
-              { count: 1, timestamp: start_of_the_week, value: 80.0 }
-            ]
-          )
-        end
-      end
-
-      context 'when the inbox filter is applied' do
-        let(:group_by) { 'week' }
-        let(:filter_type) { 'inbox' }
-        let(:filter_id) { inbox.id }
-
-        it 'returns correct timeseries' do
-          timeseries_values = subject.timeseries
-          start_of_the_week = current_time.beginning_of_week(:sunday).to_i
-          last_week_start_of_the_week = (current_time - 1.week).beginning_of_week(:sunday).to_i
-          expect(timeseries_values).to eq(
-            [
-              { count: 0, timestamp: last_week_start_of_the_week, value: 0 },
-              { count: 1, timestamp: start_of_the_week, value: 80.0 }
-            ]
-          )
-        end
-      end
-
-      context 'when the team filter is applied' do
-        let(:group_by) { 'week' }
-        let(:filter_type) { 'team' }
-        let(:filter_id) { team.id }
-
-        it 'returns correct timeseries' do
-          timeseries_values = subject.timeseries
-          start_of_the_week = current_time.beginning_of_week(:sunday).to_i
-          last_week_start_of_the_week = (current_time - 1.week).beginning_of_week(:sunday).to_i
-          expect(timeseries_values).to eq(
-            [
-              { count: 0, timestamp: last_week_start_of_the_week, value: 0 },
-              { count: 1, timestamp: start_of_the_week, value: 80.0 }
-            ]
-          )
-        end
-      end
-    end
-
-    describe '#aggregate_value' do
-      context 'when there is no filter applied' do
-        it 'returns the correct average value' do
-          expect(subject.aggregate_value).to eq 91.0
-        end
-      end
-
-      context 'when rollups are enabled and the agent does not exist' do
-        let(:filter_type) { :agent }
-        let(:filter_id) { '999999' }
-        let(:timezone_offset) { '0' }
-
-        before do
-          account.update!(reporting_timezone: 'Etc/UTC')
-          allow(account).to receive(:feature_enabled?).with('reporting_events_rollup').and_return(true)
-        end
-
-        it 'raises record not found to preserve raw path behavior' do
-          expect { subject.aggregate_value }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-    end
-  end
-
-  describe 'count metrics' do
-    subject { described_class.new(account, params) }
-
-    let(:account) { create(:account) }
-    let(:account2) { create(:account) }
-    let(:user) { create(:user, email: 'agent1@example.com') }
-    let(:inbox) { create(:inbox, account: account) }
-    let(:inbox2) { create(:inbox, account: account2) }
-    let(:current_time) { Time.current }
-
-    let(:params) do
-      {
-        type: 'agent',
-        metric: 'resolutions_count',
-        since: since_time.beginning_of_day.to_i.to_s,
-        until: current_time.end_of_day.to_i.to_s,
-        timezone: timezone,
-        timezone_offset: timezone_offset,
-        group_by: group_by,
-        id: user.id.to_s
-      }
-    end
-    let(:group_by) { 'day' }
-    let(:since_time) { current_time - 1.day }
-    let(:timezone) { nil }
-    let(:timezone_offset) { nil }
-
-    before do
-      travel_to current_time
-
-      create(:account_user, account: account, user: user)
-      create(:account_user, account: account2, user: user)
-
-      conversation1 = create(:conversation, account: account, inbox: inbox, assignee: user)
-      conversation2 = create(:conversation, account: account, inbox: inbox, assignee: user)
-
-      conversation3 = create(:conversation, account: account2, inbox: inbox2, assignee: user)
-      conversation4 = create(:conversation, account: account2, inbox: inbox2, assignee: user)
-
-      create(:reporting_event,
-             name: 'conversation_resolved',
-             account: account,
-             user: user,
-             conversation: conversation1,
-             created_at: current_time - 12.hours)
-
-      create(:reporting_event,
-             name: 'conversation_resolved',
-             account: account,
-             user: user,
-             conversation: conversation2,
-             created_at: current_time - 6.hours)
-
-      create(:reporting_event,
-             name: 'conversation_resolved',
-             account: account2,
-             user: user,
-             conversation: conversation3,
-             created_at: current_time - 8.hours)
-
-      create(:reporting_event,
-             name: 'conversation_resolved',
-             account: account2,
-             user: user,
-             conversation: conversation4,
-             created_at: current_time - 4.hours)
-
-      conversation5 = create(:conversation, account: account2, inbox: inbox2, assignee: user)
-      create(:reporting_event,
-             name: 'conversation_resolved',
-             account: account2,
-             user: user,
-             conversation: conversation5,
-             created_at: current_time - 2.hours)
-    end
-
-    describe '#aggregate_value' do
-      it 'returns only resolutions performed by the user in the specified account' do
-        expect(subject.aggregate_value).to eq(2)
-      end
-
-      context 'when rollups are enabled and the agent does not exist' do
-        let(:timezone_offset) { '0' }
-
-        let(:params) do
-          super().merge(id: '999999')
-        end
-
-        before do
-          account.update!(reporting_timezone: 'Etc/UTC')
-          allow(account).to receive(:feature_enabled?).with('reporting_events_rollup').and_return(true)
-        end
-
-        it 'raises record not found to preserve raw path behavior' do
-          expect { subject.aggregate_value }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-
-      context 'when querying account2' do
-        subject { described_class.new(account2, params) }
-
-        it 'returns only resolutions for account2' do
-          expect(subject.aggregate_value).to eq(3)
-        end
-      end
-    end
-
-    describe '#timeseries' do
-      it 'filters resolutions by account' do
-        result = subject.timeseries
-        total_count = result.sum { |row| row[:value] }
-        expect(total_count).to eq(2)
-      end
-
-      context 'when rollups are enabled and grouped by week' do
-        let(:group_by) { 'week' }
-        let(:current_time) { Time.zone.parse('2020-10-26 10:00:00 UTC') }
-        let(:since_time) { current_time - 1.week }
-        let(:timezone_offset) { '5.5' }
-
-        before do
-          account.update!(reporting_timezone: 'Chennai')
-          allow(account).to receive(:feature_enabled?).with('reporting_events_rollup').and_return(true)
-
-          create(:reporting_events_rollup,
-                 account: account,
-                 date: current_time.to_date - 1.day,
-                 dimension_type: 'agent',
-                 dimension_id: user.id,
-                 metric: 'resolutions_count',
-                 count: 1,
-                 sum_value: 0.0,
-                 sum_value_business_hours: 0.0)
-
-          create(:reporting_events_rollup,
-                 account: account,
-                 date: current_time.to_date,
-                 dimension_type: 'agent',
-                 dimension_id: user.id,
-                 metric: 'resolutions_count',
-                 count: 1,
-                 sum_value: 0.0,
-                 sum_value_business_hours: 0.0)
-        end
-
-        it 'groups weeks using sunday boundaries' do
-          expect(subject.timeseries).to eq(
-            [
-              { value: 0, timestamp: (current_time - 1.week).in_time_zone('Chennai').beginning_of_week(:sunday).to_i },
-              { value: 2, timestamp: current_time.in_time_zone('Chennai').beginning_of_week(:sunday).to_i }
-            ]
-          )
-        end
-      end
-    end
-
-    describe 'account isolation' do
-      it 'does not leak data between accounts' do
-        account1_count = described_class.new(account, params).aggregate_value
-        account2_count = described_class.new(account2, params).aggregate_value
-
-        expect(account1_count).to eq(2)
-        expect(account2_count).to eq(3)
-      end
-    end
-  end
-end

spec/controllers/api/v2/accounts/summary_reports_controller_spec.rb

@@ -45,10 +45,7 @@ RSpec.describe 'Summary Reports API', type: :request do
             headers: admin.create_new_auth_token,
             as: :json
 
-        expect(V2::Reports::AgentSummaryBuilder).to have_received(:new).with(
-          account: account,
-          params: params.merge(type: :agent)
-        )
+        expect(V2::Reports::AgentSummaryBuilder).to have_received(:new).with(account: account, params: params)
         expect(agent_summary_builder).to have_received(:build)
 
         expect(response).to have_http_status(:success)
@@ -99,10 +96,7 @@ RSpec.describe 'Summary Reports API', type: :request do
             headers: admin.create_new_auth_token,
             as: :json
 
-        expect(V2::Reports::InboxSummaryBuilder).to have_received(:new).with(
-          account: account,
-          params: params.merge(type: :inbox)
-        )
+        expect(V2::Reports::InboxSummaryBuilder).to have_received(:new).with(account: account, params: params)
         expect(inbox_summary_builder).to have_received(:build)
 
         expect(response).to have_http_status(:success)
@@ -153,10 +147,7 @@ RSpec.describe 'Summary Reports API', type: :request do
             headers: admin.create_new_auth_token,
             as: :json
 
-        expect(V2::Reports::TeamSummaryBuilder).to have_received(:new).with(
-          account: account,
-          params: params.merge(type: :team)
-        )
+        expect(V2::Reports::TeamSummaryBuilder).to have_received(:new).with(account: account, params: params)
         expect(team_summary_builder).to have_received(:build)
 
         expect(response).to have_http_status(:success)

spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb

@@ -259,12 +259,10 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
         message_content: 'Hello assistant',
         message_history: [
           { role: 'user', content: 'Previous message' },
-          { role: 'assistant', content: 'Previous response', agent_name: 'billing_scenario' }
+          { role: 'assistant', content: 'Previous response' }
         ]
       }
     end
-    let(:chat_service) { instance_double(Captain::Llm::AssistantChatService) }
-    let(:agent_runner_service) { instance_double(Captain::Assistant::AgentRunnerService) }
 
     context 'when it is an un-authenticated user' do
       it 'returns unauthorized' do
@@ -276,14 +274,11 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
       end
     end
 
-    context 'when captain v2 is disabled' do
-      it 'generates a response with the legacy assistant chat service' do
-        allow(Captain::Llm::AssistantChatService).to receive(:new).with(
-          assistant: assistant,
-          source: 'playground'
-        ).and_return(chat_service)
+    context 'when it is an agent' do
+      it 'generates a response' do
+        chat_service = instance_double(Captain::Llm::AssistantChatService)
+        allow(Captain::Llm::AssistantChatService).to receive(:new).with(assistant: assistant).and_return(chat_service)
         allow(chat_service).to receive(:generate_response).and_return({ content: 'Assistant response' })
-        expect(Captain::Assistant::AgentRunnerService).not_to receive(:new)
 
         post "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}/playground",
              params: valid_params,
@@ -297,15 +292,14 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
         )
         expect(json_response[:content]).to eq('Assistant response')
       end
+    end
 
+    context 'when message_history is not provided' do
       it 'uses empty array as default' do
         params_without_history = { message_content: 'Hello assistant' }
-        allow(Captain::Llm::AssistantChatService).to receive(:new).with(
-          assistant: assistant,
-          source: 'playground'
-        ).and_return(chat_service)
+        chat_service = instance_double(Captain::Llm::AssistantChatService)
+        allow(Captain::Llm::AssistantChatService).to receive(:new).with(assistant: assistant).and_return(chat_service)
         allow(chat_service).to receive(:generate_response).and_return({ content: 'Assistant response' })
-        expect(Captain::Assistant::AgentRunnerService).not_to receive(:new)
 
         post "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}/playground",
              params: params_without_history,
@@ -319,53 +313,5 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
         )
       end
     end
-
-    context 'when captain v2 is enabled' do
-      before do
-        account.enable_features('captain_integration_v2')
-      end
-
-      it 'generates a response with the agent runner service' do
-        allow(Captain::Assistant::AgentRunnerService).to receive(:new).with(
-          assistant: assistant,
-          source: 'playground'
-        ).and_return(agent_runner_service)
-        allow(agent_runner_service).to receive(:generate_response).and_return({ response: 'Assistant response' })
-        expect(Captain::Llm::AssistantChatService).not_to receive(:new)
-
-        post "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}/playground",
-             params: valid_params,
-             headers: agent.create_new_auth_token,
-             as: :json
-
-        expect(response).to have_http_status(:success)
-        expect(agent_runner_service).to have_received(:generate_response).with(
-          message_history: valid_params[:message_history] + [{ role: 'user', content: valid_params[:message_content] }]
-        )
-        expect(json_response[:response]).to eq('Assistant response')
-      end
-
-      it 'does not duplicate the latest user message if it is already in history' do
-        params_with_latest_message = {
-          message_content: 'Hello assistant',
-          message_history: [{ role: 'user', content: 'Hello assistant' }]
-        }
-        allow(Captain::Assistant::AgentRunnerService).to receive(:new).with(
-          assistant: assistant,
-          source: 'playground'
-        ).and_return(agent_runner_service)
-        allow(agent_runner_service).to receive(:generate_response).and_return({ response: 'Assistant response' })
-
-        post "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}/playground",
-             params: params_with_latest_message,
-             headers: agent.create_new_auth_token,
-             as: :json
-
-        expect(response).to have_http_status(:success)
-        expect(agent_runner_service).to have_received(:generate_response).with(
-          message_history: params_with_latest_message[:message_history]
-        )
-      end
-    end
   end
 end

spec/enterprise/jobs/captain/inbox_pending_conversations_resolution_job_spec.rb

@@ -2,14 +2,16 @@ require 'rails_helper'
 
 RSpec.describe Captain::InboxPendingConversationsResolutionJob, type: :job do
   let!(:inbox) { create(:inbox) }
+
   let!(:resolvable_pending_conversation) { create(:conversation, inbox: inbox, last_activity_at: 2.hours.ago, status: :pending) }
-  let!(:recent_pending_conversation) { create(:conversation, inbox: inbox, last_activity_at: 1.minute.ago, status: :pending) }
+  let!(:recent_pending_conversation) { create(:conversation, inbox: inbox, last_activity_at: 10.minutes.ago, status: :pending) }
   let!(:open_conversation) { create(:conversation, inbox: inbox, last_activity_at: 1.hour.ago, status: :open) }
+
   let!(:captain_assistant) { create(:captain_assistant, account: inbox.account) }
 
   before do
     create(:captain_inbox, inbox: inbox, captain_assistant: captain_assistant)
-    stub_const('Limits::BULK_ACTIONS_LIMIT', 3)
+    stub_const('Limits::BULK_ACTIONS_LIMIT', 2)
     inbox.reload
   end
 
@@ -18,307 +20,49 @@ RSpec.describe Captain::InboxPendingConversationsResolutionJob, type: :job do
       .to have_enqueued_job.on_queue('low')
   end
 
-  context 'when captain_tasks is disabled' do
-    it 'resolves pending conversations inactive for over 1 hour' do
-      described_class.perform_now(inbox)
+  it 'resolves only the eligible pending conversations' do
+    described_class.perform_now(inbox)
 
-      expect(resolvable_pending_conversation.reload.status).to eq('resolved')
-    end
-
-    it 'does not resolve recent pending conversations' do
-      described_class.perform_now(inbox)
-
-      expect(recent_pending_conversation.reload.status).to eq('pending')
-    end
-
-    it 'does not affect open conversations' do
-      described_class.perform_now(inbox)
-
-      expect(open_conversation.reload.status).to eq('open')
-    end
-
-    it 'does not call ConversationCompletionService' do
-      allow(Captain::ConversationCompletionService).to receive(:new)
-
-      described_class.perform_now(inbox)
-
-      expect(Captain::ConversationCompletionService).not_to have_received(:new)
-    end
+    expect(resolvable_pending_conversation.reload.status).to eq('resolved')
+    expect(recent_pending_conversation.reload.status).to eq('pending')
+    expect(open_conversation.reload.status).to eq('open')
   end
 
-  context 'when captain_tasks is enabled' do
-    before do
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-    end
-
-    it 'only evaluates eligible pending conversations (inactive > 1 hour)' do
-      allow(Captain::ConversationCompletionService).to receive(:new).and_call_original
-
-      # Mock the service to return complete for all conversations
-      mock_service = instance_double(Captain::ConversationCompletionService)
-      allow(mock_service).to receive(:perform).and_return({ complete: true, reason: 'Test' })
-      allow(Captain::ConversationCompletionService).to receive(:new).and_return(mock_service)
+  it 'creates exactly one outgoing message with configured content' do
+    custom_message = 'This is a custom resolution message.'
+    captain_assistant.update!(config: { 'resolution_message' => custom_message })
 
+    expect do
       described_class.perform_now(inbox)
+    end.to change { resolvable_pending_conversation.messages.outgoing.reload.count }.by(1)
 
-      # Only resolvable conversation should be evaluated (not recent or open)
-      expect(Captain::ConversationCompletionService).to have_received(:new).with(
-        account: inbox.account,
-        conversation_display_id: resolvable_pending_conversation.display_id
-      )
-      expect(recent_pending_conversation.reload.status).to eq('pending')
-      expect(open_conversation.reload.status).to eq('open')
-    end
-
-    it 'skips auto-action if conversation receives new activity after evaluation' do
-      mock_service = instance_double(Captain::ConversationCompletionService)
-      allow(mock_service).to receive(:perform) do
-        resolvable_pending_conversation.update!(last_activity_at: Time.current)
-        { complete: true, reason: 'Customer question was answered' }
-      end
-      allow(Captain::ConversationCompletionService).to receive(:new).and_return(mock_service)
-
-      described_class.perform_now(inbox)
-
-      expect(resolvable_pending_conversation.reload.status).to eq('pending')
-      expect(resolvable_pending_conversation.messages.outgoing).to be_empty
-    end
+    outgoing_message = resolvable_pending_conversation.messages.outgoing.last
+    expect(outgoing_message.content).to eq(custom_message)
   end
 
-  context 'when LLM evaluation returns complete' do
-    before do
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-      mock_service = instance_double(Captain::ConversationCompletionService)
-      allow(mock_service).to receive(:perform).and_return({ complete: true, reason: 'Customer question was answered' })
-      allow(Captain::ConversationCompletionService).to receive(:new).and_return(mock_service)
-    end
+  it 'creates an outgoing message with default auto resolution message if not configured' do
+    captain_assistant.update!(config: {})
 
-    it 'resolves the conversation' do
-      described_class.perform_now(inbox)
-
-      expect(resolvable_pending_conversation.reload.status).to eq('resolved')
-    end
-
-    it 'creates a private note with the reason' do
-      described_class.perform_now(inbox)
-
-      private_note = resolvable_pending_conversation.messages.where(private: true).last
-      expect(private_note.content).to eq('Auto-resolved: Customer question was answered')
-    end
-
-    it 'creates resolution message with configured content' do
-      custom_message = 'This is a custom resolution message.'
-      captain_assistant.update!(config: { 'resolution_message' => custom_message })
-      inbox.reload
-
-      described_class.perform_now(inbox)
-
-      public_message = resolvable_pending_conversation.messages.where(private: false).outgoing.last
-      expect(public_message.content).to eq(custom_message)
-    end
-
-    it 'creates resolution message with default if not configured' do
-      captain_assistant.update!(config: {})
-      inbox.reload
-
-      described_class.perform_now(inbox)
-
-      public_message = resolvable_pending_conversation.messages.where(private: false).outgoing.last
-      expect(public_message.content).to eq(I18n.t('conversations.activity.auto_resolution_message'))
-    end
-
-    it 'adds the correct activity message after resolution' do
-      described_class.perform_now(inbox)
-
-      expected_content = I18n.t(
-        'conversations.activity.captain.resolved_with_reason',
-        user_name: captain_assistant.name,
-        reason: 'no outstanding questions'
-      )
-      expect(Conversations::ActivityMessageJob)
-        .to have_been_enqueued.with(
-          resolvable_pending_conversation,
-          {
-            account_id: resolvable_pending_conversation.account_id,
-            inbox_id: resolvable_pending_conversation.inbox_id,
-            message_type: :activity,
-            content: expected_content
-          }
-        )
-    end
-
-    it 'creates a captain inference resolved reporting event' do
-      perform_enqueued_jobs do
-        described_class.perform_now(inbox)
-      end
-
-      inference_event = ReportingEvent.find_by(
-        conversation_id: resolvable_pending_conversation.id,
-        name: 'conversation_captain_inference_resolved'
-      )
-      expect(inference_event).to be_present
-    end
+    described_class.perform_now(inbox)
+    outgoing_message = resolvable_pending_conversation.messages.outgoing.last
+    expect(outgoing_message.content).to eq(
+      I18n.t('conversations.activity.auto_resolution_message')
+    )
   end
 
-  context 'when LLM evaluation returns incomplete' do
-    let(:handoff_reason) { 'Assistant asked for order number but customer did not respond' }
-
-    before do
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-      mock_service = instance_double(Captain::ConversationCompletionService)
-      allow(mock_service).to receive(:perform).and_return({ complete: false, reason: handoff_reason })
-      allow(Captain::ConversationCompletionService).to receive(:new).and_return(mock_service)
-    end
-
-    it 'hands off the conversation to agents (status becomes open)' do
-      described_class.perform_now(inbox)
-
-      expect(resolvable_pending_conversation.reload.status).to eq('open')
-    end
-
-    it 'creates a private note with the reason' do
-      described_class.perform_now(inbox)
-
-      private_note = resolvable_pending_conversation.messages.where(private: true).last
-      expect(private_note.content).to eq("Auto-handoff: #{handoff_reason}")
-    end
-
-    it 'creates handoff message with configured content' do
-      handoff_message = 'Connecting you to a human agent...'
-      captain_assistant.update!(config: { 'handoff_message' => handoff_message })
-      inbox.reload
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-
-      described_class.perform_now(inbox)
-
-      public_message = resolvable_pending_conversation.messages.where(private: false).outgoing.last
-      expect(public_message.content).to eq(handoff_message)
-      expect(public_message.additional_attributes['preserve_waiting_since']).to be_nil
-    end
-
-    it 'preserves existing waiting_since when handoff message is configured' do
-      handoff_message = 'Connecting you to a human agent...'
-      original_waiting_since = 3.hours.ago
-
-      captain_assistant.update!(config: { 'handoff_message' => handoff_message })
-      resolvable_pending_conversation.update!(waiting_since: original_waiting_since)
-      allow(MessageTemplates::Template::OutOfOffice).to receive(:perform_if_applicable)
-      inbox.reload
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-
-      described_class.perform_now(inbox)
-
-      expect(resolvable_pending_conversation.reload.waiting_since).to be_within(1.second).of(original_waiting_since)
-    end
-
-    it 'does not create handoff message if not configured' do
-      captain_assistant.update!(config: {})
-      inbox.reload
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-
-      expect do
-        described_class.perform_now(inbox)
-      end.not_to(change { resolvable_pending_conversation.messages.where(private: false).count })
-    end
-
-    it 'adds the correct activity message after handoff' do
-      described_class.perform_now(inbox)
-
-      expected_content = I18n.t(
-        'conversations.activity.captain.open_with_reason',
-        user_name: captain_assistant.name,
-        reason: 'pending clarification from customer'
+  it 'adds the correct activity message after resolution by Captain' do
+    described_class.perform_now(inbox)
+    expected_content = I18n.t('conversations.activity.captain.resolved', user_name: captain_assistant.name)
+    expect(Conversations::ActivityMessageJob)
+      .to have_been_enqueued.with(
+        resolvable_pending_conversation,
+        {
+          account_id: resolvable_pending_conversation.account_id,
+          inbox_id: resolvable_pending_conversation.inbox_id,
+          message_type: :activity,
+          content: expected_content
+        }
       )
-      expect(Conversations::ActivityMessageJob)
-        .to have_been_enqueued.with(
-          resolvable_pending_conversation,
-          {
-            account_id: resolvable_pending_conversation.account_id,
-            inbox_id: resolvable_pending_conversation.inbox_id,
-            message_type: :activity,
-            content: expected_content
-          }
-        )
-    end
-
-    it 'creates a captain inference handoff reporting event' do
-      perform_enqueued_jobs do
-        described_class.perform_now(inbox)
-      end
-
-      inference_event = ReportingEvent.find_by(
-        conversation_id: resolvable_pending_conversation.id,
-        name: 'conversation_captain_inference_handoff'
-      )
-      expect(inference_event).to be_present
-    end
-  end
-
-  context 'when handoff occurs outside business hours' do
-    let(:handoff_reason) { 'Customer has not responded to clarifying question' }
-
-    before do
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-      mock_service = instance_double(Captain::ConversationCompletionService)
-      allow(mock_service).to receive(:perform).and_return({ complete: false, reason: handoff_reason })
-      allow(Captain::ConversationCompletionService).to receive(:new).and_return(mock_service)
-      inbox.update!(working_hours_enabled: true, out_of_office_message: 'We are currently unavailable.')
-    end
-
-    it 'sends OOO message for non-campaign conversations' do
-      travel_to '01.11.2020 13:00'.to_datetime do
-        resolvable_pending_conversation.update!(last_activity_at: 2.hours.ago)
-        described_class.perform_now(inbox)
-
-        ooo_message = resolvable_pending_conversation.messages.template.last
-        expect(ooo_message).to be_present
-        expect(ooo_message.content).to eq('We are currently unavailable.')
-      end
-    end
-
-    it 'does not send OOO message for campaign conversations' do
-      campaign = create(:campaign, account: inbox.account, inbox: inbox)
-      resolvable_pending_conversation.update!(campaign: campaign)
-
-      travel_to '01.11.2020 13:00'.to_datetime do
-        resolvable_pending_conversation.update!(last_activity_at: 2.hours.ago)
-        described_class.perform_now(inbox)
-
-        expect(resolvable_pending_conversation.messages.template).to be_empty
-      end
-    end
-
-    it 'does not send OOO message during business hours' do
-      travel_to '26.10.2020 10:00'.to_datetime do
-        resolvable_pending_conversation.update!(last_activity_at: 2.hours.ago)
-        described_class.perform_now(inbox)
-
-        expect(resolvable_pending_conversation.messages.template).to be_empty
-      end
-    end
-  end
-
-  context 'when LLM evaluation fails' do
-    before do
-      allow(inbox.account).to receive(:feature_enabled?).and_call_original
-      allow(inbox.account).to receive(:feature_enabled?).with('captain_tasks').and_return(true)
-      mock_service = instance_double(Captain::ConversationCompletionService)
-      allow(mock_service).to receive(:perform).and_return({ complete: false, reason: 'API Error' })
-      allow(Captain::ConversationCompletionService).to receive(:new).and_return(mock_service)
-    end
-
-    it 'hands off as safe default' do
-      described_class.perform_now(inbox)
-
-      expect(resolvable_pending_conversation.reload.status).to eq('open')
-    end
   end
 
   it 'does not resolve conversations when auto-resolve is disabled at execution time' do