fix(captain): mark discarded generations

VERSION_CW

@@ -1 +1 @@
-4.16.1
+4.16.0

app/javascript/dashboard/components/ui/ContextMenu.vue

@@ -77,15 +77,6 @@ const handleClose = () => {
   emit('close');
 };
 
-const handleFocusOut = event => {
-  // Keep the menu open while focus stays inside it (e.g. the label search
-  // input); close it once focus leaves the menu entirely.
-  if (menuRef.value?.contains(event.relatedTarget)) {
-    return;
-  }
-  handleClose();
-};
-
 onUnmounted(() => {
   isLocked.value = false;
 });
@@ -98,7 +89,7 @@ onUnmounted(() => {
       class="fixed outline-none z-[9999] cursor-pointer"
       :style="position"
       tabindex="0"
-      @focusout="handleFocusOut"
+      @blur="handleClose"
     >
       <slot />
     </div>

app/javascript/dashboard/components/widgets/conversation/MessagesView.vue

@@ -33,7 +33,9 @@ import {
 // constants
 import { BUS_EVENTS } from 'shared/constants/busEvents';
 import { REPLY_POLICY } from 'shared/constants/links';
-import wootConstants from 'dashboard/constants/globals';
+import wootConstants, {
+  META_RESTRICTION_STATUS_URL,
+} from 'dashboard/constants/globals';
 import { LOCAL_STORAGE_KEYS } from 'dashboard/constants/localStorage';
 import { INBOX_TYPES } from 'dashboard/helper/inbox';
 
@@ -93,6 +95,7 @@ export default {
       currentUserId: 'getCurrentUserID',
       listLoadingStatus: 'getAllMessagesLoaded',
       currentAccountId: 'getCurrentAccountId',
+      isOnChatwootCloud: 'globalConfig/isOnChatwootCloud',
     }),
     isOpen() {
       return this.currentChat?.status === wootConstants.STATUS_TYPE.OPEN;
@@ -170,6 +173,13 @@ export default {
         instagramInbox
       );
     },
+    isInstagramRestrictionBannerVisible() {
+      return this.isOnChatwootCloud && this.isAnInstagramChannel;
+    },
+    instagramRestrictionStatusUrl() {
+      return META_RESTRICTION_STATUS_URL;
+    },
+
     replyWindowBannerMessage() {
       if (this.isAWhatsAppChannel) {
         return this.$t('CONVERSATION.TWILIO_WHATSAPP_CAN_REPLY');
@@ -454,7 +464,15 @@ export default {
   >
     <div ref="topBannerRef">
       <Banner
-        v-if="!currentChat.can_reply"
+        v-if="isInstagramRestrictionBannerVisible"
+        color-scheme="warning"
+        class="mx-2 mt-2 overflow-hidden rounded-lg"
+        :banner-message="$t('CONVERSATION.INSTAGRAM_RESTRICTION_BANNER')"
+        :href-link="instagramRestrictionStatusUrl"
+        :href-link-text="$t('CONVERSATION.INSTAGRAM_RESTRICTION_STATUS_LINK')"
+      />
+      <Banner
+        v-else-if="!currentChat.can_reply"
         color-scheme="alert"
         class="mx-2 mt-2 overflow-hidden rounded-lg"
         :banner-message="replyWindowBannerMessage"

app/javascript/dashboard/components/widgets/conversation/contextMenu/Index.vue

@@ -7,13 +7,10 @@ import {
   getSortedAgentsByAvailability,
   getAgentsByUpdatedPresence,
 } from 'dashboard/helper/agentHelper.js';
-import { picoSearch } from '@scmmishra/pico-search';
 import MenuItem from './menuItem.vue';
 import MenuItemWithSubmenu from './menuItemWithSubmenu.vue';
 import wootConstants from 'dashboard/constants/globals';
 import AgentLoadingPlaceholder from './agentLoadingPlaceholder.vue';
-import NextInput from 'dashboard/components-next/input/Input.vue';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
 
 const MENU = {
   MARK_AS_READ: 'mark-as-read',
@@ -34,8 +31,6 @@ export default {
     MenuItem,
     MenuItemWithSubmenu,
     AgentLoadingPlaceholder,
-    NextInput,
-    Icon,
   },
   props: {
     chatId: {
@@ -92,7 +87,6 @@ export default {
   data() {
     return {
       MENU,
-      labelSearchQuery: '',
       STATUS_TYPE: wootConstants.STATUS_TYPE,
       readOption: {
         label: this.$t('CONVERSATION.CARD_CONTEXT_MENU.MARK_AS_READ'),
@@ -222,14 +216,6 @@ export default {
       // Don't show snooze if the conversation is already snoozed/resolved/pending
       return this.status === wootConstants.STATUS_TYPE.OPEN;
     },
-    filteredLabels() {
-      const labels = this.labelSearchQuery
-        ? picoSearch(this.labels, this.labelSearchQuery, ['title'])
-        : this.labels;
-      // Assigned labels first, keeping each group's existing order.
-      const isAssigned = label => this.conversationLabels.includes(label.title);
-      return [...labels].sort((a, b) => isAssigned(b) - isAssigned(a));
-    },
   },
   mounted() {
     this.$store.dispatch('inboxAssignableAgents/fetch', [this.inboxId]);
@@ -349,49 +335,21 @@ export default {
         :option="labelMenuConfig"
         :sub-menu-available="!!labels.length"
       >
-        <div class="pb-1 w-[12.5rem]">
-          <NextInput
-            v-model="labelSearchQuery"
-            type="search"
-            size="sm"
-            class="w-full"
-            custom-input-class="!ps-8 !text-xs"
-            :placeholder="$t('CONVERSATION.CARD_CONTEXT_MENU.SEARCH_LABELS')"
-            @click.stop
-            @keydown.stop
-          >
-            <template #prefix>
-              <Icon
-                icon="i-lucide-search"
-                class="absolute z-10 -translate-y-1/2 pointer-events-none size-3.5 text-n-slate-10 top-1/2 start-2"
-              />
-            </template>
-          </NextInput>
-        </div>
-        <div class="overflow-x-hidden overflow-y-auto max-h-[12.5rem]">
-          <MenuItem
-            v-for="label in filteredLabels"
-            :key="label.id"
-            :option="generateMenuLabelConfig(label, 'label')"
-            :variant="
-              conversationLabels.includes(label.title)
-                ? 'label-assigned'
-                : 'label'
-            "
-            @mousedown.prevent
-            @click.stop="
-              conversationLabels.includes(label.title)
-                ? $emit('removeLabel', label)
-                : $emit('assignLabel', label)
-            "
-          />
-          <p
-            v-if="!filteredLabels.length"
-            class="px-2 py-2 m-0 text-xs text-center text-n-slate-11"
-          >
-            {{ $t('CONVERSATION.CARD_CONTEXT_MENU.NO_LABELS_FOUND') }}
-          </p>
-        </div>
+        <MenuItem
+          v-for="label in labels"
+          :key="label.id"
+          :option="generateMenuLabelConfig(label, 'label')"
+          :variant="
+            conversationLabels.includes(label.title)
+              ? 'label-assigned'
+              : 'label'
+          "
+          @click.stop="
+            conversationLabels.includes(label.title)
+              ? $emit('removeLabel', label)
+              : $emit('assignLabel', label)
+          "
+        />
       </MenuItemWithSubmenu>
       <MenuItemWithSubmenu
         v-if="isAllowed([MENU.AGENT])"

app/javascript/dashboard/components/widgets/conversation/contextMenu/menuItem.vue

@@ -15,7 +15,7 @@ defineProps({
 </script>
 
 <template>
-  <div class="menu group text-n-slate-12 min-h-7 min-w-0" role="button">
+  <div class="menu text-n-slate-12 min-h-7 min-w-0" role="button">
     <fluent-icon
       v-if="variant === 'icon' && option.icon"
       :icon="option.icon"
@@ -52,7 +52,7 @@ defineProps({
     <Icon
       v-if="variant === 'label-assigned'"
       icon="i-lucide-check"
-      class="flex-shrink-0 size-3.5 text-n-brand group-hover:text-white"
+      class="flex-shrink-0 size-3.5 mr-1"
     />
   </div>
 </template>

app/javascript/dashboard/constants/globals.js

@@ -78,3 +78,5 @@ export default {
   },
 };
 export const DEFAULT_REDIRECT_URL = '/app/';
+export const META_RESTRICTION_STATUS_URL =
+  'https://status.chatwoot.com/incident/948346';

app/javascript/dashboard/i18n/locale/en/conversation.json

@@ -44,6 +44,8 @@
     "TWILIO_WHATSAPP_CAN_REPLY": "You can only reply to this conversation using a template message due to",
     "TWILIO_WHATSAPP_24_HOURS_WINDOW": "24 hour message window restriction",
     "OLD_INSTAGRAM_INBOX_REPLY_BANNER": "This Instagram account was migrated to the new Instagram channel inbox. All new messages will show up there. You won’t be able to send messages from this conversation anymore.",
+    "INSTAGRAM_RESTRICTION_BANNER": "Instagram is currently restricted. Some messages or actions may be delayed or unavailable while we restore full support.",
+    "INSTAGRAM_RESTRICTION_STATUS_LINK": "View status update",
     "REPLYING_TO": "You are replying to:",
     "REMOVE_SELECTION": "Remove Selection",
     "DOWNLOAD": "Download",
@@ -193,8 +195,6 @@
       },
       "ASSIGN_AGENT": "Assign agent",
       "ASSIGN_LABEL": "Assign label",
-      "SEARCH_LABELS": "Search labels",
-      "NO_LABELS_FOUND": "No labels found",
       "AGENTS_LOADING": "Loading agents...",
       "ASSIGN_TEAM": "Assign team",
       "DELETE": "Delete conversation",

app/javascript/dashboard/i18n/locale/en/inboxMgmt.json

@@ -58,7 +58,9 @@
         "ERROR_MESSAGE": "There was an error connecting to Instagram, please try again",
         "ERROR_AUTH": "There was an error connecting to Instagram, please try again",
         "NEW_INBOX_SUGGESTION": "This Instagram account was previously linked to a different inbox and has now been migrated here. All new messages will appear here. The old inbox will no longer be able to send or receive messages for this account.",
-        "DUPLICATE_INBOX_BANNER": "This Instagram account was migrated to the new Instagram channel inbox. You won’t be able to send/receive Instagram messages from this inbox anymore."
+        "DUPLICATE_INBOX_BANNER": "This Instagram account was migrated to the new Instagram channel inbox. You won’t be able to send/receive Instagram messages from this inbox anymore.",
+        "SETTINGS_RESTRICTED_WARNING": "Instagram is currently restricted. Some messages or actions may be delayed or unavailable while we restore full support.",
+        "STATUS_LINK": "View status update"
       },
       "TIKTOK": {
         "CONTINUE_WITH_TIKTOK": "Continue with TikTok",

app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue

@@ -4,6 +4,8 @@ import { shouldBeUrl } from 'shared/helpers/Validators';
 import { useAlert } from 'dashboard/composables';
 import { useVuelidate } from '@vuelidate/core';
 import Avatar from 'next/avatar/Avatar.vue';
+import Banner from 'dashboard/components-next/banner/Banner.vue';
+import Icon from 'dashboard/components-next/icon/Icon.vue';
 import SettingIntroBanner from 'dashboard/components/widgets/SettingIntroBanner.vue';
 import SettingsToggleSection from 'dashboard/components-next/Settings/SettingsToggleSection.vue';
 import SettingsFieldSection from 'dashboard/components-next/Settings/SettingsFieldSection.vue';
@@ -44,9 +46,11 @@ import SelectInput from 'dashboard/components-next/select/Select.vue';
 import Widget from 'dashboard/modules/widget-preview/components/Widget.vue';
 import AccessToken from 'dashboard/routes/dashboard/settings/profile/AccessToken.vue';
 import { copyTextToClipboard } from 'shared/helpers/clipboard';
+import { META_RESTRICTION_STATUS_URL } from 'dashboard/constants/globals';
 
 export default {
   components: {
+    Banner,
     BotConfiguration,
     CollaboratorsPage,
     ConfigurationPage,
@@ -80,6 +84,7 @@ export default {
     WhatsappManualMigrationBanner,
     Widget,
     AccessToken,
+    Icon,
   },
   mixins: [inboxMixin],
   setup() {
@@ -343,6 +348,12 @@ export default {
     instagramUnauthorized() {
       return this.isAnInstagramChannel && this.inbox.reauthorization_required;
     },
+    showInstagramRestrictionSettingsBanner() {
+      return this.isOnChatwootCloud && this.isAnInstagramChannel;
+    },
+    metaRestrictionStatusUrl() {
+      return META_RESTRICTION_STATUS_URL;
+    },
     tiktokUnauthorized() {
       return this.isATiktokChannel && this.inbox.reauthorization_required;
     },
@@ -809,6 +820,29 @@ export default {
           :class="bannerMaxWidth"
           @start="openWhatsAppManualMigrationDialog"
         />
+        <Banner
+          v-if="showInstagramRestrictionSettingsBanner"
+          color="amber"
+          class="mx-6 mb-4 max-w-4xl"
+        >
+          <div class="flex items-start gap-3 text-start">
+            <Icon
+              icon="i-lucide-triangle-alert"
+              class="flex-shrink-0 size-4 mt-0.5"
+            />
+            <span>
+              {{ $t('INBOX_MGMT.ADD.INSTAGRAM.SETTINGS_RESTRICTED_WARNING') }}
+              <a
+                :href="metaRestrictionStatusUrl"
+                class="link underline"
+                rel="noopener noreferrer nofollow"
+                target="_blank"
+              >
+                {{ $t('INBOX_MGMT.ADD.INSTAGRAM.STATUS_LINK') }}
+              </a>
+            </span>
+          </div>
+        </Banner>
 
         <div
           v-if="selectedTabKey === 'inbox-settings'"

config/app.yml

@@ -1,5 +1,5 @@
 shared: &shared
-  version: '4.16.1'
+  version: '4.16.0'
 
 development:
   <<: *shared

config/llm.yml

@@ -143,20 +143,6 @@ features:
         gemini-3-pro,
       ]
     default: gpt-5.2
-  conversation_faq_matching:
-    models:
-      [
-        gpt-4.1-mini,
-        gpt-5-mini,
-        gpt-4.1,
-        gpt-5.1,
-        gpt-5.2,
-        claude-haiku-4.5,
-        claude-sonnet-4.5,
-        gemini-3-flash,
-        gemini-3-pro,
-      ]
-    default: gpt-4.1-mini
   pdf_faq_generation:
     models: [gpt-4.1-mini, gpt-5-mini, gpt-4.1, gpt-5.1, gpt-5.2]
     default: gpt-4.1-mini

config/locales/en.yml

@@ -626,7 +626,6 @@ en:
         label_suggestion: 'Label suggestion'
         document_faq_generation: 'Document FAQ generation'
         conversation_faq_generation: 'Conversation FAQ generation'
-        conversation_faq_matching: 'Conversation FAQ matching'
         help_center_article_generation: 'Help center article generation'
         onboarding_content_generation: 'Onboarding content generation'
         help_center_query_translation: 'Help center query translation'

enterprise/app/jobs/captain/conversation/response_builder_job.rb

@@ -7,16 +7,19 @@ class Captain::Conversation::ResponseBuilderJob < ApplicationJob
   retry_on ActiveStorage::FileNotFoundError, attempts: 3, wait: 2.seconds
   retry_on Faraday::BadRequestError, attempts: 3, wait: 2.seconds
 
-  def perform(conversation, assistant)
+  def perform(conversation, assistant, trigger_message_id = nil)
     @conversation = conversation
     @inbox = conversation.inbox
     @assistant = assistant
+    @trigger_message_id = trigger_message_id if captain_v2_enabled?
 
     return unless conversation_pending?
 
     Current.executed_by = @assistant
 
     if captain_v2_enabled?
+      return unless trigger_message_current?
+
       generate_response_with_v2
     else
       generate_and_process_response
@@ -45,11 +48,18 @@ class Captain::Conversation::ResponseBuilderJob < ApplicationJob
   end
 
   def generate_response_with_v2
-    runner_service = Captain::Assistant::AgentRunnerService.new(assistant: @assistant, conversation: @conversation)
+    runner_service = Captain::Assistant::AgentRunnerService.new(
+      assistant: @assistant,
+      conversation: @conversation,
+      trigger_message_id: @trigger_message_id
+    )
     message_history = Captain::Conversation::MessageHistoryBuilderService.new(conversation: @conversation).perform
     @response = runner_service.generate_response(message_history: message_history)
     @run_result = runner_service.last_run_result
 
+    return if runner_service.response_discarded?
+    return unless trigger_message_current?
+
     process_response
   end
 
@@ -77,16 +87,24 @@ class Captain::Conversation::ResponseBuilderJob < ApplicationJob
 
       process_v1_handoff
     elsif conversation_pending?
-      message = nil
-      ActiveRecord::Base.transaction do
-        message = create_messages
-        Rails.logger.info("[CAPTAIN][ResponseBuilderJob] Incrementing response usage for #{account.id}")
-        account.increment_response_usage
-      end
-      capture_assistant_session(result_message: message, credits_consumed: 1.0)
+      process_standard_response
     end
   end
 
+  def process_standard_response
+    message = nil
+    ActiveRecord::Base.transaction do
+      next unless trigger_message_current?
+
+      message = create_messages
+      Rails.logger.info("[CAPTAIN][ResponseBuilderJob] Incrementing response usage for #{account.id}")
+      account.increment_response_usage
+    end
+    return unless message
+
+    capture_assistant_session(result_message: message, credits_consumed: 1.0)
+  end
+
   def v1_handoff_requested?
     legacy_v1_handoff_token? || classifier_v1_handoff_requested?
   end
@@ -117,6 +135,8 @@ class Captain::Conversation::ResponseBuilderJob < ApplicationJob
   end
 
   def process_v2_handoff
+    return unless trigger_message_current?
+
     # HandoffTool already ran bot_handoff! + OOO inside the agent loop. Preserve
     # waiting_since so this message doesn't clear the timestamp it left in place.
     I18n.with_locale(@assistant.account.locale) do
@@ -152,7 +172,7 @@ class Captain::Conversation::ResponseBuilderJob < ApplicationJob
     @response ||= {}
     @response['action_source'] ||= 'error'
     @response['action_reason'] ||= error_action_reason(error)
-    process_v1_handoff if conversation_pending?
+    process_v1_handoff if conversation_pending? && (!captain_v2_enabled? || trigger_message_current?)
     true
   end
 
@@ -181,4 +201,14 @@ class Captain::Conversation::ResponseBuilderJob < ApplicationJob
     status = Conversation.uncached { Conversation.where(id: @conversation.id).pick(:status) }
     status == 'pending' || status == Conversation.statuses[:pending]
   end
+
+  def trigger_message_current?
+    return true if @trigger_message_id.blank?
+
+    latest_incoming_message_id = Conversation.uncached do
+      @conversation.messages.incoming.maximum(:id)
+    end
+
+    latest_incoming_message_id == @trigger_message_id
+  end
 end

enterprise/app/jobs/captain/llm/conversation_faq_job.rb

@@ -1,30 +0,0 @@
-class Captain::Llm::ConversationFaqJob < MutexApplicationJob
-  queue_as :low
-
-  LOCK_TIMEOUT = 10.minutes
-
-  retry_on_lock_conflict wait: 30.seconds, attempts: 30
-
-  def perform(conversation, assistant)
-    inbox = conversation.inbox
-
-    return unless conversation.resolved?
-    return unless inbox.captain_active?
-
-    return if assistant.config['feature_faq'].blank?
-
-    with_lock(lock_key(assistant, conversation), LOCK_TIMEOUT) do
-      Captain::Llm::ConversationFaqService.new(assistant, conversation).generate_suggestions
-    end
-  end
-
-  private
-
-  def lock_key(assistant, conversation)
-    format(
-      ::Redis::Alfred::CAPTAIN_CONVERSATION_FAQ_MUTEX,
-      assistant_id: assistant.id,
-      language: Captain::Llm::ConversationFaqService.language_for(conversation)
-    )
-  end
-end

enterprise/app/listeners/captain_listener.rb

@@ -8,6 +8,6 @@ class CaptainListener < BaseListener
     return unless conversation.inbox.captain_active?
 
     Captain::Llm::ContactNotesService.new(assistant, conversation).generate_and_update_notes if assistant.config['feature_memory'].present?
-    Captain::Llm::ConversationFaqJob.perform_later(conversation, assistant) if assistant.config['feature_faq'].present?
+    Captain::Llm::ConversationFaqService.new(assistant, conversation).generate_and_deduplicate if assistant.config['feature_faq'].present?
   end
 end

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

@@ -9,11 +9,12 @@ class Captain::Assistant::AgentRunnerService
 
   attr_reader :last_run_result
 
-  def initialize(assistant:, conversation: nil, callbacks: {}, source: nil)
+  def initialize(assistant:, conversation: nil, callbacks: {}, source: nil, trigger_message_id: nil)
     @assistant = assistant
     @conversation = conversation
     @callbacks = callbacks
     @source = source
+    @trigger_message_id = trigger_message_id
     @handoff_tool_called = false
   end
 
@@ -31,6 +32,10 @@ class Captain::Assistant::AgentRunnerService
     error_response(e.message)
   end
 
+  def response_discarded?
+    @response_discarded == true
+  end
+
   private
 
   def build_context(message_history)
@@ -151,10 +156,9 @@ class Captain::Assistant::AgentRunnerService
       track_handoff_usage(tool_name, handoff_tool_name, context_wrapper)
     end
 
-    if ChatwootApp.otel_enabled?
-      runner.on_run_complete do |_agent_name, _result, context_wrapper|
-        write_credits_used_metadata(context_wrapper)
-      end
+    runner.on_run_complete do |_agent_name, _result, context_wrapper|
+      @response_discarded = trigger_message_stale?
+      write_run_metadata(context_wrapper) if ChatwootApp.otel_enabled?
     end
     runner
   end
@@ -169,11 +173,22 @@ class Captain::Assistant::AgentRunnerService
     @handoff_tool_called = true
   end
 
-  def write_credits_used_metadata(context_wrapper)
+  def write_run_metadata(context_wrapper)
     root_span = context_wrapper&.context&.dig(:__otel_tracing, :root_span)
     return unless root_span
 
-    root_span.set_attribute(format(ATTR_LANGFUSE_METADATA, 'credit_used'), @handoff_tool_called ? 'false' : 'true')
+    root_span.set_attribute(format(ATTR_LANGFUSE_METADATA, 'discarded'), response_discarded?.to_s)
+    root_span.set_attribute(format(ATTR_LANGFUSE_METADATA, 'credit_used'), (!@handoff_tool_called && !response_discarded?).to_s)
+  end
+
+  def trigger_message_stale?
+    return false if @trigger_message_id.blank? || @conversation.blank?
+
+    latest_incoming_message_id = Conversation.uncached do
+      @conversation.messages.incoming.maximum(:id)
+    end
+
+    latest_incoming_message_id != @trigger_message_id
   end
 
   def runner

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

@@ -13,7 +13,8 @@ class Captain::Assistant::InstrumentationAttributeProvider
 
   def generation_attributes(_context_wrapper, _chat, message)
     {
-      format(ATTR_LANGFUSE_OBSERVATION_METADATA, 'generation_stage') => generation_stage(message)
+      format(ATTR_LANGFUSE_OBSERVATION_METADATA, 'generation_stage') => generation_stage(message),
+      format(ATTR_LANGFUSE_OBSERVATION_METADATA, 'discarded') => @service.send(:trigger_message_stale?).to_s
     }
   end
 

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

@@ -23,6 +23,7 @@ module Captain::Assistant::RunnerStateHelper
       timezone: @conversation&.inbox&.timezone.presence || 'UTC'
     }
     state[:source] = @source if @source.present?
+    state[:trigger_message_id] = @trigger_message_id if @trigger_message_id.present?
 
     build_conversation_state(state) if @conversation
     state

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

@@ -1,66 +0,0 @@
-class Captain::Llm::ConversationFaqContentService
-  def initialize(assistant, conversation)
-    @assistant = assistant
-    @conversation = conversation
-  end
-
-  def generate
-    [
-      'Business Context:',
-      JSON.pretty_generate(business_context),
-      "Conversation ID: ##{conversation.display_id}",
-      "Channel: #{conversation.inbox.channel.name}",
-      'Message History:',
-      conversation_messages
-    ].join("\n")
-  end
-
-  private
-
-  attr_reader :assistant, :conversation
-
-  def conversation_messages
-    messages = conversation
-               .messages
-               .where(message_type: %i[incoming outgoing], private: false)
-               .order(created_at: :asc)
-
-    return "No messages in this conversation\n" if messages.empty?
-
-    messages.filter_map { |message| format_message(message) }.join
-  end
-
-  def format_message(message)
-    return unless source_message?(message)
-
-    message_content = message.content_for_llm
-    return if message_content.blank?
-
-    sender = human_support_reply?(message) ? 'Support Agent' : 'User'
-    "#{sender}: #{message_content}\n"
-  end
-
-  def source_message?(message)
-    return true if message.incoming? && message.sender_type == 'Contact'
-
-    human_support_reply?(message)
-  end
-
-  def human_support_reply?(message)
-    return false unless message.outgoing?
-    return false if message.content_attributes['automation_rule_id'].present?
-    return false if message.additional_attributes['campaign_id'].present?
-
-    message.sender_type == 'User' || message.content_attributes['external_echo'].present?
-  end
-
-  def business_context
-    {
-      product_name: assistant.config['product_name'],
-      assistant_description: assistant.description,
-      instructions: assistant.config['instructions'],
-      response_guidelines: assistant.response_guidelines,
-      guardrails: assistant.guardrails
-    }.compact
-  end
-end

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

@@ -1,75 +0,0 @@
-class Captain::Llm::ConversationFaqPromptsService
-  class << self
-    def generator(language = 'english')
-      <<~PROMPT
-        You create high-quality FAQ candidates from resolved support conversations.
-        Only generate an FAQ when the conversation contains durable, reusable knowledge that would help many future customers.
-
-        ## Source rules
-        - The input starts with trusted business context. Use it to reject conversations about other businesses or topics, but never use it as the source of an FAQ answer.
-        - The conversation history contains only customer messages and human support agent messages.
-        - Base every FAQ strictly on information stated in the human support agent messages. Do not infer, generalize, or add external knowledge.
-        - A human support agent must state every fact used in the FAQ answer. Customer messages cannot supply missing answer facts.
-        - The human support agent must provide the final answer. If the agent only greets, asks clarifying questions, asks for contact details, promises to check, shares an attachment, or transfers the conversation, return: `{"faqs":[]}`.
-        - For each FAQ, identify the human support agent message or messages that together provide a complete public answer to the same question. Combine facts only across related agent messages; never combine separate questions or unrelated topics. If those messages do not provide a complete public answer, remove that FAQ.
-
-        ## Decision gate
-        Return `{"faqs":[]}` unless every generated FAQ can pass all of these checks:
-        1. The answer is fully stated by a human support agent, not by the customer.
-        2. The answer is a public, durable rule or procedure, not a private account action, manual review, troubleshooting session, quote, file, link, or follow-up.
-        3. The answer can be written without private identifiers, customer-specific facts, direct URLs, attachments, invoices, screenshots, or support-ticket steps.
-        4. The question would still make sense in a help center if the original conversation, customer, and agent did not exist.
-        Do not rescue a rejected conversation by rewriting it as a generic support question.
-
-        ## Return no FAQ for
-        - Spam, scams, advertisements, SEO/link-building pitches, adult/gambling/financial promotions, gibberish, abusive content, or conversations unrelated to the business being supported.
-        - Account-specific, order-specific, payment-specific, subscription-specific, login/access, verification, delivery, certificate, or troubleshooting issues, even if they could be rewritten as a general support question.
-        - Conversations that mainly hand off to a human, ask the customer to wait, request private identifiers or contact details, collect screenshots, attachments, or documents, or tell the customer to contact support for case review.
-        - Temporary workarounds, one-off exceptions, unclear answers, unresolved problems, wrong-service conversations, complaints, greetings, or abandoned conversations.
-        - Internal support workflow details, chat session rules, escalation mechanics, ticket-routing instructions, or "someone will get back to you" messages.
-        - Answers that are just a direct/private link, attachment, file, invoice, one-off quote or estimate, account-specific URL, or instructions to open a support ticket.
-        - Questions whose useful answer is "contact support", "wait for the team", "share your details", "we will check", or "this needs manual review".
-        - Questions about whether support can help with a private issue, third-party service, transaction, payment, delivery, or account problem.
-        - Pricing, policy, availability, roadmap, deadline, or legal claims unless the human support agent gives a clear and stable answer in the conversation.
-        - Questions already answered only by asking the customer for more information.
-
-        ## FAQ quality rules
-        - Prefer returning no FAQ over a weak or narrow FAQ.
-        - A good candidate teaches a generally reusable product, service, policy, setup, or process rule that another customer could use without contacting support.
-        - Generate at most one FAQ unless the human agent clearly answered multiple distinct, reusable questions.
-        - Do not create duplicate or overlapping FAQs in the same response.
-        - Questions must be general enough for a help center, not personalized to the current customer.
-        - Remove customer names, order numbers, invoice numbers, IDs, private URLs, phone numbers, emails, screenshots, attachments, and other personal or transaction-specific details.
-        - Answers must be complete, self-contained, and supported by the human agent's messages.
-
-        ## Examples
-        - Customer mentions a price or procedure, then the human agent only greets or says they will check: return `{"faqs":[]}`.
-        - Human agent shares only a private link, file, invoice, quote, screenshot, or attachment: return `{"faqs":[]}`.
-        - Human agent clearly states a public rule, such as which purchases are allowed for a program or service: generate one general FAQ.
-
-        Generate the FAQs only in the #{language}, use no other language.
-        If no suitable reusable FAQ is available, return: `{"faqs":[]}`.
-
-        Return only valid JSON in this exact structure:
-        ```json
-        { "faqs": [ { "question": "", "answer": "" } ] }
-        ```
-      PROMPT
-    end
-
-    def same_faq
-      <<~PROMPT
-        Decide whether the new FAQ and existing FAQ are the same.
-
-        Return `same_faq` as true only when both questions ask the same thing and both answers give the same guidance.
-        Wording, grammar, level of detail, and examples may differ. Return false when either FAQ adds, removes, contradicts, or changes a condition,
-        policy, procedure, audience, product, plan, time frame, or outcome. Related FAQs are not the same FAQ. When uncertain, return false.
-
-        Return only valid JSON in this exact structure:
-        ```json
-        { "same_faq": true }
-        ```
-      PROMPT
-    end
-  end
-end

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

@@ -2,201 +2,166 @@ class Captain::Llm::ConversationFaqService < Llm::BaseAiService
   include Integrations::LlmInstrumentation
 
   DISTANCE_THRESHOLD = 0.3
-  MATCH_LIMIT = 5
   LLM_FEATURE = 'conversation_faq_generation'.freeze
 
-  def self.language_for(conversation)
-    language = conversation.language.presence || conversation.account.locale.presence || I18n.default_locale.to_s
-    normalize_language(language)
-  end
-
-  def self.normalize_language(language)
-    language.to_s.tr('-', '_').split('_').first.downcase
-  end
-
-  private_class_method :normalize_language
-
   def initialize(assistant, conversation)
     super(feature: LLM_FEATURE, account: conversation.account, fallback_model: Llm::Models.default_model_for(LLM_FEATURE))
     @assistant = assistant
     @conversation = conversation
-    @content = Captain::Llm::ConversationFaqContentService.new(assistant, conversation).generate
-    @embedding_service = Captain::Llm::EmbeddingService.new(account_id: conversation.account_id)
+    @content = conversation_faq_content
   end
 
-  def generate_suggestions
+  # Generates and deduplicates FAQs from conversation content
+  # Skips processing if there was no human interaction
+  def generate_and_deduplicate
     return [] if no_human_interaction?
 
-    generate.map { |faq| route_candidate(faq) }
+    new_faqs = generate
+    return [] if new_faqs.empty?
+
+    duplicate_faqs, unique_faqs = find_and_separate_duplicates(new_faqs)
+    save_new_faqs(unique_faqs)
+    log_duplicate_faqs(duplicate_faqs) if Rails.env.development?
   end
 
   private
 
-  attr_reader :content, :conversation, :assistant, :embedding_service
+  attr_reader :content, :conversation, :assistant
+
+  def conversation_faq_content
+    [
+      "Conversation ID: ##{conversation.display_id}",
+      "Channel: #{conversation.inbox.channel.name}",
+      'Message History:',
+      conversation_faq_messages
+    ].join("\n")
+  end
+
+  def conversation_faq_messages
+    messages = conversation
+               .messages
+               .where(message_type: %i[incoming outgoing], private: false)
+               .order(created_at: :asc)
+
+    return "No messages in this conversation\n" if messages.empty?
+
+    messages.filter_map { |message| format_conversation_faq_message(message) }.join
+  end
+
+  def format_conversation_faq_message(message)
+    return unless faq_source_message?(message)
+
+    content = message.content_for_llm
+    return if content.blank?
+
+    sender = human_support_reply?(message) ? 'Support Agent' : 'User'
+    "#{sender}: #{content}\n"
+  end
+
+  def faq_source_message?(message)
+    return true if message.incoming? && message.sender_type == 'Contact'
+
+    human_support_reply?(message)
+  end
+
+  def human_support_reply?(message)
+    return false unless message.outgoing?
+    return false if message.content_attributes['automation_rule_id'].present?
+    return false if message.additional_attributes['campaign_id'].present?
+
+    message.sender_type == 'User' || message.content_attributes['external_echo'].present?
+  end
 
   def no_human_interaction?
     conversation.first_reply_created_at.nil?
   end
 
-  def route_candidate(faq)
-    embedding = embedding_service.get_embedding(candidate_text(faq))
+  def find_and_separate_duplicates(faqs)
+    duplicate_faqs = []
+    unique_faqs = []
 
-    return discard_observation(faq) if matching_record(approved_faqs, faq, embedding)
-    return discard_observation(faq) if matching_record(dismissed_suggestions_for_language, faq, embedding)
+    faqs.each do |faq|
+      combined_text = "#{faq['question']}: #{faq['answer']}"
+      embedding = Captain::Llm::EmbeddingService.new(account_id: @conversation.account_id).get_embedding(combined_text)
+      similar_faqs = find_similar_faqs(embedding)
 
-    suggestion = matching_record(open_suggestions_for_language, faq, embedding)
-    suggestion ||= assistant.faq_suggestions.create!(
-      question: faq.fetch('question'),
-      answer: faq.fetch('answer'),
-      embedding: embedding,
-      language: faq_language
-    )
-
-    attach_observation(suggestion, faq)
-  end
-
-  def matching_record(relation, faq, embedding)
-    likely_matches(relation, embedding).find { |record| same_faq?(faq, record) }
-  end
-
-  def likely_matches(relation, embedding)
-    return [] unless relation.exists?
-
-    ApplicationRecord.transaction do
-      # Force an exact search because IVFFlat can miss matches after relation filters.
-      # SET LOCAL keeps the planner change scoped to this transaction.
-      ApplicationRecord.connection.execute('SET LOCAL enable_indexscan = off')
-      relation
-        .nearest_neighbors(:embedding, embedding, distance: 'cosine')
-        .limit(MATCH_LIMIT)
-        .select { |record| record.neighbor_distance < DISTANCE_THRESHOLD }
-    end
-  end
-
-  def same_faq?(candidate, existing_record)
-    comparison = {
-      candidate: candidate.slice('question', 'answer'),
-      existing: { question: existing_record.question, answer: existing_record.answer }
-    }
-    prompt = Captain::Llm::ConversationFaqPromptsService.same_faq
-    faq_match_model = Llm::FeatureRouter.resolve(feature: 'conversation_faq_matching', account: conversation.account)[:model]
-    response = instrument_llm_call(match_instrumentation_params(prompt, comparison, faq_match_model)) do
-      chat(model: faq_match_model)
-        .with_params(response_format: { type: 'json_object' })
-        .with_instructions(prompt)
-        .ask(comparison.to_json)
+      if similar_faqs.any?
+        duplicate_faqs << { faq: faq, similar_faqs: similar_faqs }
+      else
+        unique_faqs << faq
+      end
     end
 
-    same_faq = JSON.parse(sanitize_json_response(response.content)).fetch('same_faq')
-    raise TypeError, 'same_faq must be a boolean' unless [true, false].include?(same_faq)
-
-    same_faq
-  rescue JSON::ParserError, KeyError, TypeError, RubyLLM::Error => e
-    Rails.logger.error "FAQ match failed: #{e.message}"
-    raise
+    [duplicate_faqs, unique_faqs]
   end
 
-  def attach_observation(suggestion, faq)
-    suggestion.with_lock do
-      existing_observation = suggestion.observations.find_by(conversation: conversation)
-      next existing_observation if existing_observation
+  def find_similar_faqs(embedding)
+    similar_faqs = assistant
+                   .responses
+                   .nearest_neighbors(:embedding, embedding, distance: 'cosine')
+    Rails.logger.debug(similar_faqs.map { |faq| [faq.question, faq.neighbor_distance] })
+    similar_faqs.select { |record| record.neighbor_distance < DISTANCE_THRESHOLD }
+  end
 
-      observation = suggestion.observations.create!(
-        conversation: conversation,
-        generated_question: faq.fetch('question'),
-        generated_answer: faq.fetch('answer'),
-        language: faq_language,
-        status: :attached
+  def save_new_faqs(faqs)
+    faqs.map do |faq|
+      assistant.responses.create!(
+        question: faq['question'],
+        answer: faq['answer'],
+        status: 'pending',
+        documentable: conversation
       )
-      suggestion.update!(source_count: suggestion.source_count + 1)
-      observation
     end
   end
 
-  def discard_observation(faq)
-    Captain::FaqObservation.find_or_create_by!(
-      conversation: conversation,
-      generated_question: faq.fetch('question'),
-      generated_answer: faq.fetch('answer'),
-      language: faq_language,
-      status: :discarded
-    )
-  end
+  def log_duplicate_faqs(duplicate_faqs)
+    return if duplicate_faqs.empty?
 
-  def open_suggestions_for_language
-    assistant.faq_suggestions.where(account_id: conversation.account_id).open.by_language(faq_language)
-  end
-
-  def dismissed_suggestions_for_language
-    assistant.faq_suggestions.where(account_id: conversation.account_id).dismissed.by_language(faq_language)
-  end
-
-  def approved_faqs
-    assistant.responses.approved
-  end
-
-  def candidate_text(faq)
-    "#{faq.fetch('question')}: #{faq.fetch('answer')}"
+    Rails.logger.info "Found #{duplicate_faqs.length} duplicate FAQs:"
+    duplicate_faqs.each do |duplicate|
+      Rails.logger.info(
+        "Q: #{duplicate[:faq]['question']}\n" \
+        "A: #{duplicate[:faq]['answer']}\n\n" \
+        "Similar existing FAQs: #{duplicate[:similar_faqs].map { |f| "Q: #{f.question} A: #{f.answer}" }.join(', ')}"
+      )
+    end
   end
 
   def generate
-    response = instrument_llm_call(generation_instrumentation_params) do
+    response = instrument_llm_call(instrumentation_params) do
       chat
         .with_params(response_format: { type: 'json_object' })
         .with_instructions(system_prompt)
-        .ask(content)
+        .ask(@content)
     end
-    parse_generation_response(response.content)
+    parse_response(response.content)
   rescue RubyLLM::Error => e
     Rails.logger.error "LLM API Error: #{e.message}"
     []
   end
 
-  def generation_instrumentation_params
+  def instrumentation_params
     {
       span_name: 'llm.captain.conversation_faq',
-      model: model,
-      temperature: temperature,
-      account_id: conversation.account_id,
-      conversation_id: conversation.display_id,
+      model: @model,
+      temperature: @temperature,
+      account_id: @conversation.account_id,
+      conversation_id: @conversation.display_id,
       feature_name: 'conversation_faq',
       messages: [
         { role: 'system', content: system_prompt },
-        { role: 'user', content: content }
+        { role: 'user', content: @content }
       ],
-      metadata: { assistant_id: assistant.id, language: faq_language }
-    }
-  end
-
-  def match_instrumentation_params(prompt, comparison, faq_match_model)
-    {
-      span_name: 'llm.captain.faq_match',
-      model: faq_match_model,
-      temperature: temperature,
-      account_id: conversation.account_id,
-      conversation_id: conversation.display_id,
-      feature_name: 'conversation_faq_match',
-      messages: [
-        { role: 'system', content: prompt },
-        { role: 'user', content: comparison.to_json }
-      ],
-      metadata: { assistant_id: assistant.id, language: faq_language }
+      metadata: { assistant_id: @assistant.id }
     }
   end
 
   def system_prompt
-    Captain::Llm::ConversationFaqPromptsService.generator(language_name(faq_language))
+    account_language = @conversation.account.locale_english_name
+    Captain::Llm::SystemPromptsService.conversation_faq_generator(account_language)
   end
 
-  def faq_language
-    @faq_language ||= self.class.language_for(conversation)
-  end
-
-  def language_name(language)
-    ISO_639.find(language)&.english_name&.downcase || 'english'
-  end
-
-  def parse_generation_response(response)
+  def parse_response(response)
     return [] if response.nil?
 
     JSON.parse(sanitize_json_response(response)).fetch('faqs', [])

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

@@ -51,6 +51,62 @@ class Captain::Llm::SystemPromptsService
       PROMPT
     end
 
+    def conversation_faq_generator(language = 'english')
+      <<~SYSTEM_PROMPT_MESSAGE
+        You create high-quality FAQ candidates from resolved support conversations.
+        Only generate an FAQ when the conversation contains durable, reusable knowledge that would help many future customers.
+
+        ## Source rules
+        - The conversation history contains only customer messages and human support agent messages.
+        - Base every FAQ strictly on information stated in the human support agent messages. Do not infer, generalize, or add external knowledge.
+        - A human support agent must state every fact used in the FAQ answer. Customer messages cannot supply missing answer facts.
+        - The human support agent must provide the final answer. If the agent only greets, asks clarifying questions, asks for contact details, promises to check, shares an attachment, or transfers the conversation, return: `{"faqs":[]}`.
+        - For each FAQ, first identify the exact human support agent message that fully answers it. If no single human agent message gives a complete public answer, remove that FAQ.
+
+        ## Decision gate
+        Return `{"faqs":[]}` unless every generated FAQ can pass all of these checks:
+        1. The answer is fully stated by a human support agent, not by the customer.
+        2. The answer is a public, durable rule or procedure, not a private account action, manual review, troubleshooting session, quote, file, link, or follow-up.
+        3. The answer can be written without private identifiers, customer-specific facts, direct URLs, attachments, invoices, screenshots, or support-ticket steps.
+        4. The question would still make sense in a help center if the original conversation, customer, and agent did not exist.
+        Do not rescue a rejected conversation by rewriting it as a generic support question.
+
+        ## Return no FAQ for
+        - Spam, scams, advertisements, SEO/link-building pitches, adult/gambling/financial promotions, gibberish, abusive content, or conversations unrelated to the business being supported.
+        - Account-specific, order-specific, payment-specific, subscription-specific, login/access, verification, delivery, certificate, or troubleshooting issues, even if they could be rewritten as a general support question.
+        - Conversations that mainly hand off to a human, ask the customer to wait, request private identifiers or contact details, collect screenshots, attachments, or documents, or tell the customer to contact support for case review.
+        - Temporary workarounds, one-off exceptions, unclear answers, unresolved problems, wrong-service conversations, complaints, greetings, or abandoned conversations.
+        - Internal support workflow details, chat session rules, escalation mechanics, ticket-routing instructions, or "someone will get back to you" messages.
+        - Answers that are just a direct/private link, attachment, file, invoice, one-off quote or estimate, account-specific URL, or instructions to open a support ticket.
+        - Questions whose useful answer is "contact support", "wait for the team", "share your details", "we will check", or "this needs manual review".
+        - Questions about whether support can help with a private issue, third-party service, transaction, payment, delivery, or account problem.
+        - Pricing, policy, availability, roadmap, deadline, or legal claims unless the human support agent gives a clear and stable answer in the conversation.
+        - Questions already answered only by asking the customer for more information.
+
+        ## FAQ quality rules
+        - Prefer returning no FAQ over a weak or narrow FAQ.
+        - A good candidate teaches a generally reusable product, service, policy, setup, or process rule that another customer could use without contacting support.
+        - Generate at most one FAQ unless the human agent clearly answered multiple distinct, reusable questions.
+        - Do not create duplicate or overlapping FAQs in the same response.
+        - Questions must be general enough for a help center, not personalized to the current customer.
+        - Remove customer names, order numbers, invoice numbers, IDs, private URLs, phone numbers, emails, screenshots, attachments, and other personal or transaction-specific details.
+        - Answers must be complete, self-contained, and supported by the human agent's messages.
+
+        ## Examples
+        - Customer mentions a price or procedure, then the human agent only greets or says they will check: return `{"faqs":[]}`.
+        - Human agent shares only a private link, file, invoice, quote, screenshot, or attachment: return `{"faqs":[]}`.
+        - Human agent clearly states a public rule, such as which purchases are allowed for a program or service: generate one general FAQ.
+
+        Generate the FAQs only in the #{language}, use no other language.
+        If no suitable reusable FAQ is available, return: `{"faqs":[]}`.
+
+        Return only valid JSON in this exact structure:
+        ```json
+        { "faqs": [ { "question": "", "answer": "" } ] }
+        ```
+      SYSTEM_PROMPT_MESSAGE
+    end
+
     def notes_generator(language = 'english')
       <<~SYSTEM_PROMPT_MESSAGE
         You are a note taker looking to convert the conversation with a contact into actionable notes for the CRM.

enterprise/app/services/enterprise/message_templates/hook_execution_service.rb

@@ -31,6 +31,7 @@ module Enterprise::MessageTemplates::HookExecutionService
 
   def schedule_captain_response
     job_args = [conversation, conversation.inbox.captain_assistant]
+    job_args << message.id if conversation.account.feature_enabled?('captain_integration_v2')
 
     if message.attachments.blank?
       Captain::Conversation::ResponseBuilderJob.perform_later(*job_args)

enterprise/lib/captain/tools/handoff_tool.rb

@@ -5,6 +5,7 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
   def perform(tool_context, reason: nil)
     conversation = find_conversation(tool_context.state)
     return 'Conversation not found' unless conversation
+    return 'Handoff skipped because a newer customer message arrived' unless trigger_message_current?(tool_context.state, conversation)
 
     # Log the handoff with reason
     log_tool_usage('tool_handoff', {
@@ -23,6 +24,17 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
 
   private
 
+  def trigger_message_current?(state, conversation)
+    trigger_message_id = state&.dig(:trigger_message_id)
+    return true if trigger_message_id.blank?
+
+    latest_incoming_message_id = Conversation.uncached do
+      conversation.messages.incoming.maximum(:id)
+    end
+
+    latest_incoming_message_id == trigger_message_id
+  end
+
   def trigger_handoff(tool_context, conversation, reason)
     # post the reason as a private note
     note = conversation.messages.create!(

lib/redis/redis_keys.rb

@@ -89,7 +89,6 @@ module Redis::RedisKeys
   WHATSAPP_MESSAGE_MUTEX = 'WHATSAPP_MESSAGE_CREATE_LOCK::%<inbox_id>s::%<sender_id>s'.freeze
   CRM_PROCESS_MUTEX = 'CRM_PROCESS_MUTEX::%<hook_id>s'.freeze
   CAPTAIN_DOCUMENT_SYNC_MUTEX = 'CAPTAIN_DOCUMENT_SYNC_LOCK::%<document_id>s'.freeze
-  CAPTAIN_CONVERSATION_FAQ_MUTEX = 'CAPTAIN_CONVERSATION_FAQ_LOCK::%<assistant_id>s::%<language>s'.freeze
 
   ## Auto Assignment Keys
   # Track conversation assignments to agents for rate limiting

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatwoot/chatwoot",
-  "version": "4.16.1",
+  "version": "4.16.0",
   "license": "MIT",
   "scripts": {
     "eslint": "eslint app/**/*.{js,vue}",

spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb

@@ -13,6 +13,7 @@ RSpec.describe Captain::Conversation::ResponseBuilderJob, type: :job do
     let(:mock_action_classifier_service) { instance_double(Captain::Llm::AssistantActionClassifierService) }
     let(:mock_false_promise_service) { instance_double(Captain::Llm::AssistantFalsePromiseService) }
     let(:assistant_model) { Llm::Models.default_model_for('assistant') }
+    let(:trigger_message) { conversation.messages.find_by!(content: 'Hello') }
 
     before do
       create(:message, conversation: conversation, content: 'Hello', message_type: :incoming)
@@ -23,6 +24,7 @@ RSpec.describe Captain::Conversation::ResponseBuilderJob, type: :job do
       allow(Captain::Assistant::AgentRunnerService).to receive(:new).and_return(mock_agent_runner_service)
       allow(mock_agent_runner_service).to receive(:generate_response).and_return({ 'response' => 'Hey, welcome to Captain V2' })
       allow(mock_agent_runner_service).to receive(:last_run_result).and_return(nil)
+      allow(mock_agent_runner_service).to receive(:response_discarded?).and_return(false)
       allow(Captain::Llm::AssistantActionClassifierService).to receive(:new).and_return(mock_action_classifier_service)
       allow(mock_action_classifier_service).to receive(:classify).and_return({ 'action' => 'continue' })
       allow(Captain::Llm::AssistantFalsePromiseService).to receive(:new).and_return(mock_false_promise_service)
@@ -358,14 +360,28 @@ RSpec.describe Captain::Conversation::ResponseBuilderJob, type: :job do
       it 'uses Captain::Assistant::AgentRunnerService' do
         expect(Captain::Assistant::AgentRunnerService).to receive(:new).with(
           assistant: assistant,
-          conversation: conversation
+          conversation: conversation,
+          trigger_message_id: trigger_message.id
         )
         expect(Captain::Llm::AssistantChatService).not_to receive(:new)
 
-        described_class.perform_now(conversation, assistant)
+        described_class.perform_now(conversation, assistant, trigger_message.id)
         expect(conversation.messages.last.content).to eq('Hey, welcome to Captain V2')
       end
 
+      it 'discards a response when a newer message arrives during generation' do
+        allow(mock_agent_runner_service).to receive(:generate_response) do
+          create(:message, conversation: conversation, content: 'New context', message_type: :incoming)
+          { 'response' => 'Stale response', 'handoff_tool_called' => false }
+        end
+        allow(mock_agent_runner_service).to receive(:response_discarded?).and_return(true)
+
+        described_class.perform_now(conversation, assistant, trigger_message.id)
+
+        expect(conversation.messages.outgoing.count).to eq(0)
+        expect(account.reload.usage_limits[:captain][:responses][:consumed]).to eq(0)
+      end
+
       it 'passes message history with resolution markers to agent runner service' do
         same_second = Time.current.change(usec: 0)
         conversation.messages.find_by!(content: 'Hello').update!(created_at: same_second, updated_at: same_second)

spec/enterprise/jobs/captain/llm/conversation_faq_job_spec.rb

@@ -1,57 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Captain::Llm::ConversationFaqJob, type: :job do
-  let(:account) { create(:account) }
-  let(:inbox) { create(:inbox, account: account) }
-  let(:assistant) { create(:captain_assistant, account: account, config: { feature_faq: true }) }
-  let(:conversation) { create(:conversation, account: account, inbox: inbox, first_reply_created_at: Time.zone.now) }
-  let(:faq_service) { instance_double(Captain::Llm::ConversationFaqService, generate_suggestions: []) }
-  let(:lock_manager) { instance_double(Redis::LockManager, lock: true, unlock: true) }
-  let(:lock_key) { "CAPTAIN_CONVERSATION_FAQ_LOCK::#{assistant.id}::en" }
-
-  before do
-    create(:captain_inbox, inbox: inbox, captain_assistant: assistant)
-    conversation.update!(status: :resolved)
-    allow(Redis::LockManager).to receive(:new).and_return(lock_manager)
-    allow(Captain::Llm::ConversationFaqService).to receive(:new).and_return(faq_service)
-  end
-
-  describe '#perform' do
-    it 'uses the assistant captured when the job was enqueued' do
-      replacement_assistant = create(:captain_assistant, account: account, config: { feature_faq: true })
-      inbox.captain_inbox.update!(captain_assistant: replacement_assistant)
-
-      expect(inbox.reload.captain_assistant).to eq(replacement_assistant)
-      expect(Captain::Llm::ConversationFaqService).to receive(:new)
-        .with(assistant, conversation)
-        .and_return(faq_service)
-      expect(faq_service).to receive(:generate_suggestions)
-
-      described_class.perform_now(conversation, assistant)
-    end
-
-    it 'locks FAQ grouping for the assistant and normalized language' do
-      conversation.update!(additional_attributes: { conversation_language: 'pt-BR' })
-      expected_key = "CAPTAIN_CONVERSATION_FAQ_LOCK::#{assistant.id}::pt"
-
-      expect(lock_manager).to receive(:lock).with(expected_key, described_class::LOCK_TIMEOUT).and_return(true)
-      expect(lock_manager).to receive(:unlock).with(expected_key)
-
-      described_class.perform_now(conversation, assistant)
-    end
-
-    context 'when another job holds the grouping lock' do
-      before do
-        allow(lock_manager).to receive(:lock).with(lock_key, described_class::LOCK_TIMEOUT).and_return(false)
-      end
-
-      it 'does not generate suggestions concurrently' do
-        expect(Captain::Llm::ConversationFaqService).not_to receive(:new)
-
-        expect do
-          described_class.new.perform(conversation, assistant)
-        end.to raise_error(MutexApplicationJob::LockAcquisitionError)
-      end
-    end
-  end
-end

spec/enterprise/lib/captain/tools/handoff_tool_spec.rb

@@ -28,6 +28,37 @@ RSpec.describe Captain::Tools::HandoffTool, type: :model do
 
   describe '#perform' do
     context 'when conversation exists' do
+      context 'with a trigger message id' do
+        let(:trigger_message) do
+          create(:message, conversation: conversation, account: account, inbox: inbox, message_type: :incoming, created_at: same_second)
+        end
+        let(:same_second) { Time.current.change(usec: 0) }
+        let(:tool_context) do
+          Struct.new(:state).new({ conversation: { id: conversation.id }, trigger_message_id: trigger_message.id })
+        end
+
+        it 'hands off when the trigger message is still the latest message' do
+          trigger_message
+
+          expect do
+            result = tool.perform(tool_context, reason: 'Customer needs specialized support')
+            expect(result).to include('Conversation handed off')
+          end.to change(Message, :count).by(1)
+        end
+
+        it 'skips the handoff when a newer message has arrived' do
+          trigger_message
+          conversation.update!(status: :pending)
+          create(:message, conversation: conversation, account: account, inbox: inbox, message_type: :incoming, created_at: same_second)
+
+          expect do
+            result = tool.perform(tool_context, reason: 'Customer needs specialized support')
+            expect(result).to eq('Handoff skipped because a newer customer message arrived')
+          end.not_to change(Message, :count)
+          expect(conversation.reload.status).to eq('pending')
+        end
+      end
+
       context 'with reason provided' do
         it 'creates a private note with reason and hands off conversation' do
           reason = 'Customer needs specialized support'

spec/enterprise/listeners/captain_listener_spec.rb

@@ -29,7 +29,7 @@ describe CaptainListener do
           .to receive(:new)
           .with(assistant, conversation)
           .and_return(instance_double(Captain::Llm::ContactNotesService, generate_and_update_notes: nil))
-        expect(Captain::Llm::ConversationFaqJob).not_to receive(:perform_later)
+        expect(Captain::Llm::ConversationFaqService).not_to receive(:new)
 
         listener.conversation_resolved(event)
       end
@@ -42,8 +42,11 @@ describe CaptainListener do
         assistant.save!
       end
 
-      it 'enqueues FAQ suggestion generation' do
-        expect(Captain::Llm::ConversationFaqJob).to receive(:perform_later).with(conversation, assistant)
+      it 'generates and deduplicates FAQs' do
+        expect(Captain::Llm::ConversationFaqService)
+          .to receive(:new)
+          .with(assistant, conversation)
+          .and_return(instance_double(Captain::Llm::ConversationFaqService, generate_and_deduplicate: false))
         expect(Captain::Llm::ContactNotesService).not_to receive(:new)
 
         listener.conversation_resolved(event)

spec/enterprise/services/captain/assistant/agent_runner_service_spec.rb

@@ -52,6 +52,12 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
 
       expect(service.instance_variable_get(:@callbacks)).to eq(callbacks)
     end
+
+    it 'accepts the trigger message id' do
+      service = described_class.new(assistant: assistant, conversation: conversation, trigger_message_id: 123)
+
+      expect(service.instance_variable_get(:@trigger_message_id)).to eq(123)
+    end
   end
 
   describe '#generate_response' do
@@ -99,6 +105,18 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
       service.generate_response(message_history: message_history)
     end
 
+    it 'adds the trigger message id to the runner state' do
+      service = described_class.new(assistant: assistant, conversation: conversation, trigger_message_id: 123)
+
+      expect(mock_runner).to receive(:run).with(
+        'I need help with my account',
+        context: hash_including(state: hash_including(trigger_message_id: 123)),
+        max_turns: 10
+      )
+
+      service.generate_response(message_history: message_history)
+    end
+
     context 'when the latest user message is multimodal' do
       let(:multimodal_message_history) do
         [
@@ -446,6 +464,7 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
       attributes = provider.generation_attributes(nil, nil, message)
 
       expect(attributes['langfuse.observation.metadata.generation_stage']).to eq('final_response')
+      expect(attributes['langfuse.observation.metadata.discarded']).to eq('false')
     end
 
     it 'marks tool call generations separately from final responses' do
@@ -456,6 +475,18 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
 
       expect(attributes['langfuse.observation.metadata.generation_stage']).to eq('tool_call')
     end
+
+    it 'marks a generation as discarded when a newer message has arrived' do
+      trigger_message = create(:message, conversation: conversation, message_type: :incoming)
+      runner_service = described_class.new(assistant: assistant, conversation: conversation, trigger_message_id: trigger_message.id)
+      attribute_provider = Captain::Assistant::InstrumentationAttributeProvider.new(runner_service)
+      message = instance_double(RubyLLM::Message, tool_calls: {})
+      create(:message, conversation: conversation, message_type: :incoming)
+
+      attributes = attribute_provider.generation_attributes(nil, nil, message)
+
+      expect(attributes['langfuse.observation.metadata.discarded']).to eq('true')
+    end
   end
 
   describe '#build_state' do
@@ -574,6 +605,7 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
 
       tool_complete_callback.call(Captain::Tools::HandoffTool.new(assistant).name, 'ok', context_wrapper)
 
+      expect(root_span).to receive(:set_attribute).with('langfuse.trace.metadata.discarded', 'false')
       expect(root_span).to receive(:set_attribute).with('langfuse.trace.metadata.credit_used', 'false')
       run_complete_callback.call('assistant', nil, context_wrapper)
     end
@@ -588,6 +620,7 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
         tool_complete_callback = block
         runner
       end
+      allow(runner).to receive(:on_run_complete).and_return(runner)
 
       service.send(:add_usage_metadata_callback, runner)
 
@@ -599,15 +632,24 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
       expect(context_wrapper.context[:captain_v2_handoff_tool_called]).to be true
     end
 
-    it 'does not register OTEL run callback when OTEL is disabled' do
-      service = described_class.new(assistant: assistant, conversation: conversation)
+    it 'tracks discarded responses when OTEL is disabled' do
+      trigger_message = create(:message, conversation: conversation, message_type: :incoming)
+      service = described_class.new(assistant: assistant, conversation: conversation, trigger_message_id: trigger_message.id)
       runner = instance_double(Agents::AgentRunner)
+      run_complete_callback = nil
 
       allow(ChatwootApp).to receive(:otel_enabled?).and_return(false)
       allow(runner).to receive(:on_tool_complete).and_return(runner)
-      expect(runner).not_to receive(:on_run_complete)
+      allow(runner).to receive(:on_run_complete) do |&block|
+        run_complete_callback = block
+        runner
+      end
 
       service.send(:add_usage_metadata_callback, runner)
+      create(:message, conversation: conversation, message_type: :incoming)
+      run_complete_callback.call('assistant', nil, Struct.new(:context).new({}))
+
+      expect(service.response_discarded?).to be true
     end
 
     it 'sets credit_used=true when handoff tool is not used' do
@@ -629,9 +671,38 @@ RSpec.describe Captain::Assistant::AgentRunnerService do
 
       service.send(:add_usage_metadata_callback, runner)
 
+      expect(root_span).to receive(:set_attribute).with('langfuse.trace.metadata.discarded', 'false')
       expect(root_span).to receive(:set_attribute).with('langfuse.trace.metadata.credit_used', 'true')
       run_complete_callback.call('assistant', nil, context_wrapper)
     end
+
+    it 'marks the trace discarded and does not use credit when a newer message arrived' do
+      trigger_message = create(:message, conversation: conversation, message_type: :incoming)
+      service = described_class.new(assistant: assistant, conversation: conversation, trigger_message_id: trigger_message.id)
+      runner = instance_double(Agents::AgentRunner)
+      run_complete_callback = nil
+      span_class = Class.new do
+        def set_attribute(*); end
+      end
+      root_span = instance_double(span_class)
+      context_wrapper = Struct.new(:context).new({ __otel_tracing: { root_span: root_span } })
+
+      allow(ChatwootApp).to receive(:otel_enabled?).and_return(true)
+      allow(runner).to receive(:on_tool_complete).and_return(runner)
+      allow(runner).to receive(:on_run_complete) do |&block|
+        run_complete_callback = block
+        runner
+      end
+
+      service.send(:add_usage_metadata_callback, runner)
+      create(:message, conversation: conversation, message_type: :incoming)
+
+      expect(root_span).to receive(:set_attribute).with('langfuse.trace.metadata.discarded', 'true')
+      expect(root_span).to receive(:set_attribute).with('langfuse.trace.metadata.credit_used', 'false')
+      run_complete_callback.call('assistant', nil, context_wrapper)
+
+      expect(service.response_discarded?).to be true
+    end
   end
 
   describe 'constants' do

spec/enterprise/services/captain/llm/conversation_faq_prompts_service_spec.rb

@@ -1,13 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Captain::Llm::ConversationFaqPromptsService do
-  describe '.generator' do
-    it 'allows a complete FAQ answer to use several related agent messages' do
-      prompt = described_class.generator
-
-      expect(prompt).to include('message or messages that together provide a complete public answer')
-      expect(prompt).to include('Combine facts only across related agent messages')
-      expect(prompt).not_to include('no single human agent message')
-    end
-  end
-end

spec/enterprise/services/captain/llm/conversation_faq_service_spec.rb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 RSpec.describe Captain::Llm::ConversationFaqService do
   let(:captain_assistant) { create(:captain_assistant) }
-  let(:conversation) { create(:conversation, account: captain_assistant.account, first_reply_created_at: Time.zone.now) }
+  let(:conversation) { create(:conversation, first_reply_created_at: Time.zone.now) }
   let(:service) { described_class.new(captain_assistant, conversation) }
   let(:embedding_service) { instance_double(Captain::Llm::EmbeddingService) }
   let(:mock_chat) { instance_double(RubyLLM::Chat) }
@@ -15,8 +15,6 @@ RSpec.describe Captain::Llm::ConversationFaqService do
   let(:mock_response) do
     instance_double(RubyLLM::Message, content: { faqs: sample_faqs }.to_json)
   end
-  let(:embedding_one) { [1.0] + Array.new(1535, 0.0) }
-  let(:embedding_two) { [0.0, 1.0] + Array.new(1534, 0.0) }
 
   before do
     create(:installation_config, name: 'CAPTAIN_OPEN_AI_API_KEY', value: 'test-key')
@@ -28,10 +26,11 @@ RSpec.describe Captain::Llm::ConversationFaqService do
     allow(mock_chat).to receive(:ask).and_return(mock_response)
   end
 
-  describe '#generate_suggestions' do
+  describe '#generate_and_deduplicate' do
     context 'when successful' do
       before do
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one, embedding_two)
+        allow(embedding_service).to receive(:get_embedding).and_return([0.1, 0.2, 0.3])
+        allow(captain_assistant.responses).to receive(:nearest_neighbors).and_return([])
       end
 
       it 'uses the conversation FAQ generation feature model' do
@@ -39,7 +38,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
           model: Llm::Models.default_model_for('conversation_faq_generation')
         ).and_return(mock_chat)
 
-        described_class.new(captain_assistant, conversation).generate_suggestions
+        described_class.new(captain_assistant, conversation).generate_and_deduplicate
       end
 
       it 'uses the conversation FAQ default ahead of the legacy global installation model' do
@@ -49,7 +48,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
           model: Llm::Models.default_model_for('conversation_faq_generation')
         ).and_return(mock_chat)
 
-        described_class.new(captain_assistant, conversation).generate_suggestions
+        described_class.new(captain_assistant, conversation).generate_and_deduplicate
       end
 
       it 'keeps account conversation FAQ model overrides ahead of the feature default' do
@@ -58,7 +57,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
 
         expect(RubyLLM).to receive(:chat).with(model: 'gpt-4.1-mini').and_return(mock_chat)
 
-        described_class.new(captain_assistant, conversation).generate_suggestions
+        described_class.new(captain_assistant, conversation).generate_and_deduplicate
       end
 
       it 'resolves the feature model from the conversation account' do
@@ -67,7 +66,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
           account: conversation.account
         ).and_call_original
 
-        described_class.new(captain_assistant, conversation).generate_suggestions
+        described_class.new(captain_assistant, conversation).generate_and_deduplicate
       end
 
       it 'sends only customer and human support agent messages to the LLM' do
@@ -85,7 +84,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
         create(:message, conversation: conversation, account: conversation.account, inbox: conversation.inbox,
                          message_type: :activity, content: 'Activity message')
 
-        service.generate_suggestions
+        service.generate_and_deduplicate
 
         expected_content = satisfy do |content|
           content.include?('User: Customer question') &&
@@ -105,7 +104,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
                          sender: nil, message_type: :outgoing, content: 'Human replied from the native app',
                          content_attributes: { external_echo: true })
 
-        service.generate_suggestions
+        service.generate_and_deduplicate
 
         expected_content = satisfy do |content|
           content.include?('User: Customer asks in a native channel') &&
@@ -134,27 +133,22 @@ RSpec.describe Captain::Llm::ConversationFaqService do
           block.call
         end
 
-        service.generate_suggestions
+        service.generate_and_deduplicate
       end
 
-      it 'creates suggestions instead of trusted FAQs for valid conversation content' do
+      it 'creates new FAQs for valid conversation content' do
         expect do
-          service.generate_suggestions
-        end.to change(captain_assistant.faq_suggestions, :count).by(2)
-        expect(Captain::FaqObservation.count).to eq(2)
-        expect(captain_assistant.responses.count).to be_zero
+          service.generate_and_deduplicate
+        end.to change(captain_assistant.responses, :count).by(2)
       end
 
-      it 'saves open suggestions with one attached source each' do
-        service.generate_suggestions
+      it 'saves FAQs with pending status linked to conversation' do
+        service.generate_and_deduplicate
         expect(
-          captain_assistant.faq_suggestions.pluck(:question, :answer, :status, :source_count, :language)
+          captain_assistant.responses.pluck(:question, :answer, :status, :documentable_id)
         ).to contain_exactly(
-          ['What is the purpose?', 'To help users.', 'open', 1, 'en'],
-          ['How does it work?', 'Through AI.', 'open', 1, 'en']
-        )
-        expect(Captain::FaqObservation.attached.pluck(:conversation_id, :language)).to contain_exactly(
-          [conversation.id, 'en'], [conversation.id, 'en']
+          ['What is the purpose?', 'To help users.', 'pending', conversation.id],
+          ['How does it work?', 'Through AI.', 'pending', conversation.id]
         )
       end
     end
@@ -163,292 +157,37 @@ RSpec.describe Captain::Llm::ConversationFaqService do
       let(:conversation) { create(:conversation) }
 
       it 'returns an empty array without generating FAQs' do
-        expect(service.generate_suggestions).to eq([])
+        expect(service.generate_and_deduplicate).to eq([])
       end
 
       it 'does not call the LLM API' do
         expect(RubyLLM).not_to receive(:chat)
-        service.generate_suggestions
+        service.generate_and_deduplicate
       end
     end
 
     context 'when finding duplicates' do
       let(:existing_response) do
-        create(:captain_assistant_response, assistant: captain_assistant, account: captain_assistant.account,
-                                            question: 'Similar question', answer: 'Similar answer', embedding: embedding_one)
+        create(:captain_assistant_response, assistant: captain_assistant, question: 'Similar question', answer: 'Similar answer')
       end
-      let(:match_response) { instance_double(RubyLLM::Message, content: { same_faq: true }.to_json) }
-
-      before do
-        existing_response
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-        allow(mock_chat).to receive(:ask) do |input|
-          input.start_with?('{') ? match_response : mock_response
-        end
-      end
-
-      it 'discards candidates the LLM confirms are covered by an approved FAQ' do
-        expect do
-          service.generate_suggestions
-        end.to change(Captain::FaqObservation.discarded, :count).by(2)
-        expect(captain_assistant.faq_suggestions.count).to be_zero
-      end
-
-      it 'uses the conversation FAQ matching feature model' do
-        expect(RubyLLM).to receive(:chat).with(
-          model: Llm::Models.default_model_for('conversation_faq_matching')
-        ).at_least(:once).and_return(mock_chat)
-
-        service.generate_suggestions
-      end
-
-      it 'uses the account model override for conversation FAQ matching' do
-        conversation.account.update!(captain_models: { 'conversation_faq_matching' => 'gpt-5-mini' })
-
-        expect(RubyLLM).to receive(:chat).with(model: 'gpt-5-mini').at_least(:once).and_return(mock_chat)
-
-        service.generate_suggestions
-      end
-
-      it 'resolves the matching feature model from the conversation account' do
-        allow(Llm::FeatureRouter).to receive(:resolve).and_call_original
-        expect(Llm::FeatureRouter).to receive(:resolve).with(
-          feature: 'conversation_faq_matching',
-          account: conversation.account
-        ).and_call_original
-
-        service.generate_suggestions
-      end
-    end
-
-    context 'when FAQ comparison cannot be completed' do
-      let(:existing_response) do
-        create(:captain_assistant_response, assistant: captain_assistant, account: captain_assistant.account,
-                                            question: 'Similar question', answer: 'Similar answer', embedding: embedding_one)
-      end
-      let(:comparison_response) { instance_double(RubyLLM::Message, content: comparison_response_content) }
-      let(:comparison_response_content) { 'invalid json' }
-
-      before do
-        existing_response
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-        allow(mock_chat).to receive(:ask) do |input|
-          input.start_with?('{') ? comparison_response : mock_response
-        end
-        allow(Rails.logger).to receive(:error)
-      end
-
-      it 'raises when the comparison response is malformed' do
-        expect do
-          service.generate_suggestions
-        end.to raise_error(JSON::ParserError)
-        expect(captain_assistant.faq_suggestions.count).to be_zero
-      end
-
-      context 'when the response omits the comparison result' do
-        let(:comparison_response_content) { {}.to_json }
-
-        it 'raises instead of treating the response as a non-match' do
-          expect do
-            service.generate_suggestions
-          end.to raise_error(KeyError)
-          expect(captain_assistant.faq_suggestions.count).to be_zero
-        end
-      end
-
-      context 'when the comparison result is not a boolean' do
-        let(:comparison_response_content) { { same_faq: 'false' }.to_json }
-
-        it 'raises instead of treating the response as a non-match' do
-          expect do
-            service.generate_suggestions
-          end.to raise_error(TypeError, 'same_faq must be a boolean')
-          expect(captain_assistant.faq_suggestions.count).to be_zero
-        end
-      end
-
-      context 'when the comparison provider fails' do
-        before do
-          allow(mock_chat).to receive(:ask) do |input|
-            raise RubyLLM::Error.new(nil, 'API Error') if input.start_with?('{')
-
-            mock_response
-          end
-        end
-
-        it 'raises instead of treating the failure as a non-match' do
-          expect do
-            service.generate_suggestions
-          end.to raise_error(RubyLLM::Error)
-          expect(captain_assistant.faq_suggestions.count).to be_zero
-        end
-      end
-    end
-
-    context 'when the classifier confirms a non-match' do
-      let(:sample_faqs) { [{ 'question' => 'How can I use the feature?', 'answer' => 'Enable it in settings.' }] }
-      let(:match_response) { instance_double(RubyLLM::Message, content: { same_faq: false }.to_json) }
-
-      before do
-        create(:captain_assistant_response, assistant: captain_assistant, account: captain_assistant.account,
-                                            question: 'How do I enable the feature?', answer: 'Turn it on in settings.',
-                                            embedding: embedding_one)
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-        allow(mock_chat).to receive(:ask) do |input|
-          input.start_with?('{') ? match_response : mock_response
-        end
-      end
-
-      it 'creates a new suggestion' do
-        expect do
-          service.generate_suggestions
-        end.to change(captain_assistant.faq_suggestions, :count).by(1)
-      end
-    end
-
-    context 'when an open suggestion is the same FAQ' do
-      let(:sample_faqs) { [{ 'question' => 'How can I use the feature?', 'answer' => 'Enable it in settings.' }] }
-      let(:existing_suggestion) do
-        captain_assistant.faq_suggestions.create!(
-          question: 'How do I enable the feature?',
-          answer: 'Turn it on in settings.',
-          embedding: embedding_one
-        ).tap do |suggestion|
-          suggestion.observations.create!(
-            conversation: create(:conversation, account: captain_assistant.account),
-            generated_question: suggestion.question,
-            generated_answer: suggestion.answer,
-            language: suggestion.language
-          )
-          suggestion.update!(source_count: suggestion.observations.attached.count)
-        end
-      end
-      let(:match_response) { instance_double(RubyLLM::Message, content: { same_faq: true }.to_json) }
-
-      before do
-        existing_suggestion
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-        allow(mock_chat).to receive(:ask) do |input|
-          input.start_with?('{') ? match_response : mock_response
-        end
-      end
-
-      it 'attaches the observation and increments the source count' do
-        expect do
-          service.generate_suggestions
-        end.to change(existing_suggestion.observations, :count).by(1)
-        expect(existing_suggestion.reload.source_count).to eq(2)
-        expect(captain_assistant.faq_suggestions.count).to eq(1)
-      end
-    end
-
-    context 'when a similar open suggestion uses another language' do
-      let(:sample_faqs) { [{ 'question' => 'Como ativo o recurso?', 'answer' => 'Ative nas configuracoes.' }] }
-      let!(:existing_suggestion) do
-        captain_assistant.faq_suggestions.create!(question: 'How do I enable the feature?', answer: 'Turn it on in settings.',
-                                                  embedding: embedding_one, language: 'en', source_count: 1)
-      end
-
-      before do
-        conversation.update!(additional_attributes: { conversation_language: 'pt-BR' })
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-      end
-
-      it 'creates a separate suggestion in the conversation language' do
-        expect do
-          service.generate_suggestions
-        end.to change(captain_assistant.faq_suggestions, :count).by(1)
-
-        expect(captain_assistant.faq_suggestions.pluck(:language)).to contain_exactly('en', 'pt')
-        expect(existing_suggestion.reload.source_count).to eq(1)
-      end
-    end
-
-    context 'when an open suggestion uses another locale variant of the same language' do
-      let(:account) { create(:account, locale: 'pt_BR') }
-      let(:captain_assistant) { create(:captain_assistant, account: account) }
-      let(:conversation) { create(:conversation, account: account, first_reply_created_at: Time.zone.now) }
-      let(:sample_faqs) { [{ 'question' => 'Como ativo o recurso?', 'answer' => 'Ative nas configuracoes.' }] }
-      let(:existing_suggestion) do
-        captain_assistant.faq_suggestions.create!(
-          question: 'Como habilito o recurso?',
-          answer: 'Ative nas configuracoes.',
-          embedding: embedding_one,
-          language: 'pt',
-          source_count: 1
+      let(:similar_neighbor) do
+        OpenStruct.new(
+          id: 1,
+          question: existing_response.question,
+          answer: existing_response.answer,
+          neighbor_distance: 0.1
         )
       end
-      let(:match_response) { instance_double(RubyLLM::Message, content: { same_faq: true }.to_json) }
 
       before do
-        existing_suggestion
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-        allow(mock_chat).to receive(:ask) do |input|
-          input.start_with?('{') ? match_response : mock_response
-        end
+        allow(embedding_service).to receive(:get_embedding).and_return([0.1, 0.2, 0.3])
+        allow(captain_assistant.responses).to receive(:nearest_neighbors).and_return([similar_neighbor])
       end
 
-      it 'attaches the observation to the existing base-language suggestion' do
+      it 'filters out duplicate FAQs based on embedding similarity' do
         expect do
-          service.generate_suggestions
-        end.to change(existing_suggestion.observations, :count).by(1)
-
-        expect(existing_suggestion.reload.source_count).to eq(2)
-        expect(captain_assistant.faq_suggestions.count).to eq(1)
-        expect(existing_suggestion.observations.last.language).to eq('pt')
-      end
-    end
-
-    context 'when a similar approved FAQ uses another language' do
-      let(:sample_faqs) { [{ 'question' => 'Como ativo o recurso?', 'answer' => 'Ative nas configuracoes.' }] }
-      let(:match_response) { instance_double(RubyLLM::Message, content: { same_faq: true }.to_json) }
-
-      before do
-        create(:captain_assistant_response, assistant: captain_assistant, account: captain_assistant.account,
-                                            question: 'How do I enable the feature?', answer: 'Turn it on in settings.',
-                                            embedding: embedding_one)
-        conversation.update!(additional_attributes: { conversation_language: 'pt-BR' })
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-        allow(mock_chat).to receive(:ask) do |input|
-          input.start_with?('{') ? match_response : mock_response
-        end
-      end
-
-      it 'deduplicates against the approved FAQ' do
-        expect do
-          service.generate_suggestions
-        end.to change(Captain::FaqObservation.discarded, :count).by(1)
-        expect(captain_assistant.faq_suggestions.count).to be_zero
-      end
-    end
-
-    context 'when conversation and account locales share a base language' do
-      let(:account) { create(:account, locale: 'pt_BR') }
-      let(:captain_assistant) { create(:captain_assistant, account: account) }
-      let(:conversation) do
-        create(:conversation, account: account, first_reply_created_at: Time.zone.now,
-                              additional_attributes: { conversation_language: 'pt' })
-      end
-      let!(:existing_response) do
-        create(:captain_assistant_response, assistant: captain_assistant, account: account,
-                                            question: 'Como ativo o recurso?', answer: 'Ative nas configuracoes.',
-                                            embedding: embedding_one)
-      end
-      let(:match_response) { instance_double(RubyLLM::Message, content: { same_faq: true }.to_json) }
-
-      before do
-        existing_response
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one)
-        allow(mock_chat).to receive(:ask) do |input|
-          input.start_with?('{') ? match_response : mock_response
-        end
-      end
-
-      it 'deduplicates against approved FAQs in the same base language' do
-        expect do
-          service.generate_suggestions
-        end.to change(Captain::FaqObservation.discarded, :count).by(2)
-        expect(captain_assistant.faq_suggestions.count).to be_zero
+          service.generate_and_deduplicate
+        end.not_to change(captain_assistant.responses, :count)
       end
     end
 
@@ -460,7 +199,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
 
       it 'returns empty array and logs the error' do
         expect(Rails.logger).to receive(:error).with('LLM API Error: API Error')
-        expect(service.generate_suggestions).to eq([])
+        expect(service.generate_and_deduplicate).to eq([])
       end
     end
 
@@ -475,7 +214,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
 
       it 'handles JSON parsing errors gracefully' do
         expect(Rails.logger).to receive(:error).with(/Error in parsing GPT processed response:/)
-        expect(service.generate_suggestions).to eq([])
+        expect(service.generate_and_deduplicate).to eq([])
       end
     end
 
@@ -489,7 +228,7 @@ RSpec.describe Captain::Llm::ConversationFaqService do
       end
 
       it 'returns empty array' do
-        expect(service.generate_suggestions).to eq([])
+        expect(service.generate_and_deduplicate).to eq([])
       end
     end
   end
@@ -497,44 +236,22 @@ RSpec.describe Captain::Llm::ConversationFaqService do
   describe 'language handling' do
     context 'when conversation has different language' do
       let(:account) { create(:account, locale: 'fr') }
-      let(:captain_assistant) { create(:captain_assistant, account: account) }
       let(:conversation) do
         create(:conversation, account: account, first_reply_created_at: Time.zone.now)
       end
 
       before do
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one, embedding_two)
+        allow(embedding_service).to receive(:get_embedding).and_return([0.1, 0.2, 0.3])
+        allow(captain_assistant.responses).to receive(:nearest_neighbors).and_return([])
       end
 
       it 'uses account language for system prompt' do
-        expect(Captain::Llm::ConversationFaqPromptsService).to receive(:generator)
+        expect(Captain::Llm::SystemPromptsService).to receive(:conversation_faq_generator)
           .with('french')
           .at_least(:once)
           .and_call_original
 
-        service.generate_suggestions
-      end
-    end
-
-    context 'when conversation language differs from account language' do
-      let(:account) { create(:account, locale: 'en') }
-      let(:captain_assistant) { create(:captain_assistant, account: account) }
-      let(:conversation) do
-        create(:conversation, account: account, first_reply_created_at: Time.zone.now,
-                              additional_attributes: { conversation_language: 'pt-BR' })
-      end
-
-      before do
-        allow(embedding_service).to receive(:get_embedding).and_return(embedding_one, embedding_two)
-      end
-
-      it 'uses the conversation language for the system prompt' do
-        expect(Captain::Llm::ConversationFaqPromptsService).to receive(:generator)
-          .with('portuguese')
-          .at_least(:once)
-          .and_call_original
-
-        service.generate_suggestions
+        service.generate_and_deduplicate
       end
     end
   end

spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb

@@ -22,9 +22,13 @@ RSpec.describe MessageTemplates::HookExecutionService do
       end
 
       it 'schedules captain response job for incoming messages on pending conversations' do
-        expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+        allow(account).to receive(:feature_enabled?).and_call_original
+        allow(account).to receive(:feature_enabled?).with('captain_integration_v2').and_return(true)
+        allow(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later)
 
-        create(:message, conversation: conversation, message_type: :incoming, account: account)
+        message = create(:message, conversation: conversation, message_type: :incoming, account: account)
+
+        expect(Captain::Conversation::ResponseBuilderJob).to have_received(:perform_later).with(conversation, assistant, message.id)
       end
     end
 

spec/lib/llm/models_spec.rb

@@ -26,10 +26,9 @@ RSpec.describe Llm::Models do
       end
     end
 
-    it 'routes each FAQ operation independently' do
+    it 'routes document and conversation FAQ generation independently' do
       expect(described_class.default_model_for('document_faq_generation')).to eq('gpt-4.1-mini')
       expect(described_class.default_model_for('conversation_faq_generation')).to eq('gpt-5.2')
-      expect(described_class.default_model_for('conversation_faq_matching')).to eq('gpt-4.1-mini')
     end
   end