Merge branch 'develop' into codex/captain-v2-paid-default

app/controllers/api/v1/accounts/agent_bots_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::AgentBotsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action :check_authorization
   before_action :agent_bot, except: [:index, :create]
 

app/controllers/api/v1/accounts/automation_rules_controller.rb

@@ -3,7 +3,6 @@ class Api::V1::Accounts::AutomationRulesController < Api::V1::Accounts::BaseCont
 
   before_action :check_authorization
   before_action :fetch_automation_rule, only: [:show, :update, :destroy, :clone]
-  before_action :ensure_execution_delay_allowed, only: [:create, :update]
 
   def index
     @automation_rules = Current.account.automation_rules
@@ -49,9 +48,6 @@ class Api::V1::Accounts::AutomationRulesController < Api::V1::Accounts::BaseCont
   def clone
     automation_rule = Current.account.automation_rules.find_by(id: params[:automation_rule_id])
     new_rule = automation_rule.dup
-    # dup copies execution_delay; drop it when the feature is off so clone can't create new
-    # delayed rules that create/update would reject.
-    new_rule.execution_delay = nil unless delayed_automations_enabled?
     new_rule.save!
     @automation_rule = new_rule
   end
@@ -59,27 +55,13 @@ class Api::V1::Accounts::AutomationRulesController < Api::V1::Accounts::BaseCont
   private
 
   def automation_rules_permit
-    permitted_attributes = [:name, :description, :event_name, :active]
-    permitted_attributes << :execution_delay if delayed_automations_enabled?
-
     params.permit(
-      *permitted_attributes,
+      :name, :description, :event_name, :active,
       conditions: [:attribute_key, :filter_operator, :query_operator, :custom_attribute_type, { values: [] }],
       actions: [:action_name, { action_params: [] }]
     )
   end
 
-  def ensure_execution_delay_allowed
-    return if delayed_automations_enabled?
-    return if params[:execution_delay].blank?
-
-    render json: { error: 'Delayed automations are not enabled for this account.' }, status: :unprocessable_entity
-  end
-
-  def delayed_automations_enabled?
-    Current.account.feature_enabled?('delayed_automations')
-  end
-
   def fetch_automation_rule
     @automation_rule = Current.account.automation_rules.find_by(id: params[:id])
   end

app/controllers/api/v1/accounts/captain/preferences_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::PreferencesController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action :authorize_account_update, only: [:update]
 
   def show

app/controllers/api/v1/accounts/labels_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::LabelsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action :fetch_label, except: [:index, :create]
   before_action :check_authorization
 

app/controllers/api/v1/accounts/whatsapp/authorizations_controller.rb

@@ -1,5 +1,4 @@
 class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts::BaseController
-  before_action :ensure_embedded_signup_enabled
   # Reconfiguring/reauthorizing a live inbox swaps its credentials, so restrict it to admins.
   before_action :check_admin_authorization?, if: -> { params[:inbox_id].present? }
   before_action :fetch_and_validate_inbox, if: -> { params[:inbox_id].present? }
@@ -19,13 +18,6 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
 
   private
 
-  def ensure_embedded_signup_enabled
-    return unless ChatwootApp.chatwoot_cloud?
-    return if Current.account.feature_enabled?('whatsapp_embedded_signup_inbox_creation')
-
-    raise Pundit::NotAuthorizedError
-  end
-
   def process_embedded_signup
     service = Whatsapp::EmbeddedSignupService.new(
       account: Current.account,
@@ -52,7 +44,8 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
   def can_reconfigure_channel?
     channel = @inbox.channel
     return false unless channel.provider == 'whatsapp_cloud'
-    return true if ChatwootApp.chatwoot_cloud?
+
+    # Reconfiguring a live embedded-signup channel requires the feature flag.
     return Current.account.feature_enabled?('whatsapp_reconfigure') if channel.provider_config['source'] == 'embedded_signup'
 
     true

app/controllers/webhooks/whatsapp_controller.rb

@@ -47,10 +47,18 @@ class Webhooks::WhatsappController < ActionController::API
     metadata = params.dig(:entry, 0, :changes, 0, :value, :metadata)
     return if metadata.blank?
 
-    Whatsapp::WebhookChannelFinderService.new(
-      display_phone_number: metadata[:display_phone_number],
-      phone_number_id: metadata[:phone_number_id]
-    ).perform
+    phone_number = normalized_phone_number(metadata[:display_phone_number])
+    phone_number_id = metadata[:phone_number_id]
+    channel = Channel::Whatsapp.find_by(phone_number: phone_number)
+
+    return channel if channel && channel.provider_config['phone_number_id'] == phone_number_id
+  end
+
+  def normalized_phone_number(phone_number)
+    return if phone_number.blank?
+
+    phone_number = phone_number.to_s
+    phone_number.start_with?('+') ? phone_number : "+#{phone_number}"
   end
 
   def inactive_whatsapp_number?

app/javascript/dashboard/api/captain/agentSessions.js

@@ -1,9 +0,0 @@
-import ApiClient from '../ApiClient';
-
-class CaptainAgentSessions extends ApiClient {
-  constructor() {
-    super('captain/agent_sessions', { accountScoped: true });
-  }
-}
-
-export default new CaptainAgentSessions();

app/javascript/dashboard/api/captain/assistant.js

@@ -26,18 +26,15 @@ class CaptainAssistant extends ApiClient {
     });
   }
 
-  getStats({ assistantId, range, signal }) {
-    const requestConfig = {
+  getStats({ assistantId, range }) {
+    return axios.get(`${this.url}/${assistantId}/stats`, {
       params: { range, timezone_offset: getTimezoneOffset() },
-    };
-    if (signal) requestConfig.signal = signal;
-
-    return axios.get(`${this.url}/${assistantId}/stats`, requestConfig);
+    });
   }
 
-  getSummary({ assistantId, range, stats }) {
+  getSummary({ assistantId, range }) {
     return axios.get(`${this.url}/${assistantId}/summary`, {
-      params: { range, timezone_offset: getTimezoneOffset(), stats },
+      params: { range, timezone_offset: getTimezoneOffset() },
     });
   }
 

app/javascript/dashboard/api/channel/whatsapp/whatsappCallsAPI.js

@@ -10,13 +10,10 @@ class WhatsappCallsAPI extends ApiClient {
     return axios.get(`${this.url}/${callId}`).then(r => r.data);
   }
 
-  // Either conversationId, or contactId + inboxId to let the BE resolve the conversation.
-  initiate({ conversationId, contactId, inboxId }, sdpOffer) {
+  initiate(conversationId, sdpOffer) {
     return axios
       .post(`${this.url}/initiate`, {
         conversation_id: conversationId,
-        contact_id: contactId,
-        inbox_id: inboxId,
         sdp_offer: sdpOffer,
       })
       .then(r => r.data);

app/javascript/dashboard/components-next/Calls/CallListItem.vue

@@ -25,11 +25,8 @@ const route = useRoute();
 
 const kind = computed(() => getCallKind(props.call));
 
-const contactName = computed(() =>
-  (props.call.contact.name || props.call.contact.phoneNumber || '').replace(
-    /^\+/,
-    ''
-  )
+const contactName = computed(
+  () => props.call.contact.name || props.call.contact.phoneNumber
 );
 
 const agentActionLabel = computed(() => {

app/javascript/dashboard/components-next/Contacts/VoiceCallButton.vue

@@ -16,6 +16,7 @@ import { useAlert } from 'dashboard/composables';
 import { frontendURL, conversationUrl } from 'dashboard/helper/URLHelper';
 import { useCallsStore } from 'dashboard/stores/calls';
 import { useWhatsappCallSession } from 'dashboard/composables/useWhatsappCallSession';
+import ContactAPI from 'dashboard/api/contacts';
 
 import Button from 'dashboard/components-next/button/Button.vue';
 import Dialog from 'dashboard/components-next/dialog/Dialog.vue';
@@ -82,18 +83,39 @@ const navigateToConversation = conversationId => {
 
 const whatsappCallSession = useWhatsappCallSession();
 
+// Find the most recent open conversation for this contact in the picked inbox.
+// WhatsApp /initiate is conversation-scoped (unlike Twilio's contact-scoped path).
+// Pass inboxId so the BE applies the filter before the 20-row cap — without it,
+// contacts whose latest WhatsApp conversation falls outside the 20 most recent
+// across all inboxes would be treated as having no conversation.
+const findWhatsappConversationId = async inboxId => {
+  const { data } = await ContactAPI.getConversations(props.contactId, {
+    inboxId,
+  });
+  const conversations = data?.payload || [];
+  const match = [...conversations].sort(
+    (a, b) => (b.last_activity_at || 0) - (a.last_activity_at || 0)
+  )[0];
+  return match?.id || null;
+};
+
 const startWhatsappCall = async (inboxId, conversationIdHint) => {
-  const response = await whatsappCallSession.initiateOutboundCall(
-    conversationIdHint
-      ? { conversationId: conversationIdHint }
-      : { contactId: props.contactId, inboxId }
-  );
+  // WhatsApp /initiate is conversation-scoped, so we must hand it a
+  // conversation. Use the caller's hint when given (in-conversation flow);
+  // otherwise pick the most recent one in the inbox.
+  const conversationId =
+    conversationIdHint || (await findWhatsappConversationId(inboxId));
+  if (!conversationId) {
+    useAlert(t('CONTACT_PANEL.CALL_FAILED'));
+    return;
+  }
+
+  const response =
+    await whatsappCallSession.initiateOutboundCall(conversationId);
   // The composable returns { status: 'locked' } when an init is already in
   // flight or a call is already active; treat that as a soft no-op rather than
   // claiming success.
   if (response?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.LOCKED) return;
-
-  const conversationId = response?.conversation_id || conversationIdHint;
   if (!response?.id) {
     // Permission template path returns no call id. Mirror the header button and
     // surface whether the request was just sent or is already pending instead of

app/javascript/dashboard/components-next/NewConversation/ComposeConversation.vue

@@ -234,7 +234,6 @@ onMounted(() => resetContacts());
     ref="popoverRef"
     :align="align"
     :show-content-border="false"
-    :close-on-scroll="false"
     @show="onPopoverShow"
     @hide="onPopoverHide"
   >

app/javascript/dashboard/components-next/captain/pageComponents/overview/MetricCard.vue

@@ -9,7 +9,6 @@ const props = defineProps({
   // null = neutral, true = good direction, false = bad direction
   trendGood: { type: Boolean, default: null },
   clickable: { type: Boolean, default: false },
-  loading: { type: Boolean, default: false },
 });
 
 const emit = defineEmits(['click']);
@@ -46,11 +45,7 @@ const onActivate = () => {
         class="transition-opacity opacity-0 cursor-help i-lucide-info size-3.5 text-n-slate-10 group-hover:opacity-100"
       />
     </div>
-    <div v-if="loading" class="flex items-end justify-between gap-2">
-      <div class="w-20 rounded h-9 bg-n-slate-3 animate-pulse" />
-      <div class="w-10 h-5 rounded bg-n-slate-3 animate-pulse" />
-    </div>
-    <div v-else class="flex items-end justify-between gap-2">
+    <div class="flex items-end justify-between gap-2">
       <span
         class="text-3xl font-semibold tracking-tight tabular-nums text-n-slate-12"
       >

app/javascript/dashboard/components-next/captain/pageComponents/overview/WelcomeCard.vue

@@ -9,10 +9,6 @@ const props = defineProps({
     type: String,
     default: '30',
   },
-  stats: {
-    type: Object,
-    default: null,
-  },
 });
 
 const route = useRoute();
@@ -24,41 +20,22 @@ const assistantId = computed(() => route.params.assistantId);
 const welcomeMarkdown = ref('');
 const isLoading = ref(false);
 
-// Increments on every fetch so a slow response for a superseded
-// range/stats/assistant can't overwrite the latest request's state.
-let fetchToken = 0;
-
 const fetchSummary = async () => {
-  fetchToken += 1;
-  const token = fetchToken;
-
-  if (!props.stats) {
-    welcomeMarkdown.value = '';
-    isLoading.value = false;
-    return;
-  }
-
   isLoading.value = true;
-  let message = '';
   try {
     const { data } = await CaptainAssistant.getSummary({
       assistantId: assistantId.value,
       range: props.range,
-      stats: props.stats,
     });
-    message = data.message ?? '';
+    welcomeMarkdown.value = data.message ?? '';
   } catch {
-    message = '';
+    welcomeMarkdown.value = '';
+  } finally {
+    isLoading.value = false;
   }
-
-  if (token !== fetchToken) return;
-  welcomeMarkdown.value = message;
-  isLoading.value = false;
 };
 
-watch([() => props.range, () => props.stats, assistantId], fetchSummary, {
-  immediate: true,
-});
+watch([() => props.range, assistantId], fetchSummary, { immediate: true });
 
 // Render through the shared markdown formatter (html disabled, so it is safe)
 // used everywhere else for Captain output, instead of a bespoke parser. It

app/javascript/dashboard/components-next/content-templates/ContentTemplateParser.vue

@@ -3,13 +3,8 @@ import { ref, computed, onMounted, watch } from 'vue';
 import { useVuelidate } from '@vuelidate/core';
 import { requiredIf } from '@vuelidate/validators';
 import { useI18n } from 'vue-i18n';
-import {
-  isTwilioComplete,
-  isTwilioMediaTemplate,
-  getTwilioMediaVariableKey,
-  getTwilioMediaUrl,
-  applyTwilioMediaFilename,
-} from '@chatwoot/utils';
+import { extractFilenameFromUrl } from 'dashboard/helper/URLHelper';
+import { TWILIO_CONTENT_TEMPLATE_TYPES } from 'shared/constants/messages';
 
 import Input from 'dashboard/components-next/input/Input.vue';
 
@@ -45,23 +40,30 @@ const templateBody = computed(() => {
   return props.template.body || '';
 });
 
-// Media-template detection and variable extraction are shared with the mobile
-// app via @chatwoot/utils.
-const hasMediaTemplate = computed(() => isTwilioMediaTemplate(props.template));
+const hasMediaTemplate = computed(() => {
+  return props.template.template_type === TWILIO_CONTENT_TEMPLATE_TYPES.MEDIA;
+});
 
 const hasVariables = computed(() => {
   return templateBody.value?.match(VARIABLE_PATTERN) !== null;
 });
 
-const mediaVariableKey = computed(() =>
-  getTwilioMediaVariableKey(props.template)
-);
+const mediaVariableKey = computed(() => {
+  if (!hasMediaTemplate.value) return null;
+  const mediaUrl = props.template?.types?.['twilio/media']?.media?.[0];
+  if (!mediaUrl) return null;
+  return mediaUrl.match(/{{(\d+)}}/)?.[1] ?? null;
+});
 
-const hasMediaVariable = computed(() => mediaVariableKey.value !== null);
+const hasMediaVariable = computed(() => {
+  return hasMediaTemplate.value && mediaVariableKey.value !== null;
+});
 
-const templateMediaUrl = computed(() =>
-  hasMediaTemplate.value ? getTwilioMediaUrl(props.template) : ''
-);
+const templateMediaUrl = computed(() => {
+  if (!hasMediaTemplate.value) return '';
+
+  return props.template?.types?.['twilio/media']?.media?.[0] || '';
+});
 
 const variablePattern = computed(() => {
   if (!hasVariables.value) return [];
@@ -81,10 +83,26 @@ const renderedTemplate = computed(() => {
   return rendered;
 });
 
-// Completeness validation is shared with the mobile app via @chatwoot/utils.
-const isFormInvalid = computed(
-  () => !isTwilioComplete(props.template, processedParams.value)
-);
+const isFormInvalid = computed(() => {
+  if (!hasVariables.value && !hasMediaVariable.value) return false;
+
+  if (hasVariables.value) {
+    const hasEmptyVariable = variablePattern.value.some(
+      variable => !processedParams.value[variable]
+    );
+    if (hasEmptyVariable) return true;
+  }
+
+  if (
+    hasMediaVariable.value &&
+    mediaVariableKey.value &&
+    !processedParams.value[mediaVariableKey.value]
+  ) {
+    return true;
+  }
+
+  return false;
+});
 
 const v$ = useVuelidate(
   {
@@ -117,11 +135,19 @@ const sendMessage = () => {
 
   const { friendly_name, language } = props.template;
 
-  // For media templates, reduce the media URL to a filename before sending.
-  const processedParameters = applyTwilioMediaFilename(
-    props.template,
-    processedParams.value
-  );
+  // Process parameters and extract filename from media URL if needed
+  const processedParameters = { ...processedParams.value };
+
+  // For media templates, extract filename from full URL
+  if (
+    hasMediaVariable.value &&
+    mediaVariableKey.value &&
+    processedParameters[mediaVariableKey.value]
+  ) {
+    processedParameters[mediaVariableKey.value] = extractFilenameFromUrl(
+      processedParameters[mediaVariableKey.value]
+    );
+  }
 
   const payload = {
     message: renderedTemplate.value,

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

@@ -1,342 +0,0 @@
-<script setup>
-import { computed, ref } from 'vue';
-import { useI18n, I18nT } from 'vue-i18n';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
-import Popover from 'dashboard/components-next/popover/Popover.vue';
-import { useStore, useMapGetter } from 'dashboard/composables/store';
-import { useAccount } from 'dashboard/composables/useAccount';
-import { FEATURE_FLAGS } from 'dashboard/featureFlags';
-import { useMessageContext } from './provider.js';
-import { MESSAGE_VARIANTS, ORIENTATION } from './constants';
-
-const props = defineProps({
-  messageId: { type: Number, required: true },
-});
-
-const { t } = useI18n();
-const { orientation, variant, createdAt } = useMessageContext();
-const store = useStore();
-const { isCloudFeatureEnabled } = useAccount();
-
-const isOpen = ref(false);
-
-const showSparkle = computed(() =>
-  isCloudFeatureEnabled(FEATURE_FLAGS.CAPTAIN_V2)
-);
-
-const session = computed(() =>
-  store.getters['captainAgentSessions/getSessionByMessageId'](props.messageId)
-);
-const hasFetched = computed(() =>
-  store.getters['captainAgentSessions/hasFetched'](props.messageId)
-);
-const isLoading = computed(
-  () =>
-    !hasFetched.value ||
-    store.getters['captainAgentSessions/isFetching'](props.messageId)
-);
-
-const citations = computed(() => session.value?.citations || []);
-
-const scenarioTitles = computed(() =>
-  (session.value?.scenarios || []).reduce((map, scenario) => {
-    map[scenario.id] = scenario.title;
-    return map;
-  }, {})
-);
-
-// Fallback for agents without a matching scenario title:
-// "chatwoot_assistant" → "Chatwoot assistant",
-// "scenario_5_chatwoot_uptime_agent" → "Chatwoot uptime".
-const humanizeAgentName = agentName => {
-  const label = agentName
-    .replace(/^scenario_\d+_/, '')
-    .replace(/_agent$/, '')
-    .replaceAll('_', ' ')
-    .trim();
-  return label.charAt(0).toUpperCase() + label.slice(1);
-};
-
-const handoffLabel = agentName => {
-  const scenarioId = agentName.match(/^scenario_(\d+)/)?.[1];
-  return scenarioTitles.value[scenarioId] || humanizeAgentName(agentName);
-};
-
-const ACRONYMS = ['faq', 'api', 'url', 'id', 'sla', 'csat'];
-
-// Tool names arrive as RubyLLM identifiers like
-// "captain--tools--faq_lookup" or "custom_get_status_page_overview";
-// show "FAQ Lookup" / "Get Status Page Overview" instead.
-const humanizeToolName = name => {
-  return (name || '')
-    .split('--')
-    .pop()
-    .replace(/^custom_/, '')
-    .split('_')
-    .filter(Boolean)
-    .map(word =>
-      ACRONYMS.includes(word)
-        ? word.toUpperCase()
-        : word.charAt(0).toUpperCase() + word.slice(1)
-    )
-    .join(' ');
-};
-
-// Argument keys are camelCased by the store ("labelName"); show "Label Name".
-const humanizeArgumentKey = key =>
-  key
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(' ')
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(' ');
-
-const formatArguments = args => {
-  if (!args || typeof args !== 'object') return '';
-  return Object.entries(args)
-    .map(([key, value]) => `${humanizeArgumentKey(key)}: ${value}`)
-    .join(', ');
-};
-
-// Timeline of what Captain did during the run: tool calls (with their
-// arguments) and scenario/agent handoffs. Message bodies and raw tool
-// results are intentionally not echoed here.
-const steps = computed(() => {
-  const runContext = session.value?.runContext;
-  const result = [];
-  let currentAgent = null;
-
-  (Array.isArray(runContext) ? runContext : []).forEach(entry => {
-    if (entry?.role !== 'assistant') return;
-
-    const agentName = entry.agentName;
-    if (agentName && agentName !== currentAgent) {
-      if (currentAgent !== null) {
-        result.push({ type: 'handoff', name: handoffLabel(agentName) });
-      }
-      currentAgent = agentName;
-    }
-
-    (entry.toolCalls || []).forEach(call => {
-      // Agent-to-agent transfers surface as "handoff_to_<agent>" tool calls;
-      // the agent_name change above already yields a handoff step for them.
-      if (call.name?.startsWith('handoff_to_')) return;
-
-      result.push({
-        type: 'tool',
-        name: humanizeToolName(call.name),
-        detail: formatArguments(call.arguments),
-      });
-    });
-  });
-
-  return result;
-});
-
-// The final assistant entry stores structured content ({response, reasoning});
-// surface the model's reasoning for the reply it produced.
-const reasoning = computed(() => {
-  const runContext = session.value?.runContext;
-  if (!Array.isArray(runContext)) return '';
-
-  const entry = [...runContext]
-    .reverse()
-    .find(item => item?.role === 'assistant' && item.content?.reasoning);
-  return entry?.content?.reasoning || '';
-});
-
-const STEP_ICONS = {
-  tool: 'i-ph-wrench',
-  handoff: 'i-ph-user-switch',
-};
-
-const STEP_KEYPATHS = {
-  tool: 'CONVERSATION.CAPTAIN_GENERATION.STEP_TOOL',
-  handoff: 'CONVERSATION.CAPTAIN_GENERATION.STEP_HANDOFF',
-};
-
-const currentUser = useMapGetter('getCurrentUser');
-const isSuperAdmin = computed(() => currentUser.value.type === 'SuperAdmin');
-
-// Model and credits are only surfaced to super admins and in development.
-const devDetails = computed(() => {
-  if (!session.value) return null;
-  if (!import.meta.env.DEV && !isSuperAdmin.value) return null;
-  const model = t('CONVERSATION.CAPTAIN_GENERATION.MODEL', {
-    model: session.value.llmModel,
-  });
-  const credits = t('CONVERSATION.CAPTAIN_GENERATION.CREDITS', {
-    credits: session.value.creditsConsumed,
-  });
-  return `${model} · ${credits}`;
-});
-
-// With the sparkle at the row start, the meta gets pushed to the opposite end;
-// without it, fall back to the message orientation.
-const rowLayoutClass = computed(() => {
-  if (showSparkle.value) return 'justify-between';
-  return orientation.value === ORIENTATION.LEFT
-    ? 'justify-start'
-    : 'justify-end';
-});
-
-// Blend the sparkle with the bubble background: amber on private notes,
-// slate everywhere else. Tokens adapt to dark mode on their own.
-const sparkleColorClass = computed(() => {
-  if (variant.value === MESSAGE_VARIANTS.PRIVATE) {
-    return isOpen.value
-      ? 'text-n-amber-12/80'
-      : 'text-n-amber-12/40 hover:text-n-amber-12/70';
-  }
-  return isOpen.value
-    ? 'text-n-slate-12'
-    : 'text-n-slate-11/60 hover:text-n-slate-12';
-});
-
-const popoverAlign = computed(() =>
-  orientation.value === ORIENTATION.LEFT ? 'start' : 'end'
-);
-
-const prefetch = () => {
-  store.dispatch('captainAgentSessions/fetch', {
-    messageId: props.messageId,
-    createdAt: createdAt.value,
-  });
-};
-
-const onPopoverShow = () => {
-  isOpen.value = true;
-  prefetch();
-};
-
-const onPopoverHide = () => {
-  isOpen.value = false;
-};
-</script>
-
-<template>
-  <div class="flex items-center gap-1.5" :class="rowLayoutClass">
-    <Popover
-      v-if="showSparkle"
-      :align="popoverAlign"
-      @show="onPopoverShow"
-      @hide="onPopoverHide"
-    >
-      <button
-        v-tooltip="t('CONVERSATION.CAPTAIN_GENERATION.TITLE')"
-        type="button"
-        class="inline-flex items-center gap-1 p-0 bg-transparent border-0 cursor-pointer"
-        :class="sparkleColorClass"
-        @mouseenter="prefetch"
-        @focus="prefetch"
-      >
-        <Icon icon="i-ph-sparkle-fill" class="size-3.5" />
-        <span class="text-xs">
-          {{ t('CONVERSATION.CAPTAIN_GENERATION.GENERATED_BY') }}
-        </span>
-      </button>
-      <template #content>
-        <div class="flex flex-col gap-4 p-4 w-80">
-          <span v-if="isLoading" class="text-xs text-n-slate-11">
-            {{ t('CONVERSATION.CAPTAIN_GENERATION.LOADING') }}
-          </span>
-          <span v-else-if="!session" class="text-xs text-n-slate-11">
-            {{ t('CONVERSATION.CAPTAIN_GENERATION.EMPTY') }}
-          </span>
-          <template v-else>
-            <div v-if="steps.length" class="flex flex-col gap-2">
-              <span class="text-xs font-medium text-n-slate-11">
-                {{ t('CONVERSATION.CAPTAIN_GENERATION.TIMELINE') }}
-              </span>
-              <div class="flex flex-col">
-                <div
-                  v-for="(step, index) in steps"
-                  :key="index"
-                  class="flex gap-2.5"
-                >
-                  <div class="flex flex-col items-center">
-                    <span
-                      class="flex items-center justify-center rounded-full size-5 bg-n-alpha-2 text-n-slate-11"
-                    >
-                      <Icon :icon="STEP_ICONS[step.type]" class="size-3" />
-                    </span>
-                    <span
-                      v-if="index < steps.length - 1"
-                      class="flex-1 w-px min-h-2 bg-n-weak"
-                    />
-                  </div>
-                  <div
-                    class="flex flex-col min-w-0 gap-0.5"
-                    :class="index < steps.length - 1 ? 'pb-3' : ''"
-                  >
-                    <I18nT
-                      :keypath="STEP_KEYPATHS[step.type]"
-                      tag="span"
-                      class="text-xs leading-5 text-n-slate-11"
-                    >
-                      <template #name>
-                        <span class="font-medium text-n-slate-12">
-                          {{ step.name }}
-                        </span>
-                      </template>
-                    </I18nT>
-                    <span
-                      v-if="step.detail"
-                      class="text-xs text-n-slate-11 break-words"
-                    >
-                      {{ step.detail }}
-                    </span>
-                  </div>
-                </div>
-              </div>
-            </div>
-            <div v-if="citations.length" class="flex flex-col gap-2">
-              <div class="flex items-baseline gap-1.5">
-                <span class="text-xs font-medium text-n-slate-11">
-                  {{ t('CONVERSATION.CAPTAIN_GENERATION.SOURCES') }}
-                </span>
-                <span class="text-xs text-n-slate-10">
-                  {{
-                    t(
-                      'CONVERSATION.CAPTAIN_GENERATION.SOURCES_SUMMARY',
-                      citations.length
-                    )
-                  }}
-                </span>
-              </div>
-              <ul class="flex flex-col gap-1 m-0 list-disc ps-4">
-                <li
-                  v-for="citation in citations"
-                  :key="citation.id"
-                  class="text-xs text-n-slate-12"
-                >
-                  <a
-                    v-if="citation.link"
-                    :href="citation.link"
-                    target="_blank"
-                    rel="noopener noreferrer"
-                    class="text-xs text-n-blue-11 hover:underline"
-                  >
-                    {{ citation.title || citation.link }}
-                  </a>
-                  <span v-else>{{ citation.title }}</span>
-                </li>
-              </ul>
-            </div>
-            <div v-if="reasoning" class="flex flex-col gap-2">
-              <span class="text-xs font-medium text-n-slate-11">
-                {{ t('CONVERSATION.CAPTAIN_GENERATION.REASONING') }}
-              </span>
-              <p class="m-0 text-xs leading-normal text-n-slate-12 break-words">
-                {{ reasoning }}
-              </p>
-            </div>
-            <span v-if="devDetails" class="text-xs text-n-slate-11">
-              {{ devDetails }}
-            </span>
-          </template>
-        </div>
-      </template>
-    </Popover>
-    <slot name="meta" />
-  </div>
-</template>

app/javascript/dashboard/components-next/message/bubbles/Base.vue

@@ -2,7 +2,6 @@
 import { computed } from 'vue';
 
 import MessageMeta from '../MessageMeta.vue';
-import CaptainGenerationDetails from '../CaptainGenerationDetails.vue';
 
 import { emitter } from 'shared/helpers/mitt';
 import { useMessageContext } from '../provider.js';
@@ -10,38 +9,16 @@ import { useI18n } from 'vue-i18n';
 
 import MessageFormatter from 'shared/helpers/MessageFormatter.js';
 import { BUS_EVENTS } from 'shared/constants/busEvents';
-import { MESSAGE_VARIANTS, ORIENTATION, SENDER_TYPES } from '../constants';
+import { MESSAGE_VARIANTS, ORIENTATION } from '../constants';
 
 const props = defineProps({
   hideMeta: { type: Boolean, default: false },
 });
 
-const {
-  variant,
-  orientation,
-  inReplyTo,
-  shouldGroupWithNext,
-  id,
-  sender,
-  senderType,
-} = useMessageContext();
+const { variant, orientation, inReplyTo, shouldGroupWithNext } =
+  useMessageContext();
 const { t } = useI18n();
 
-const isCaptainMessage = computed(
-  () =>
-    (sender.value?.type ?? senderType.value) === SENDER_TYPES.CAPTAIN_ASSISTANT
-);
-
-const metaColorClass = computed(() =>
-  variant.value === MESSAGE_VARIANTS.PRIVATE
-    ? 'text-n-amber-12/50'
-    : 'text-n-slate-11'
-);
-
-const emailMetaClass = computed(() =>
-  variant.value === MESSAGE_VARIANTS.EMAIL ? 'px-3 pb-3' : ''
-);
-
 const varaintBaseMap = {
   [MESSAGE_VARIANTS.AGENT]: 'bg-n-solid-blue text-n-slate-12',
   [MESSAGE_VARIANTS.PRIVATE]:
@@ -137,21 +114,16 @@ const replyToPreview = computed(() => {
       />
     </div>
     <slot />
-    <template v-if="shouldShowMeta">
-      <CaptainGenerationDetails
-        v-if="isCaptainMessage"
-        :message-id="id"
-        class="mt-2"
-      >
-        <template #meta>
-          <MessageMeta :class="[emailMetaClass, metaColorClass]" />
-        </template>
-      </CaptainGenerationDetails>
-      <MessageMeta
-        v-else
-        :class="[flexOrientationClass, emailMetaClass, metaColorClass]"
-        class="mt-2"
-      />
-    </template>
+    <MessageMeta
+      v-if="shouldShowMeta"
+      :class="[
+        flexOrientationClass,
+        variant === MESSAGE_VARIANTS.EMAIL ? 'px-3 pb-3' : '',
+        variant === MESSAGE_VARIANTS.PRIVATE
+          ? 'text-n-amber-12/50'
+          : 'text-n-slate-11',
+      ]"
+      class="mt-2"
+    />
   </div>
 </template>

app/javascript/dashboard/components-next/message/bubbles/VoiceCall.vue

@@ -263,9 +263,9 @@ const handleCallBack = async () => {
   if (!canCallBack.value || isInitiatingCall.value) return;
   try {
     if (isWhatsapp.value) {
-      const response = await whatsappCallSession.initiateOutboundCall({
-        conversationId: conversationId.value,
-      });
+      const response = await whatsappCallSession.initiateOutboundCall(
+        conversationId.value
+      );
       if (response?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.LOCKED) return;
       // Permission template path returns no call id — show banner, no widget yet.
       if (!response?.id) {

app/javascript/dashboard/components-next/popover/Popover.vue

@@ -1,11 +1,7 @@
 <script setup>
 import { ref, computed, watch, nextTick } from 'vue';
 import { vOnClickOutside } from '@vueuse/components';
-import {
-  useBreakpoints,
-  breakpointsTailwind,
-  useEventListener,
-} from '@vueuse/core';
+import { useBreakpoints, breakpointsTailwind } from '@vueuse/core';
 import { useDropdownPosition } from 'dashboard/composables/useDropdownPosition';
 import { useKeyboardEvents } from 'dashboard/composables/useKeyboardEvents';
 import TeleportWithDirection from 'dashboard/components-next/TeleportWithDirection.vue';
@@ -20,10 +16,6 @@ const props = defineProps({
     type: Boolean,
     default: false,
   },
-  closeOnScroll: {
-    type: Boolean,
-    default: true,
-  },
   showContentBorder: {
     type: Boolean,
     default: true,
@@ -49,12 +41,8 @@ const { fixedPosition, updatePosition } = useDropdownPosition(
   { align: props.align }
 );
 
-const SCROLL_CLOSE_THRESHOLD = 24;
-const triggerTopAtOpen = ref(0);
-
 const show = async () => {
   isActive.value = true;
-  triggerTopAtOpen.value = triggerRef.value?.getBoundingClientRect().top ?? 0;
   if (!isMobile.value) {
     await nextTick();
     updatePosition();
@@ -68,22 +56,6 @@ const hide = () => {
   emit('hide');
 };
 
-// The teleported popover tracks its trigger while ancestors scroll; allow
-// small drift (trackpad inertia), but close once the trigger moves further.
-useEventListener(
-  window,
-  'scroll',
-  event => {
-    if (!props.closeOnScroll || !showPopover.value) return;
-    if (popoverRef.value?.contains(event.target)) return;
-    const top = triggerRef.value?.getBoundingClientRect().top ?? 0;
-    if (Math.abs(top - triggerTopAtOpen.value) > SCROLL_CLOSE_THRESHOLD) {
-      hide();
-    }
-  },
-  { capture: true, passive: true }
-);
-
 const toggle = async () => {
   if (isActive.value) hide();
   else await show();

app/javascript/dashboard/components-next/whatsapp/WhatsAppTemplateParser.vue

@@ -13,7 +13,6 @@ import { useVuelidate } from '@vuelidate/core';
 import { requiredIf } from '@vuelidate/validators';
 import { useI18n } from 'vue-i18n';
 
-import { isWhatsAppComplete } from '@chatwoot/utils';
 import Input from 'dashboard/components-next/input/Input.vue';
 import {
   buildTemplateParameters,
@@ -85,10 +84,29 @@ const renderedTemplate = computed(() => {
   return replaceTemplateVariables(bodyText.value, processedParams.value);
 });
 
-// Completeness validation is shared with the mobile app via @chatwoot/utils.
-const isFormInvalid = computed(
-  () => !isWhatsAppComplete(props.template, processedParams.value)
-);
+const isFormInvalid = computed(() => {
+  if (!hasVariables.value && !hasMediaHeader.value) return false;
+
+  if (hasMediaHeader.value && !processedParams.value.header?.media_url) {
+    return true;
+  }
+
+  if (hasVariables.value && processedParams.value.body) {
+    const hasEmptyBodyVariable = Object.values(processedParams.value.body).some(
+      value => !value
+    );
+    if (hasEmptyBodyVariable) return true;
+  }
+
+  if (processedParams.value.buttons) {
+    const hasEmptyButtonParameter = processedParams.value.buttons.some(
+      button => !button.parameter
+    );
+    if (hasEmptyButtonParameter) return true;
+  }
+
+  return false;
+});
 
 const v$ = useVuelidate(
   {

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

@@ -69,9 +69,9 @@ const callButtonTooltip = computed(() =>
 const startWhatsappCall = async () => {
   if (whatsappCallSession.isInitiating.value) return;
   try {
-    const response = await whatsappCallSession.initiateOutboundCall({
-      conversationId: props.chat.id,
-    });
+    const response = await whatsappCallSession.initiateOutboundCall(
+      props.chat.id
+    );
 
     // Composable returns LOCKED when init is already in flight or a call is
     // active; soft no-op so a parallel click doesn't trigger a banner.

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

@@ -1,9 +1,9 @@
-import { useMapGetter } from 'dashboard/composables/store';
-import * as agentHelper from 'dashboard/helper/agentHelper';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ref } from 'vue';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { useAgentsList } from '../useAgentsList';
+import { useMapGetter } from 'dashboard/composables/store';
 import { allAgentsData, formattedAgentsData } from './fixtures/agentFixtures';
+import * as agentHelper from 'dashboard/helper/agentHelper';
 
 // Mock vue-i18n
 vi.mock('vue-i18n', () => ({
@@ -94,32 +94,6 @@ describe('useAgentsList', () => {
     expect(agentsList.value.length).toBe(formattedAgentsData.slice(1).length);
   });
 
-  it('keeps nameless agent bots and applies a fallback label', () => {
-    const namelessBot = {
-      id: 91,
-      name: null,
-      assignee_type: 'AgentBot',
-      availability_status: 'offline',
-    };
-    mockUseMapGetter({
-      'inboxAssignableAgents/getAssignableAgents': ref(() => [
-        ...allAgentsData,
-        namelessBot,
-      ]),
-    });
-
-    const { agentsList } = useAgentsList();
-    // access the computed to trigger evaluation
-    expect(agentsList.value).toBeDefined();
-
-    const passedAgents =
-      agentHelper.getAgentsByUpdatedPresence.mock.calls[0][0];
-    expect(passedAgents).toContainEqual({
-      ...namelessBot,
-      name: '-',
-    });
-  });
-
   it('handles empty assignable agents', () => {
     mockUseMapGetter({
       'inboxAssignableAgents/getAssignableAgents': ref(() => []),

app/javascript/dashboard/composables/useAgentsList.js

@@ -1,10 +1,10 @@
+import { computed } from 'vue';
 import { useMapGetter } from 'dashboard/composables/store';
+import { useI18n } from 'vue-i18n';
 import {
   getAgentsByUpdatedPresence,
   getSortedAgentsByAvailability,
 } from 'dashboard/helper/agentHelper';
-import { computed } from 'vue';
-import { useI18n } from 'vue-i18n';
 
 /**
  * A composable function that provides a list of agents for assignment.
@@ -53,11 +53,7 @@ export function useAgentsList(
    * @type {import('vue').ComputedRef<Array>}
    */
   const agentsList = computed(() => {
-    const agents = (assignableAgents.value || []).map(agent =>
-      !agent.name && agent.assignee_type === 'AgentBot'
-        ? { ...agent, name: '-' }
-        : agent
-    );
+    const agents = assignableAgents.value || [];
     const agentsByUpdatedPresence = getAgentsByUpdatedPresence(
       agents,
       currentUser.value,

app/javascript/dashboard/composables/useWhatsappCallSession.js

@@ -308,8 +308,7 @@ export function useWhatsappCallSession() {
     }
   };
 
-  // target: { conversationId } or { contactId, inboxId }
-  const initiateOutboundCall = async target => {
+  const initiateOutboundCall = async conversationId => {
     // Module-scoped lock + active-session guard so a second click — from the
     // same composable instance OR a different one (header vs contact panel)
     // OR while a call is already live — can't tear down the in-flight setup
@@ -321,7 +320,10 @@ export function useWhatsappCallSession() {
     isInitiatingOutbound.value = true;
     try {
       const sdpOffer = await prepareOutboundOffer();
-      const response = await WhatsappCallsAPI.initiate(target, sdpOffer);
+      const response = await WhatsappCallsAPI.initiate(
+        conversationId,
+        sdpOffer
+      );
       if (response?.id) {
         activeCallId = response.id;
         // A connect webhook that raced ahead of this response was buffered;
@@ -352,7 +354,7 @@ export function useWhatsappCallSession() {
         data?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.PERMISSION_REQUESTED ||
         data?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.PERMISSION_PENDING
       ) {
-        return { status: data.status, conversation_id: data.conversation_id };
+        return { status: data.status };
       }
       throw e;
     } finally {

app/javascript/dashboard/featureFlags.js

@@ -7,14 +7,14 @@ export const FEATURE_FLAGS = {
   AUTOMATIONS: 'automations',
   CAMPAIGNS: 'campaigns',
   WHATSAPP_CAMPAIGNS: 'whatsapp_campaign',
-  WHATSAPP_EMBEDDED_SIGNUP_FLOW: 'whatsapp_embedded_signup_inbox_creation',
+  WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION:
+    'whatsapp_embedded_signup_inbox_creation',
   WHATSAPP_MANUAL_TRANSFER: 'whatsapp_manual_transfer',
   WHATSAPP_RECONFIGURE: 'whatsapp_reconfigure',
   CANNED_RESPONSES: 'canned_responses',
   CRM: 'crm',
   CUSTOM_ATTRIBUTES: 'custom_attributes',
   DATA_IMPORT: 'data_import',
-  DELAYED_AUTOMATIONS: 'delayed_automations',
   API_AND_WEBHOOKS: 'api_and_webhooks',
   INBOX_MANAGEMENT: 'inbox_management',
   INTEGRATIONS: 'integrations',

app/javascript/dashboard/helper/URLHelper.js

@@ -127,8 +127,25 @@ export const getHostNameFromURL = url => {
   }
 };
 
-// Shared with the mobile app via @chatwoot/utils.
-export { extractFilenameFromUrl } from '@chatwoot/utils';
+/**
+ * Extracts filename from a URL
+ * @param {string} url - The URL to extract filename from
+ * @returns {string} - The extracted filename or original URL if extraction fails
+ */
+export const extractFilenameFromUrl = url => {
+  if (!url || typeof url !== 'string') return url;
+
+  try {
+    const urlObj = new URL(url);
+    const pathname = urlObj.pathname;
+    const filename = pathname.split('/').pop();
+    return filename || url;
+  } catch (error) {
+    // If URL parsing fails, try to extract filename using regex
+    const match = url.match(/\/([^/?#]+)(?:[?#]|$)/);
+    return match ? match[1] : url;
+  }
+};
 
 /**
  * Normalizes a comma/newline separated list of domains

app/javascript/dashboard/helper/agentHelper.js

@@ -7,7 +7,7 @@
 export const getAgentsByAvailability = (agents, availability) => {
   return agents
     .filter(agent => agent.availability_status === availability)
-    .sort((a, b) => (a.name || '').localeCompare(b.name || ''));
+    .sort((a, b) => a.name.localeCompare(b.name));
 };
 
 /**

app/javascript/dashboard/helper/automationHelper.js

@@ -208,12 +208,6 @@ export const generateAutomationPayload = payload => {
   return automation;
 };
 
-export const formatDelay = minutes => {
-  if (minutes % 1440 === 0) return `${minutes / 1440}d`;
-  if (minutes % 60 === 0) return `${minutes / 60}h`;
-  return `${minutes}m`;
-};
-
 export const isCustomAttribute = (attrs, key) => {
   return attrs.find(attr => attr.key === key);
 };

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

@@ -26,18 +26,6 @@ describe('agentHelper', () => {
         offlineAgentsData
       );
     });
-
-    it('does not throw when an agent has a null name', () => {
-      const agents = [
-        { id: 1, name: null, availability_status: 'offline' },
-        { id: 2, name: 'Zoe', availability_status: 'offline' },
-      ];
-
-      expect(() => getAgentsByAvailability(agents, 'offline')).not.toThrow();
-      expect(
-        getAgentsByAvailability(agents, 'offline').map(agent => agent.id)
-      ).toEqual([1, 2]);
-    });
   });
 
   describe('getSortedAgentsByAvailability', () => {

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

@@ -156,18 +156,12 @@ describe('templateHelper', () => {
       ]);
     });
 
-    it('should handle templates with no variables but a media header', () => {
+    it('should handle templates with no variables', () => {
       const emptyTemplate = templates.find(
         t => t.name === 'no_variable_template'
       );
-      const result = buildTemplateParameters(emptyTemplate);
-      // hasMediaHeader is derived from the template, so the document header is kept.
-      expect(result.body).toBeUndefined();
-      expect(result.header).toEqual({
-        media_url: '',
-        media_type: 'document',
-        media_name: '',
-      });
+      const result = buildTemplateParameters(emptyTemplate, false);
+      expect(result).toEqual({});
     });
 
     it('should build parameters for templates with multiple component types', () => {

app/javascript/dashboard/helper/templateHelper.js

@@ -1,16 +1,19 @@
-import { processVariable, buildWhatsAppProcessedParams } from '@chatwoot/utils';
-
-// Constants and pure template helpers are shared with the mobile app via
-// @chatwoot/utils so the logic lives in one place.
-export {
-  MEDIA_FORMATS,
-  COMPONENT_TYPES,
-  findComponentByType,
-  processVariable,
-} from '@chatwoot/utils';
-
+// Constants
 export const DEFAULT_LANGUAGE = 'en';
 export const DEFAULT_CATEGORY = 'UTILITY';
+export const COMPONENT_TYPES = {
+  HEADER: 'HEADER',
+  BODY: 'BODY',
+  BUTTONS: 'BUTTONS',
+};
+export const MEDIA_FORMATS = ['IMAGE', 'VIDEO', 'DOCUMENT'];
+
+export const findComponentByType = (template, type) =>
+  template.components?.find(component => component.type === type);
+
+export const processVariable = str => {
+  return str.replace(/{{|}}/g, '');
+};
 
 export const allKeysRequired = value => {
   const keys = Object.keys(value);
@@ -24,7 +27,70 @@ export const replaceTemplateVariables = (templateText, processedParams) => {
   });
 };
 
-// The media-header flag is derived from the template inside the shared helper;
-// the second argument is kept for backwards-compatible call sites.
-export const buildTemplateParameters = template =>
-  buildWhatsAppProcessedParams(template);
+export const buildTemplateParameters = (template, hasMediaHeaderValue) => {
+  const allVariables = {};
+
+  const bodyComponent = findComponentByType(template, COMPONENT_TYPES.BODY);
+  const headerComponent = findComponentByType(template, COMPONENT_TYPES.HEADER);
+
+  if (!bodyComponent) return allVariables;
+
+  const templateString = bodyComponent.text;
+
+  // Process body variables
+  const matchedVariables = templateString.match(/{{([^}]+)}}/g);
+  if (matchedVariables) {
+    allVariables.body = {};
+    matchedVariables.forEach(variable => {
+      const key = processVariable(variable);
+      allVariables.body[key] = '';
+    });
+  }
+
+  if (hasMediaHeaderValue) {
+    if (!allVariables.header) allVariables.header = {};
+    allVariables.header.media_url = '';
+    allVariables.header.media_type = headerComponent.format.toLowerCase();
+
+    // For document templates, include media_name field for filename support
+    if (headerComponent.format.toLowerCase() === 'document') {
+      allVariables.header.media_name = '';
+    }
+  }
+
+  // Process button variables
+  const buttonComponents = template.components.filter(
+    component => component.type === COMPONENT_TYPES.BUTTONS
+  );
+
+  buttonComponents.forEach(buttonComponent => {
+    if (buttonComponent.buttons) {
+      buttonComponent.buttons.forEach((button, index) => {
+        // Handle URL buttons with variables
+        if (button.type === 'URL' && button.url && button.url.includes('{{')) {
+          const buttonVars = button.url.match(/{{([^}]+)}}/g) || [];
+          if (buttonVars.length > 0) {
+            if (!allVariables.buttons) allVariables.buttons = [];
+            allVariables.buttons[index] = {
+              type: 'url',
+              parameter: '',
+              url: button.url,
+              variables: buttonVars.map(v => processVariable(v)),
+            };
+          }
+        }
+
+        // Handle copy code buttons
+        if (button.type === 'COPY_CODE') {
+          if (!allVariables.buttons) allVariables.buttons = [];
+          allVariables.buttons[index] = {
+            type: 'copy_code',
+            parameter: '',
+          };
+        }
+      });
+    }
+  });
+
+  return allVariables;
+};

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

@@ -28,35 +28,6 @@
           "PLACEHOLDER": "Please select one",
           "ERROR": "Event is required"
         },
-        "EXECUTE": {
-          "LABEL": "Delayed execution",
-          "AFTER_DELAY": "Run after",
-          "UNITS": {
-            "MINUTES": "Minutes",
-            "HOURS": "Hours",
-            "DAYS": "Days"
-          },
-          "ERROR": "Delay must be between 10 minutes and 30 days",
-          "ENDS_IF_LABEL": "Won't run if",
-          "ENDS_IF": {
-            "STATUS": "the conversation's status changes, or its conditions no longer match.",
-            "CUSTOMER_REPLY": "the customer replies, or the conditions no longer match.",
-            "AGENT_REPLY": "an agent replies, or the conditions no longer match.",
-            "GENERIC": "there is a new reply on the conversation, or the conditions no longer match."
-          },
-          "HELP_TEXT": "Only applies to conversations with activity after the rule is created."
-        },
-        "TRIGGER": {
-          "LABEL": "Trigger",
-          "WHEN_LABEL": "When",
-          "STATUS_LABEL": "Status is",
-          "INBOX_LABEL": "Inbox",
-          "OPTIONS": {
-            "CUSTOMER_UNRESPONSIVE": "Customer unresponsive",
-            "AGENT_UNRESPONSIVE": "Teammate unresponsive",
-            "CONVERSATION_STATUS": "Conversation in a status"
-          }
-        },
         "CONDITIONS": {
           "LABEL": "Conditions"
         },
@@ -78,13 +49,7 @@
         "CREATED_ON": "Created on",
         "ACTIONS": "Actions"
       },
-      "404": "No automation rules found",
-      "SECTIONS": {
-        "INSTANT": "Automations",
-        "DELAYED": "Delayed execution"
-      },
-      "DELAY_BADGE": "Runs after {delay}",
-      "DELAY_DISABLED_BANNER": "Delayed execution is disabled for this account. Delayed rules won't run until it is enabled again."
+      "404": "No automation rules found"
     },
     "DELETE": {
       "TITLE": "Delete Automation Rule",

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

@@ -72,20 +72,6 @@
     "RATING_TITLE": "Rating",
     "FEEDBACK_TITLE": "Feedback",
     "REPLY_MESSAGE_NOT_FOUND": "Message not available",
-    "CAPTAIN_GENERATION": {
-      "TITLE": "How was this reply generated?",
-      "GENERATED_BY": "Generated by Captain",
-      "LOADING": "Loading details…",
-      "EMPTY": "No generation details available for this message.",
-      "TIMELINE": "Generation steps",
-      "STEP_TOOL": "Called {name}",
-      "STEP_HANDOFF": "Handed off to {name}",
-      "REASONING": "Reasoning",
-      "SOURCES": "Knowledge base",
-      "SOURCES_SUMMARY": "{count} result | {count} results",
-      "MODEL": "Generated with {model}",
-      "CREDITS": "Credits: {credits}"
-    },
     "CARD": {
       "SHOW_LABELS": "Show labels",
       "HIDE_LABELS": "Hide labels",

app/javascript/dashboard/routes/dashboard/calls/pages/CallsIndex.vue

@@ -1,6 +1,5 @@
 <script setup>
-import { computed, ref, watch, onMounted } from 'vue';
-import { until } from '@vueuse/core';
+import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute, useRouter } from 'vue-router';
 import { useMapGetter, useStore } from 'dashboard/composables/store';
@@ -50,9 +49,7 @@ const isVoiceEnabled = computed(
 const calls = computed(() => callHistoryStore.records);
 const meta = computed(() => callHistoryStore.meta);
 const isFetching = computed(() => callHistoryStore.uiFlags.isFetching);
-const accountUiFlags = useMapGetter('accounts/getUIFlags');
-
-const isInitializing = ref(true);
+const inboxesUiFlags = useMapGetter('inboxes/getUIFlags');
 
 // Filters are seeded from the URL so a shared link restores the same view.
 const activity = ref(
@@ -101,25 +98,20 @@ const onPageChange = page => {
   fetchCalls();
 };
 
-onMounted(async () => {
-  try {
-    await Promise.all([
-      store.dispatch('inboxes/get'),
-      until(() => accountUiFlags.value.isFetchingItem).toBe(false),
-    ]);
-    if (!isVoiceEnabled.value) return;
-    // Only admins see the assignee filter, so only they need the agent list.
-    if (isAdmin.value) store.dispatch('agents/get');
-    await fetchCalls();
-  } finally {
-    isInitializing.value = false;
-  }
+// inboxes/get flips isFetching true synchronously, so the spinner shows on the
+// first render and the setup CTA never flashes; hit the calls endpoint only
+// once inboxes confirm voice is on.
+store.dispatch('inboxes/get').then(() => {
+  if (!isVoiceEnabled.value) return;
+  // Only admins see the assignee filter, so only they need the agent list.
+  if (isAdmin.value) store.dispatch('agents/get');
+  fetchCalls();
 });
 </script>
 
 <template>
   <div
-    v-if="isInitializing"
+    v-if="inboxesUiFlags.isFetching"
     class="flex items-center justify-center w-full h-full bg-n-surface-1"
   >
     <Spinner :size="24" />

app/javascript/dashboard/routes/dashboard/captain/assistants/overview/Index.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { computed, onUnmounted, ref, watch } from 'vue';
+import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute } from 'vue-router';
 import { FEATURE_FLAGS } from 'dashboard/featureFlags';
@@ -27,49 +27,19 @@ const selectedRange = ref('this_month');
 
 const assistantId = computed(() => route.params.assistantId);
 const stats = ref(null);
-const isFetching = ref(false);
-
-// Increments on every fetch so a response (or retry) from a superseded
-// range/assistant can't clobber the latest request's state.
-let fetchToken = 0;
-let abortController = null;
 
 const fetchStats = async () => {
-  fetchToken += 1;
-  const token = fetchToken;
-  abortController?.abort();
-  abortController = new AbortController();
-  const { signal } = abortController;
-  stats.value = null;
-  isFetching.value = true;
-
-  const requestStats = () =>
-    CaptainAssistant.getStats({
+  try {
+    const { data } = await CaptainAssistant.getStats({
       assistantId: assistantId.value,
       range: selectedRange.value,
-      signal,
     });
-
-  let data = null;
-  try {
-    ({ data } = await requestStats());
+    stats.value = data;
   } catch {
-    // One silent retry before giving up, unless the request was aborted.
-    try {
-      if (token === fetchToken && !signal.aborted)
-        ({ data } = await requestStats());
-    } catch {
-      data = null;
-    }
+    stats.value = null;
   }
-
-  if (token !== fetchToken || signal.aborted) return;
-  stats.value = data;
-  isFetching.value = false;
 };
 
-onUnmounted(() => abortController?.abort());
-
 watch([selectedRange, assistantId], fetchStats, { immediate: true });
 
 // `direction` says whether a rising trend is good ('up'), bad ('down'), or
@@ -186,7 +156,7 @@ const closeDrilldown = () => {
 
         <CoverageBanner :knowledge="stats?.knowledge" />
 
-        <WelcomeCard :range="selectedRange" :stats="stats" />
+        <WelcomeCard :range="selectedRange" />
 
         <div
           class="grid grid-cols-1 gap-px overflow-hidden border rounded-xl sm:grid-cols-2 lg:grid-cols-3 bg-n-weak border-n-weak"
@@ -199,8 +169,7 @@ const closeDrilldown = () => {
             :trend="metric.trend"
             :hint="metric.hint"
             :trend-good="metric.trendGood"
-            :loading="isFetching"
-            :clickable="canDrilldown && Boolean(metric.metric) && !isFetching"
+            :clickable="canDrilldown && Boolean(metric.metric)"
             @click="openDrilldown(metric)"
           />
         </div>

app/javascript/dashboard/routes/dashboard/onboarding/inbox-setup/useChannelConfig.js

@@ -18,7 +18,9 @@ export function useChannelConfig() {
     // app id (not the 'none' sentinel) and the signup configuration id.
     whatsapp: () =>
       (!isOnChatwootCloud.value ||
-        isCloudFeatureEnabled(FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW)) &&
+        isCloudFeatureEnabled(
+          FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION
+        )) &&
       Boolean(installationConfig.whatsappAppId) &&
       installationConfig.whatsappAppId !== 'none' &&
       Boolean(installationConfig.whatsappConfigurationId),

app/javascript/dashboard/routes/dashboard/settings/agentBots/Index.vue

@@ -135,7 +135,7 @@ onMounted(() => {
               <BaseTableCell class="max-w-0">
                 <div class="flex items-center gap-4 min-w-0">
                   <Avatar
-                    :name="bot.name || ''"
+                    :name="bot.name"
                     :src="bot.thumbnail"
                     :size="40"
                     class="flex-shrink-0"

app/javascript/dashboard/routes/dashboard/settings/automation/AddAutomationRule.vue

@@ -10,7 +10,6 @@ const START_VALUE = {
   name: null,
   description: null,
   event_name: 'conversation_created',
-  execution_delay: null,
   conditions: [
     {
       attribute_key: 'status',

app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleForm.vue

@@ -6,11 +6,6 @@ import { useOperators } from 'dashboard/components-next/filter/operators';
 import ConditionRow from 'dashboard/components-next/filter/ConditionRow.vue';
 import AutomationActionInput from 'dashboard/components/widgets/AutomationActionInput.vue';
 import NextButton from 'dashboard/components-next/button/Button.vue';
-import ToggleSwitch from 'dashboard/components-next/switch/Switch.vue';
-import FilterSelect from 'dashboard/components-next/filter/inputs/FilterSelect.vue';
-import MultiSelect from 'dashboard/components-next/filter/inputs/MultiSelect.vue';
-import DurationInput from 'dashboard/components-next/input/DurationInput.vue';
-import { DURATION_UNITS } from 'dashboard/components-next/input/constants';
 import Dialog from 'dashboard/components-next/dialog/Dialog.vue';
 import {
   generateAutomationPayload,
@@ -19,7 +14,6 @@ import {
   showActionInput,
 } from 'dashboard/helper/automationHelper';
 import { validateAutomation } from 'dashboard/helper/validations';
-import { FEATURE_FLAGS } from 'dashboard/featureFlags';
 import { AUTOMATION_RULE_EVENTS, AUTOMATION_ACTION_TYPES } from './constants';
 
 const props = defineProps({
@@ -77,28 +71,6 @@ const INPUT_TYPE_MAP = {
   date: 'date',
 };
 
-const DEFAULT_DELAY_MINUTES = 240; // 4 hours
-const MIN_DELAY_MINUTES = 10;
-const MAX_DELAY_MINUTES = 43200; // 30 days
-// A delayed rule is expressed as one meaningful trigger instead of a raw event + conditions. Each
-// trigger maps to the automation's event_name plus a preset condition: message_type for the two
-// unresponsive cases (reply-chase / awaiting-agent), or a chosen status for conversation_updated.
-const DELAYED_TRIGGERS = [
-  { key: 'conversation_status', eventName: 'conversation_updated' },
-  {
-    key: 'customer_unresponsive',
-    eventName: 'message_created',
-    messageType: 'outgoing',
-  },
-  {
-    key: 'agent_unresponsive',
-    eventName: 'message_created',
-    messageType: 'incoming',
-  },
-];
-const DEFAULT_TRIGGER = DELAYED_TRIGGERS[0].key;
-const DEFAULT_TRIGGER_STATUS = 'pending';
-
 const { t } = useI18n();
 const { isCloudFeatureEnabled } = useAccount();
 const { operators } = useOperators();
@@ -106,7 +78,6 @@ const { operators } = useOperators();
 const dialogRef = ref(null);
 const conditionsRef = useTemplateRef('conditionsRef');
 const errors = ref({});
-const isDelayed = ref(false);
 
 const isEditMode = computed(() => props.mode === 'edit');
 
@@ -213,167 +184,6 @@ const hasActionErrors = computed(() =>
   Object.keys(errors.value).some(key => key.startsWith('action_'))
 );
 
-const allowsDelayedExecution = computed(() =>
-  isCloudFeatureEnabled(FEATURE_FLAGS.DELAYED_AUTOMATIONS)
-);
-
-// Trigger controls for the delayed flow. They own event_name + conditions while the wait is on.
-// selectedTrigger / triggerStatus are plain values (FilterSelect); triggerInboxes is an array of
-// { id, name } (MultiSelect) — empty means the rule applies to every inbox.
-const selectedTrigger = ref(DEFAULT_TRIGGER);
-const triggerStatus = ref(DEFAULT_TRIGGER_STATUS);
-const triggerInboxes = ref([]);
-
-const isStatusTrigger = computed(
-  () => selectedTrigger.value === 'conversation_status'
-);
-
-// FilterSelect expects { label, value }.
-const statusSelectOptions = computed(() =>
-  (props.getConditionDropdownValues('status') || [])
-    .filter(option => option.id !== 'all')
-    .map(option => ({ value: option.id, label: option.name }))
-);
-
-const triggerSelectOptions = computed(() =>
-  DELAYED_TRIGGERS.map(trigger => ({
-    value: trigger.key,
-    label: t(
-      `AUTOMATION.ADD.FORM.TRIGGER.OPTIONS.${trigger.key.toUpperCase()}`
-    ),
-  }))
-);
-
-// MultiSelect expects (and returns) { id, name } options.
-const inboxOptions = computed(
-  () => props.getConditionDropdownValues('inbox_id') || []
-);
-
-// What ends the wait, mirroring the backend episode that arms the rule. Shown to the user so
-// they can predict when the rule runs. Conversation rules key on status; message rules key on
-// the reply that ends the wait (customer reply for outgoing, agent reply for incoming).
-const waitEndsKey = computed(() => {
-  if (eventName.value !== 'message_created') return 'STATUS';
-  const messageType = (automation.value?.conditions || []).find(
-    condition => condition.attribute_key === 'message_type'
-  );
-  const raw = Array.isArray(messageType?.values)
-    ? messageType.values[0]
-    : messageType?.values;
-  // Raw create-mode values are strings ('outgoing'); edit-mode values are option objects.
-  const value = raw && typeof raw === 'object' ? raw.id : raw;
-  if (value === 'outgoing') return 'CUSTOMER_REPLY';
-  if (value === 'incoming') return 'AGENT_REPLY';
-  return 'GENERIC';
-});
-
-// DurationInput holds the wait in minutes and clamps to [MIN, MAX]; the unit is display-only.
-const delayMinutes = ref(DEFAULT_DELAY_MINUTES);
-const delayUnit = ref(DURATION_UNITS.HOURS);
-
-const executionDelayInvalid = computed(
-  () => isDelayed.value && !Number.isFinite(delayMinutes.value)
-);
-
-// Show the wait in the largest whole unit (240 min → 4 hours). Passed in by open() rather than
-// read from `automation`, whose model prop only settles a tick later.
-const syncDelayFromDelay = delay => {
-  isDelayed.value = Boolean(delay);
-  const minutes = delay || DEFAULT_DELAY_MINUTES;
-  if (minutes % 1440 === 0) delayUnit.value = DURATION_UNITS.DAYS;
-  else if (minutes % 60 === 0) delayUnit.value = DURATION_UNITS.HOURS;
-  else delayUnit.value = DURATION_UNITS.MINUTES;
-  delayMinutes.value = minutes;
-};
-
-watch([isDelayed, delayMinutes], () => {
-  if (!automation.value || !allowsDelayedExecution.value) return;
-  automation.value.execution_delay = isDelayed.value
-    ? delayMinutes.value
-    : null;
-});
-
-const buildTriggerCondition = (attributeKey, values) => ({
-  attribute_key: attributeKey,
-  filter_operator: 'equal_to',
-  values,
-  query_operator: 'and',
-  custom_attribute_type: '',
-});
-
-// Write the selected trigger (plus optional inbox scope) onto the rule's event_name + conditions.
-const applyDelayedTrigger = () => {
-  const trigger = DELAYED_TRIGGERS.find(
-    item => item.key === selectedTrigger.value
-  );
-  if (!automation.value || !trigger) return;
-  automation.value.event_name = trigger.eventName;
-  const conditions = [
-    trigger.messageType
-      ? buildTriggerCondition('message_type', trigger.messageType)
-      : buildTriggerCondition('status', triggerStatus.value),
-  ];
-  if (triggerInboxes.value.length) {
-    conditions.push(
-      buildTriggerCondition(
-        'inbox_id',
-        triggerInboxes.value.map(inbox => inbox.id)
-      )
-    );
-  }
-  automation.value.conditions = conditions;
-};
-
-// A single value is a raw string in create mode and an option object ({ id }) after edit-mode
-// formatting; return its plain value either way.
-const rawConditionValue = condition => {
-  const raw = Array.isArray(condition?.values)
-    ? condition.values[0]
-    : condition?.values;
-  return raw && typeof raw === 'object' ? raw.id : raw;
-};
-
-// Populate the trigger controls from an existing delayed rule when editing.
-const hydrateTriggerFromAutomation = () => {
-  const conditions = automation.value?.conditions || [];
-  const byKey = key => conditions.find(c => c.attribute_key === key);
-  const messageType = rawConditionValue(byKey('message_type'));
-  if (messageType === 'incoming') selectedTrigger.value = 'agent_unresponsive';
-  else if (messageType === 'outgoing')
-    selectedTrigger.value = 'customer_unresponsive';
-  else {
-    selectedTrigger.value = 'conversation_status';
-    triggerStatus.value =
-      rawConditionValue(byKey('status')) || DEFAULT_TRIGGER_STATUS;
-  }
-  const inboxValues = byKey('inbox_id')?.values || [];
-  const inboxIds = inboxValues.map(value =>
-    value && typeof value === 'object' ? value.id : value
-  );
-  triggerInboxes.value = inboxOptions.value.filter(inbox =>
-    inboxIds.includes(inbox.id)
-  );
-};
-
-// Turning the wait on (create) sets the default trigger's event + conditions.
-watch(isDelayed, delayed => {
-  if (delayed && automation.value && !isEditMode.value) applyDelayedTrigger();
-});
-
-// Any trigger-control change re-derives event_name + conditions. After hydration this simply
-// re-writes the same values, so it stays idempotent (no reference change → no loop).
-watch([selectedTrigger, triggerStatus, triggerInboxes], () => {
-  if (isDelayed.value) applyDelayedTrigger();
-});
-
-// Opening an existing delayed rule mirrors its event/conditions into the trigger controls.
-watch(
-  () => automation.value,
-  () => {
-    if (isDelayed.value && automation.value) hydrateTriggerFromAutomation();
-  }
-);
-
 watch(
   () => automation.value,
   () => {
@@ -406,9 +216,8 @@ const syncCustomAttributeTypes = () => {
   });
 };
 
-const open = (executionDelay = null) => {
+const open = () => {
   resetValidation();
-  syncDelayFromDelay(executionDelay);
   dialogRef.value?.open();
 };
 
@@ -421,13 +230,8 @@ const emitSaveAutomation = () => {
   syncCustomAttributeTypes();
   const conditionsValid = isConditionsValid();
   errors.value = validateAutomation(automation.value);
-  if (allowsDelayedExecution.value && executionDelayInvalid.value) {
-    errors.value.execution_delay = true;
-  }
   if (Object.keys(errors.value).length === 0 && conditionsValid) {
     const payload = generateAutomationPayload(automation.value);
-    // The API rejects the param when the feature is off; existing values are kept server-side.
-    if (!allowsDelayedExecution.value) delete payload.execution_delay;
     emit('save', payload, props.mode);
   }
 };
@@ -462,163 +266,84 @@ defineExpose({ open, close });
         :error="errors.description ? $t('AUTOMATION.ADD.FORM.DESC.ERROR') : ''"
         :placeholder="$t('AUTOMATION.ADD.FORM.DESC.PLACEHOLDER')"
       />
-      <!-- Wait Start (choose the delay first, then the trigger) -->
-      <div v-if="allowsDelayedExecution" class="mb-6">
-        <div class="flex items-center justify-between gap-4">
-          <label class="mb-0" :class="{ error: errors.execution_delay }">
-            {{ $t('AUTOMATION.ADD.FORM.EXECUTE.LABEL') }}
-          </label>
-          <ToggleSwitch v-model="isDelayed" />
-        </div>
-        <div v-if="isDelayed" class="flex flex-wrap items-center gap-2 mt-2">
-          <span class="text-sm text-n-slate-11">
-            {{ $t('AUTOMATION.ADD.FORM.EXECUTE.AFTER_DELAY') }}
-          </span>
-          <div class="flex items-center gap-2 w-64">
-            <DurationInput
-              v-model="delayMinutes"
-              v-model:unit="delayUnit"
-              :min="MIN_DELAY_MINUTES"
-              :max="MAX_DELAY_MINUTES"
-            />
-          </div>
-        </div>
-        <span
-          v-if="isDelayed && executionDelayInvalid"
-          class="text-xs text-n-ruby-9"
-        >
-          {{ $t('AUTOMATION.ADD.FORM.EXECUTE.ERROR') }}
-        </span>
-      </div>
-      <!-- Wait End -->
-      <!-- Delayed trigger: a curated event + condition, in place of raw Event/Conditions -->
-      <div v-if="isDelayed" class="mb-6">
-        <label class="mb-1">
-          {{ $t('AUTOMATION.ADD.FORM.TRIGGER.LABEL') }}
-        </label>
-        <div
-          class="flex flex-col gap-3 p-4 outline outline-1 -outline-offset-1 rounded-xl outline-n-weak dark:outline-n-strong"
-        >
-          <div class="flex items-center gap-3 min-h-8">
-            <span class="w-20 shrink-0 text-sm text-n-slate-11">
-              {{ $t('AUTOMATION.ADD.FORM.TRIGGER.WHEN_LABEL') }}
-            </span>
-            <FilterSelect
-              v-model="selectedTrigger"
-              :options="triggerSelectOptions"
-            />
-          </div>
-          <div v-if="isStatusTrigger" class="flex items-center gap-3 min-h-8">
-            <span class="w-20 shrink-0 text-sm text-n-slate-11">
-              {{ $t('AUTOMATION.ADD.FORM.TRIGGER.STATUS_LABEL') }}
-            </span>
-            <FilterSelect
-              v-model="triggerStatus"
-              :options="statusSelectOptions"
-            />
-          </div>
-          <div class="flex items-center gap-3 min-h-8">
-            <span class="w-20 shrink-0 text-sm text-n-slate-11">
-              {{ $t('AUTOMATION.ADD.FORM.TRIGGER.INBOX_LABEL') }}
-            </span>
-            <MultiSelect v-model="triggerInboxes" :options="inboxOptions" />
-          </div>
-        </div>
-        <p class="text-xs text-n-slate-11 pt-2 mb-0">
-          <span class="text-n-slate-12 font-medium">
-            {{ $t('AUTOMATION.ADD.FORM.EXECUTE.ENDS_IF_LABEL') }}
-          </span>
-          {{ $t(`AUTOMATION.ADD.FORM.EXECUTE.ENDS_IF.${waitEndsKey}`) }}
-        </p>
-        <p class="text-xs text-n-slate-11 pt-1 mb-0">
-          {{ $t('AUTOMATION.ADD.FORM.EXECUTE.HELP_TEXT') }}
-        </p>
-      </div>
-      <!-- Instant flow: raw Event + Conditions -->
-      <template v-else>
-        <div class="mb-6">
-          <label :class="{ error: errors.event_name }">
-            {{ $t('AUTOMATION.ADD.FORM.EVENT.LABEL') }}
-            <select
-              v-model="automation.event_name"
-              class="m-0"
-              @change="onEventChange()"
+      <div class="mb-6">
+        <label :class="{ error: errors.event_name }">
+          {{ $t('AUTOMATION.ADD.FORM.EVENT.LABEL') }}
+          <select
+            v-model="automation.event_name"
+            class="m-0"
+            @change="onEventChange()"
+          >
+            <option
+              v-for="event in automationRuleEvents"
+              :key="event.key"
+              :value="event.key"
             >
-              <option
-                v-for="event in automationRuleEvents"
-                :key="event.key"
-                :value="event.key"
-              >
-                {{ event.value }}
-              </option>
-            </select>
-            <span v-if="errors.event_name" class="message">
-              {{ $t('AUTOMATION.ADD.FORM.EVENT.ERROR') }}
-            </span>
-          </label>
-          <p
-            v-if="!isEditMode && hasAutomationMutated"
-            class="text-xs text-right text-n-teal-10 pt-1"
-          >
-            {{ $t('AUTOMATION.FORM.RESET_MESSAGE') }}
-          </p>
-        </div>
-        <!-- Conditions Start -->
-        <section class="mb-5">
-          <label>
-            {{ $t('AUTOMATION.ADD.FORM.CONDITIONS.LABEL') }}
-          </label>
-          <ul
-            class="grid gap-4 list-none p-3 mb-4 outline outline-1 rounded-xl -outline-offset-1"
-            :class="
-              hasConditionErrors
-                ? 'outline-n-ruby-5 bg-n-ruby-2/50'
-                : 'outline-n-weak dark:outline-n-strong'
-            "
-          >
-            <template v-for="(condition, i) in automation.conditions" :key="i">
-              <ConditionRow
-                v-if="i === 0"
-                ref="conditionsRef"
-                v-model:attribute-key="automation.conditions[i].attribute_key"
-                v-model:filter-operator="
-                  automation.conditions[i].filter_operator
-                "
-                v-model:values="automation.conditions[i].values"
-                :filter-types="filterTypes"
-                :show-query-operator="false"
-                @remove="removeFilter(i)"
-              />
-              <ConditionRow
-                v-else
-                ref="conditionsRef"
-                v-model:attribute-key="automation.conditions[i].attribute_key"
-                v-model:filter-operator="
-                  automation.conditions[i].filter_operator
-                "
-                v-model:query-operator="
-                  automation.conditions[i - 1].query_operator
-                "
-                v-model:values="automation.conditions[i].values"
-                :filter-types="filterTypes"
-                show-query-operator
-                @remove="removeFilter(i)"
-              />
-            </template>
-            <div>
-              <NextButton
-                icon="i-lucide-plus"
-                blue
-                faded
-                sm
-                :label="$t('AUTOMATION.ADD.CONDITION_BUTTON_LABEL')"
-                @click="appendNewCondition"
-              />
-            </div>
-          </ul>
-        </section>
-        <!-- Conditions End -->
-      </template>
+              {{ event.value }}
+            </option>
+          </select>
+          <span v-if="errors.event_name" class="message">
+            {{ $t('AUTOMATION.ADD.FORM.EVENT.ERROR') }}
+          </span>
+        </label>
+        <p
+          v-if="!isEditMode && hasAutomationMutated"
+          class="text-xs text-right text-n-teal-10 pt-1"
+        >
+          {{ $t('AUTOMATION.FORM.RESET_MESSAGE') }}
+        </p>
+      </div>
+      <!-- Conditions Start -->
+      <section class="mb-5">
+        <label>
+          {{ $t('AUTOMATION.ADD.FORM.CONDITIONS.LABEL') }}
+        </label>
+        <ul
+          class="grid gap-4 list-none p-3 mb-4 outline outline-1 rounded-xl -outline-offset-1"
+          :class="
+            hasConditionErrors
+              ? 'outline-n-ruby-5 bg-n-ruby-2/50'
+              : 'outline-n-weak dark:outline-n-strong'
+          "
+        >
+          <template v-for="(condition, i) in automation.conditions" :key="i">
+            <ConditionRow
+              v-if="i === 0"
+              ref="conditionsRef"
+              v-model:attribute-key="automation.conditions[i].attribute_key"
+              v-model:filter-operator="automation.conditions[i].filter_operator"
+              v-model:values="automation.conditions[i].values"
+              :filter-types="filterTypes"
+              :show-query-operator="false"
+              @remove="removeFilter(i)"
+            />
+            <ConditionRow
+              v-else
+              ref="conditionsRef"
+              v-model:attribute-key="automation.conditions[i].attribute_key"
+              v-model:filter-operator="automation.conditions[i].filter_operator"
+              v-model:query-operator="
+                automation.conditions[i - 1].query_operator
+              "
+              v-model:values="automation.conditions[i].values"
+              :filter-types="filterTypes"
+              show-query-operator
+              @remove="removeFilter(i)"
+            />
+          </template>
+          <div>
+            <NextButton
+              icon="i-lucide-plus"
+              blue
+              faded
+              sm
+              :label="$t('AUTOMATION.ADD.CONDITION_BUTTON_LABEL')"
+              @click="appendNewCondition"
+            />
+          </div>
+        </ul>
+      </section>
+      <!-- Conditions End -->
       <!-- Actions Start -->
       <section>
         <label>

app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleRow.vue

@@ -1,7 +1,6 @@
 <script setup>
 import { computed } from 'vue';
 import { messageStamp } from 'shared/helpers/timeHelper';
-import { formatDelay } from 'dashboard/helper/automationHelper';
 import Button from 'dashboard/components-next/button/Button.vue';
 import ToggleSwitch from 'dashboard/components-next/switch/Switch.vue';
 import { BaseTableRow, BaseTableCell } from 'dashboard/components-next/table';
@@ -44,16 +43,6 @@ const automationActive = computed({
           <span class="text-body-main text-n-slate-12 truncate">
             {{ automation.name }}
           </span>
-          <span
-            v-if="automation.execution_delay"
-            class="text-xs px-1.5 py-0.5 rounded-md bg-n-alpha-2 text-n-slate-11 whitespace-nowrap flex-shrink-0"
-          >
-            {{
-              $t('AUTOMATION.LIST.DELAY_BADGE', {
-                delay: formatDelay(automation.execution_delay),
-              })
-            }}
-          </span>
           <div class="w-px h-3 rounded-lg bg-n-weak flex-shrink-0" />
           <span class="text-body-main text-n-slate-11 truncate">
             {{ automation.description }}

app/javascript/dashboard/routes/dashboard/settings/automation/EditAutomationRule.vue

@@ -34,33 +34,29 @@ const {
 
 const { formatAutomation } = useEditableAutomation();
 
-const syncAutomationFromSelected = (source = props.selectedResponse) => {
-  if (!source?.conditions) return;
-
-  manifestCustomAttributes();
-  automation.value = formatAutomation(
-    source,
-    allCustomAttributes.value,
-    automationTypes,
-    AUTOMATION_ACTION_TYPES
-  );
-};
-
-// Format from the rule passed to open(): the prop updates a tick later, so at open() time
-// automation still holds the previously selected rule (its execution_delay hydrates the form).
-const open = rule => {
-  syncAutomationFromSelected(rule);
-  formRef.value?.open(rule?.execution_delay);
-};
+const open = () => formRef.value?.open();
 const close = () => formRef.value?.close();
 
 const onSave = (payload, mode) => {
   emit('saveAutomation', payload, mode);
 };
 
-watch(() => props.selectedResponse, syncAutomationFromSelected, {
-  immediate: true,
-});
+watch(
+  () => props.selectedResponse,
+  value => {
+    if (!value?.conditions) return;
+
+    manifestCustomAttributes();
+
+    automation.value = formatAutomation(
+      value,
+      allCustomAttributes.value,
+      automationTypes,
+      AUTOMATION_ACTION_TYPES
+    );
+  },
+  { immediate: true }
+);
 
 defineExpose({ open, close });
 </script>

app/javascript/dashboard/routes/dashboard/settings/automation/Index.vue

@@ -35,31 +35,6 @@ const filteredRecords = computed(() => {
   if (!query) return records.value;
   return picoSearch(records.value, query, ['name', 'description']);
 });
-
-// Delayed (wait) rules run on a different lifecycle, so list them in their own section.
-const hasDelayedRecords = computed(() =>
-  records.value.some(automation => automation.execution_delay)
-);
-
-const sections = computed(() => {
-  const instant = [];
-  const delayed = [];
-  filteredRecords.value.forEach(automation =>
-    (automation.execution_delay ? delayed : instant).push(automation)
-  );
-  return [
-    {
-      key: 'instant',
-      label: t('AUTOMATION.LIST.SECTIONS.INSTANT'),
-      items: instant,
-    },
-    {
-      key: 'delayed',
-      label: t('AUTOMATION.LIST.SECTIONS.DELAYED'),
-      items: delayed,
-    },
-  ].filter(section => section.items.length);
-});
 const uiFlags = computed(() => getters['automations/getUIFlags'].value);
 const accountId = computed(() => getters.getCurrentAccountId.value);
 
@@ -77,14 +52,6 @@ const isSLAEnabled = computed(() =>
   getters['accounts/isFeatureEnabledonAccount'].value(accountId.value, 'sla')
 );
 
-const showDelayDisabledBanner = computed(
-  () =>
-    !getters['accounts/isFeatureEnabledonAccount'].value(
-      accountId.value,
-      'delayed_automations'
-    ) && records.value.some(automation => automation.execution_delay)
-);
-
 onMounted(() => {
   store.dispatch('inboxes/get');
   store.dispatch('agents/get');
@@ -107,7 +74,7 @@ const hideAddPopup = () => {
 
 const openEditPopup = response => {
   selectedAutomation.value = { ...response };
-  editDialogRef.value?.open(response);
+  editDialogRef.value?.open();
 };
 const hideEditPopup = () => {
   editDialogRef.value?.close();
@@ -161,11 +128,11 @@ const submitAutomation = async (payload, mode) => {
     hideAddPopup();
     hideEditPopup();
   } catch (error) {
-    const fallbackMessage =
+    const errorMessage =
       mode === 'edit'
         ? t('AUTOMATION.EDIT.API.ERROR_MESSAGE')
         : t('AUTOMATION.ADD.API.ERROR_MESSAGE');
-    useAlert(error?.response?.data?.error || fallbackMessage);
+    useAlert(errorMessage);
   }
 };
 const toggleAutomation = async ({ id, name, status }) => {
@@ -245,49 +212,25 @@ const tableHeaders = computed(() => {
       </BaseSettingsHeader>
     </template>
     <template #body>
-      <div
-        v-if="showDelayDisabledBanner"
-        class="px-4 py-3 mb-4 text-sm rounded-lg bg-n-amber-3 text-n-amber-12"
-      >
-        {{ $t('AUTOMATION.LIST.DELAY_DISABLED_BANNER') }}
-      </div>
-      <template v-if="filteredRecords.length">
-        <div
-          v-for="section in sections"
-          :key="section.key"
-          class="mb-6 last:mb-0"
-        >
-          <h4
-            v-if="hasDelayedRecords"
-            class="mb-2 text-sm font-medium text-n-slate-11"
-          >
-            {{ section.label }}
-          </h4>
-          <BaseTable :headers="tableHeaders" :items="section.items">
-            <template #row="{ items }">
-              <AutomationRuleRow
-                v-for="automation in items"
-                :key="automation.id"
-                :automation="automation"
-                :loading="loading[automation.id]"
-                @clone="cloneAutomation"
-                @toggle="toggleAutomation"
-                @edit="openEditPopup"
-                @delete="openDeletePopup"
-              />
-            </template>
-          </BaseTable>
-        </div>
-      </template>
       <BaseTable
-        v-else
         :headers="tableHeaders"
-        :items="[]"
+        :items="filteredRecords"
         :no-data-message="
           searchQuery ? $t('AUTOMATION.NO_RESULTS') : $t('AUTOMATION.LIST.404')
         "
       >
-        <template #row />
+        <template #row="{ items }">
+          <AutomationRuleRow
+            v-for="automation in items"
+            :key="automation.id"
+            :automation="automation"
+            :loading="loading[automation.id]"
+            @clone="cloneAutomation"
+            @toggle="toggleAutomation"
+            @edit="openEditPopup"
+            @delete="openDeletePopup"
+          />
+        </template>
       </BaseTable>
     </template>
 

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

@@ -1,5 +1,5 @@
 <script setup>
-import { computed } from 'vue';
+import { ref, computed, onMounted } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRouter } from 'vue-router';
 import { useMapGetter } from 'dashboard/composables/store';
@@ -14,7 +14,7 @@ const { accountId, currentAccount } = useAccount();
 
 const globalConfig = useMapGetter('globalConfig/get');
 
-const enabledFeatures = computed(() => currentAccount.value?.features || {});
+const enabledFeatures = ref({});
 
 const hasTiktokConfigured = computed(() => {
   return window.chatwootConfig?.tiktokAppId;
@@ -105,6 +105,10 @@ const channelList = computed(() => {
   return channels;
 });
 
+const initializeEnabledFeatures = async () => {
+  enabledFeatures.value = currentAccount.value.features;
+};
+
 const initChannelAuth = channel => {
   const params = {
     sub_page: channel,
@@ -112,6 +116,10 @@ const initChannelAuth = channel => {
   };
   router.push({ name: 'settings_inboxes_page_channel', params });
 };
+
+onMounted(() => {
+  initializeEnabledFeatures();
+});
 </script>
 
 <template>

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

@@ -390,11 +390,6 @@ export default {
       return (
         this.isAWhatsAppCloudChannel &&
         this.isEmbeddedSignupWhatsApp &&
-        (!this.isOnChatwootCloud ||
-          this.isFeatureEnabledonAccount(
-            this.accountId,
-            FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
-          )) &&
         this.inbox.reauthorization_required
       );
     },

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

@@ -42,7 +42,9 @@ const shouldShowWhatsappEmbeddedSignup = computed(() => {
     selectedProvider.value === PROVIDER_TYPES.WHATSAPP &&
     hasWhatsappAppId.value &&
     (!isOnChatwootCloud.value ||
-      isCloudFeatureEnabled(FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW))
+      isCloudFeatureEnabled(
+        FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION
+      ))
   );
 });
 

app/javascript/dashboard/routes/dashboard/settings/inbox/components/SenderNameExamplePreview.vue

@@ -3,7 +3,6 @@ import { computed } from 'vue';
 import { useI18n } from 'vue-i18n';
 import Avatar from 'next/avatar/Avatar.vue';
 import RadioCard from 'dashboard/components-next/radioCard/RadioCard.vue';
-import { useBranding } from 'shared/composables/useBranding';
 
 const props = defineProps({
   senderNameType: {
@@ -23,7 +22,6 @@ const props = defineProps({
 const emit = defineEmits(['update']);
 
 const { t } = useI18n();
-const { replaceInstallationName } = useBranding();
 
 const senderNameKeyOptions = computed(() => [
   {
@@ -32,7 +30,7 @@ const senderNameKeyOptions = computed(() => [
     content: t('INBOX_MGMT.EDIT.SENDER_NAME_SECTION.FRIENDLY.SUBTITLE'),
     preview: {
       senderName: 'Smith',
-      businessName: replaceInstallationName('Chatwoot'),
+      businessName: 'Chatwoot',
       email: '<support@yourbusiness.com>',
     },
   },
@@ -42,7 +40,7 @@ const senderNameKeyOptions = computed(() => [
     content: t('INBOX_MGMT.EDIT.SENDER_NAME_SECTION.PROFESSIONAL.SUBTITLE'),
     preview: {
       senderName: '',
-      businessName: replaceInstallationName('Chatwoot'),
+      businessName: 'Chatwoot',
       email: '<support@yourbusiness.com>',
     },
   },
@@ -53,7 +51,7 @@ const isKeyOptionFriendly = key => key === 'friendly';
 const userName = keyOption =>
   isKeyOptionFriendly(keyOption.key)
     ? keyOption.preview.senderName
-    : props.businessName || keyOption.preview.businessName;
+    : keyOption.preview.businessName;
 
 const toggleSenderNameType = key => {
   emit('update', key);

app/javascript/dashboard/routes/dashboard/settings/inbox/settingsPage/ConfigurationPage.vue

@@ -56,7 +56,6 @@ export default {
     ...mapGetters({
       accountId: 'getCurrentAccountId',
       isFeatureEnabledonAccount: 'accounts/isFeatureEnabledonAccount',
-      isOnChatwootCloud: 'globalConfig/isOnChatwootCloud',
     }),
     isEmbeddedSignupWhatsApp() {
       return this.inbox.provider_config?.source === 'embedded_signup';
@@ -66,9 +65,7 @@ export default {
         this.isEmbeddedSignupWhatsApp &&
         this.isFeatureEnabledonAccount(
           this.accountId,
-          this.isOnChatwootCloud
-            ? FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
-            : FEATURE_FLAGS.WHATSAPP_RECONFIGURE
+          FEATURE_FLAGS.WHATSAPP_RECONFIGURE
         )
       );
     },

app/javascript/dashboard/store/captain/agentSessions.js

@@ -1,62 +0,0 @@
-import CaptainAgentSessionsAPI from 'dashboard/api/captain/agentSessions';
-import camelcaseKeys from 'camelcase-keys';
-
-const SET_SESSION = 'SET_SESSION';
-const SET_FETCHING = 'SET_FETCHING';
-
-// Session capture runs right after the message is broadcast (and well after,
-// for handoff notes created mid-run), so a 404 on a fresh message may just
-// mean the session isn't written yet. Skip caching those so a later
-// hover/click retries; older misses are permanent (V1 messages, failed runs).
-const RECENT_MESSAGE_WINDOW_SECONDS = 60;
-
-// Caches Captain agent-session metadata per message id. A missing session
-// (404) is cached as null so the UI shows an empty state without refetching.
-export default {
-  namespaced: true,
-  state: {
-    sessions: {},
-    fetchingIds: [],
-  },
-  getters: {
-    getSessionByMessageId: state => messageId => state.sessions[messageId],
-    isFetching: state => messageId => state.fetchingIds.includes(messageId),
-    hasFetched: state => messageId => messageId in state.sessions,
-  },
-  actions: {
-    fetch: async ({ state, commit }, { messageId, createdAt }) => {
-      if (messageId in state.sessions) return;
-      if (state.fetchingIds.includes(messageId)) return;
-
-      commit(SET_FETCHING, { messageId, isFetching: true });
-      try {
-        const { data } = await CaptainAgentSessionsAPI.show(messageId);
-        commit(SET_SESSION, {
-          messageId,
-          session: camelcaseKeys(data, { deep: true }),
-        });
-      } catch (error) {
-        const isRecentMessage =
-          createdAt &&
-          Date.now() / 1000 - createdAt < RECENT_MESSAGE_WINDOW_SECONDS;
-        // Only a 404 means "no session exists"; transient failures (5xx,
-        // network errors) stay uncached so a later hover retries.
-        if (error.response?.status === 404 && !isRecentMessage) {
-          commit(SET_SESSION, { messageId, session: null });
-        }
-      } finally {
-        commit(SET_FETCHING, { messageId, isFetching: false });
-      }
-    },
-  },
-  mutations: {
-    [SET_SESSION](state, { messageId, session }) {
-      state.sessions = { ...state.sessions, [messageId]: session };
-    },
-    [SET_FETCHING](state, { messageId, isFetching }) {
-      state.fetchingIds = isFetching
-        ? [...state.fetchingIds, messageId]
-        : state.fetchingIds.filter(id => id !== messageId);
-    },
-  },
-};

app/javascript/dashboard/store/index.js

@@ -50,7 +50,6 @@ import teamMembers from './modules/teamMembers';
 import teams from './modules/teams';
 import userNotificationSettings from './modules/userNotificationSettings';
 import webhooks from './modules/webhooks';
-import captainAgentSessions from './captain/agentSessions';
 import captainAssistants from './captain/assistant';
 import captainDocuments from './captain/document';
 import captainResponses from './captain/response';
@@ -116,7 +115,6 @@ export default createStore({
     teams,
     userNotificationSettings,
     webhooks,
-    captainAgentSessions,
     captainAssistants,
     captainDocuments,
     captainResponses,

app/javascript/dashboard/store/modules/inboxes.js

@@ -7,7 +7,6 @@ import FBChannel from '../../api/channel/fbChannel';
 import TwilioChannel from '../../api/channel/twilioChannel';
 import WhatsappChannel from '../../api/channel/whatsappChannel';
 import { throwErrorMessage } from '../utils/api';
-import { isSendableTemplate } from '@chatwoot/utils';
 import AnalyticsHelper from '../../helper/AnalyticsHelper';
 import camelcaseKeys from 'camelcase-keys';
 import { ACCOUNT_EVENTS } from '../../helper/AnalyticsHelper/events';
@@ -68,8 +67,45 @@ export const getters = {
       return [];
     }
 
-    // Sendable-template filtering is shared with the mobile app via @chatwoot/utils.
-    return templates.filter(isSendableTemplate);
+    return templates.filter(template => {
+      // Ensure template has required properties
+      if (!template || !template.status || !template.components) {
+        return false;
+      }
+
+      // Only show approved templates
+      if (template.status.toLowerCase() !== 'approved') {
+        return false;
+      }
+
+      // Filter out authentication templates
+      if (template.category === 'AUTHENTICATION') {
+        return false;
+      }
+
+      // Filter out CSAT templates (customer_satisfaction_survey and its versions)
+      if (
+        template.name &&
+        template.name.startsWith('customer_satisfaction_survey')
+      ) {
+        return false;
+      }
+
+      // Filter out interactive templates (LIST, PRODUCT, CATALOG), location templates, and call permission templates
+      const hasUnsupportedComponents = template.components.some(
+        component =>
+          ['LIST', 'PRODUCT', 'CATALOG', 'CALL_PERMISSION_REQUEST'].includes(
+            component.type
+          ) ||
+          (component.type === 'HEADER' && component.format === 'LOCATION')
+      );
+
+      if (hasUnsupportedComponents) {
+        return false;
+      }
+
+      return true;
+    });
   },
   getNewConversationInboxes($state) {
     return $state.records.filter(inbox => {

app/javascript/shared/components/ui/MultiselectDropdown.vue

@@ -68,10 +68,6 @@ const isAgentBot = computed(
   () => props.selectedItem?.assignee_type === 'AgentBot'
 );
 
-const selectedItemName = computed(() =>
-  !props.selectedItem?.name && isAgentBot.value ? '-' : props.selectedItem?.name
-);
-
 const selectedThumbnail = computed(
   () => props.selectedItem?.thumbnail || props.selectedItem?.avatar_url
 );
@@ -99,16 +95,16 @@ const selectedThumbnail = computed(
           <h4
             v-else
             class="items-center overflow-hidden text-sm leading-tight whitespace-nowrap text-ellipsis text-n-slate-12"
-            :title="selectedItemName"
+            :title="selectedItem.name"
           >
-            {{ selectedItemName }}
+            {{ selectedItem.name }}
           </h4>
         </div>
         <Avatar
           v-if="hasValue && hasThumbnail && (isAgentBot || !hasIcon)"
           :src="selectedThumbnail"
           :status="selectedItem.availability_status"
-          :name="selectedItemName"
+          :name="selectedItem.name"
           :icon-name="isAgentBot ? 'i-lucide-bot' : undefined"
           :size="24"
           hide-offline-status

app/javascript/shared/components/ui/MultiselectDropdownItems.vue

@@ -53,9 +53,7 @@ export default {
   computed: {
     filteredOptions() {
       return this.options.filter(option => {
-        return (option.name || '')
-          .toLowerCase()
-          .includes(this.search.toLowerCase());
+        return option.name.toLowerCase().includes(this.search.toLowerCase());
       });
     },
     noResult() {

app/javascript/shared/composables/specs/useBranding.spec.js

@@ -73,13 +73,13 @@ describe('useBranding', () => {
       expect(result).toBe('Welcome to our platform');
     });
 
-    it('should replace "Chatwoot" regardless of casing', () => {
+    it('should be case-sensitive for "Chatwoot"', () => {
       const { replaceInstallationName } = useBranding();
       const result = replaceInstallationName(
-        'Welcome to chatwoot, Chatwoot and CHATWOOT'
+        'Welcome to chatwoot and CHATWOOT'
       );
 
-      expect(result).toBe('Welcome to MyCompany, MyCompany and MyCompany');
+      expect(result).toBe('Welcome to chatwoot and CHATWOOT');
     });
 
     it('should handle special characters in installation name', () => {

app/javascript/shared/composables/useBranding.js

@@ -7,8 +7,7 @@ import { useMapGetter } from 'dashboard/composables/store.js';
 export function useBranding() {
   const globalConfig = useMapGetter('globalConfig/get');
   /**
-   * Replaces "Chatwoot" (any casing) in text with the installation name from
-   * global config
+   * Replaces "Chatwoot" in text with the installation name from global config
    * @param {string} text - The text to process
    * @returns {string} - Text with "Chatwoot" replaced by installation name
    */
@@ -18,7 +17,7 @@ export function useBranding() {
     const installationName = globalConfig.value?.installationName;
     if (!installationName) return text;
 
-    return text.replace(/chatwoot/gi, installationName);
+    return text.replace(/Chatwoot/g, installationName);
   };
 
   return {

app/jobs/automation_rules/process_pending_execution_job.rb

@@ -1,65 +0,0 @@
-class AutomationRules::ProcessPendingExecutionJob < ApplicationJob
-  queue_as :medium
-
-  discard_on ActiveJob::DeserializationError
-
-  def perform(pending_execution)
-    return if delayed_automations_disabled?
-    # Account flag off pauses (not skips): leave the row pending so re-enabling resumes it.
-    return unless pending_execution.account.feature_enabled?('delayed_automations')
-    # Atomic claim: a duplicate enqueue (overlapping sweep or stale reclaim) loses here and returns.
-    return unless pending_execution.claim!
-
-    skip_reason = skip_reason_for(pending_execution)
-    return pending_execution.update!(status: :skipped, skip_reason: skip_reason) if skip_reason
-
-    execute(pending_execution)
-  rescue StandardError => e
-    # Row stays `processing`; the next sweep reclaims and retries it once the lock goes stale.
-    ChatwootExceptionTracker.new(e, account: pending_execution.account).capture_exception
-  end
-
-  private
-
-  def skip_reason_for(pending_execution)
-    return 'expired' if pending_execution.due_at < AutomationRulePendingExecution::DUE_WINDOW.ago
-
-    structural_skip_reason(pending_execution) || behavioral_skip_reason(pending_execution)
-  end
-
-  def structural_skip_reason(pending_execution)
-    rule = pending_execution.automation_rule
-    return 'rule_inactive' if rule.nil? || !rule.active?
-    return 'conversation_gone' if pending_execution.conversation.nil?
-
-    nil
-  end
-
-  def behavioral_skip_reason(pending_execution)
-    return 'episode_moved' unless pending_execution.episode_current?
-    return AutomationRulePendingExecution::CONDITIONS_CHANGED_SKIP unless conditions_still_match?(pending_execution)
-
-    nil
-  end
-
-  def conditions_still_match?(pending_execution)
-    AutomationRules::ConditionsFilterService.new(
-      pending_execution.automation_rule,
-      pending_execution.conversation,
-      { message: pending_execution.message }
-    ).perform.present?
-  end
-
-  def execute(pending_execution)
-    AutomationRules::ActionService.new(
-      pending_execution.automation_rule,
-      pending_execution.account,
-      pending_execution.conversation
-    ).perform
-    pending_execution.update!(status: :executed)
-  end
-
-  def delayed_automations_disabled?
-    GlobalConfig.get('DISABLE_DELAYED_AUTOMATIONS')['DISABLE_DELAYED_AUTOMATIONS']
-  end
-end

app/jobs/automation_rules/resume_paused_executions_job.rb

@@ -1,11 +0,0 @@
-class AutomationRules::ResumePausedExecutionsJob < ApplicationJob
-  # Enqueued the moment the account flag flips back on, ahead of the next sweep, so overdue rows
-  # are rescheduled before that sweep's per-row jobs could mark them expired.
-  queue_as :medium
-
-  discard_on ActiveJob::DeserializationError
-
-  def perform(account)
-    AutomationRulePendingExecution.reschedule_paused(account)
-  end
-end

app/jobs/automation_rules/trigger_pending_executions_job.rb

@@ -1,32 +0,0 @@
-class AutomationRules::TriggerPendingExecutionsJob < ApplicationJob
-  queue_as :scheduled_jobs
-
-  DEFAULT_SWEEP_LIMIT = 1000
-
-  def perform
-    return if delayed_automations_disabled?
-
-    started_at = Time.current
-    purged = AutomationRulePendingExecution.purge_terminal!
-
-    rows = AutomationRulePendingExecution.sweepable.for_enabled_accounts.order(:due_at).limit(sweep_limit).to_a
-    rows.each { |row| AutomationRules::ProcessPendingExecutionJob.perform_later(row) }
-
-    log_summary(enqueued: rows.size, capped: rows.size >= sweep_limit, purged: purged, started_at: started_at)
-  end
-
-  private
-
-  def delayed_automations_disabled?
-    GlobalConfig.get('DISABLE_DELAYED_AUTOMATIONS')['DISABLE_DELAYED_AUTOMATIONS']
-  end
-
-  def sweep_limit
-    (InstallationConfig.find_by(name: 'AUTOMATION_PENDING_EXECUTIONS_SWEEP_LIMIT')&.value || DEFAULT_SWEEP_LIMIT).to_i
-  end
-
-  def log_summary(enqueued:, capped:, purged:, started_at:)
-    summary = { event: 'completed', enqueued: enqueued, capped: capped, purged: purged, duration_ms: ((Time.current - started_at) * 1000).round }
-    Rails.logger.info("[AutomationRules::TriggerPendingExecutionsJob] #{summary.to_json}")
-  end
-end

app/jobs/trigger_scheduled_items_job.rb

@@ -19,9 +19,6 @@ class TriggerScheduledItemsJob < ApplicationJob
 
     # Job to sync whatsapp templates
     Channels::Whatsapp::TemplatesSyncSchedulerJob.perform_later
-
-    # Job to trigger pending executions
-    AutomationRules::TriggerPendingExecutionsJob.perform_later
   end
 end
 

app/jobs/webhooks/whatsapp_events_job.rb

@@ -153,11 +153,11 @@ class Webhooks::WhatsappEventsJob < MutexApplicationJob
   end
 
   def get_channel_from_wb_payload(wb_params)
-    metadata = wb_params[:entry].first[:changes].first.dig(:value, :metadata) || {}
-    Whatsapp::WebhookChannelFinderService.new(
-      display_phone_number: metadata[:display_phone_number],
-      phone_number_id: metadata[:phone_number_id]
-    ).perform
+    phone_number = "+#{wb_params[:entry].first[:changes].first.dig(:value, :metadata, :display_phone_number)}"
+    phone_number_id = wb_params[:entry].first[:changes].first.dig(:value, :metadata, :phone_number_id)
+    channel = Channel::Whatsapp.find_by(phone_number: phone_number)
+    # validate to ensure the phone number id matches the whatsapp channel
+    return channel if channel && channel.provider_config['phone_number_id'] == phone_number_id
   end
 end
 

app/listeners/automation_rule_listener.rb

@@ -30,7 +30,7 @@ class AutomationRuleListener < BaseListener
     rules.each do |rule|
       conditions_match = ::AutomationRules::ConditionsFilterService.new(rule, message.conversation,
                                                                         { message: message, changed_attributes: changed_attributes }).perform
-      execute_rule(rule, account, message.conversation, message: message) if conditions_match.present?
+      ::AutomationRules::ActionService.new(rule, account, message.conversation).perform if conditions_match.present?
     end
   end
 
@@ -52,20 +52,7 @@ class AutomationRuleListener < BaseListener
 
     rules.each do |rule|
       conditions_match = ::AutomationRules::ConditionsFilterService.new(rule, conversation, { changed_attributes: changed_attributes }).perform
-      execute_rule(rule, account, conversation) if conditions_match.present?
-    end
-  end
-
-  # Delayed rules record a pending execution instead of acting; the sweep re-checks and
-  # runs them at due time. Flag off means no arming and no immediate fallback — a delayed
-  # message silently becoming instant is worse than skipping.
-  def execute_rule(rule, account, conversation, message: nil)
-    if rule.execution_delay.present?
-      return unless account.feature_enabled?('delayed_automations')
-
-      AutomationRulePendingExecution.schedule(rule: rule, conversation: conversation, message: message)
-    else
-      ::AutomationRules::ActionService.new(rule, account, conversation).perform
+      AutomationRules::ActionService.new(rule, account, conversation).perform if conditions_match.present?
     end
   end
 

app/models/account.rb

@@ -65,7 +65,6 @@ class Account < ApplicationRecord
   has_many :articles, dependent: :destroy_async, class_name: '::Article'
   has_many :assignment_policies, dependent: :destroy_async
   has_many :automation_rules, dependent: :destroy_async
-  has_many :automation_rule_pending_executions, dependent: :delete_all
   has_many :macros, dependent: :destroy_async
   has_many :campaigns, dependent: :destroy_async
   has_many :canned_responses, dependent: :destroy_async
@@ -112,7 +111,6 @@ class Account < ApplicationRecord
   before_validation :validate_limit_keys
   after_create_commit :notify_creation
   after_update_commit :clear_unread_conversation_counts_cache, if: :saved_change_to_feature_conversation_unread_counts?
-  after_update_commit :resume_delayed_automations, if: -> { saved_change_to_feature_delayed_automations? && feature_delayed_automations? }
   after_destroy :remove_account_sequences
 
   def agents
@@ -191,10 +189,6 @@ class Account < ApplicationRecord
     ::Conversations::UnreadCounts::Store.clear_account!(id)
   end
 
-  def resume_delayed_automations
-    AutomationRules::ResumePausedExecutionsJob.perform_later(self)
-  end
-
   trigger.after(:insert).for_each(:row) do
     "execute format('create sequence IF NOT EXISTS conv_dpid_seq_%s', NEW.id);"
   end

app/models/automation_rule.rb

@@ -2,17 +2,16 @@
 #
 # Table name: automation_rules
 #
-#  id              :bigint           not null, primary key
-#  actions         :jsonb            not null
-#  active          :boolean          default(TRUE), not null
-#  conditions      :jsonb            not null
-#  description     :text
-#  event_name      :string           not null
-#  execution_delay :integer
-#  name            :string           not null
-#  created_at      :datetime         not null
-#  updated_at      :datetime         not null
-#  account_id      :bigint           not null
+#  id          :bigint           not null, primary key
+#  actions     :jsonb            not null
+#  active      :boolean          default(TRUE), not null
+#  conditions  :jsonb            not null
+#  description :text
+#  event_name  :string           not null
+#  name        :string           not null
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  account_id  :bigint           not null
 #
 # Indexes
 #
@@ -22,13 +21,7 @@ class AutomationRule < ApplicationRecord
   include Rails.application.routes.url_helpers
   include Reauthorizable
 
-  EXECUTION_DELAY_RANGE = (10..43_200) # minutes: 10 min to 30 days
-  # Conversation-level delayed rules key their episode on status; only status and attributes
-  # that never change after the delay (inbox) are safe to also filter on.
-  DELAYED_CONVERSATION_ATTRIBUTES = %w[status inbox_id].freeze
-
   belongs_to :account
-  has_many :pending_executions, class_name: 'AutomationRulePendingExecution', dependent: :delete_all
   has_many_attached :files
 
   validate :json_conditions_format
@@ -36,13 +29,8 @@ class AutomationRule < ApplicationRecord
   validate :query_operator_presence
   validate :query_operator_value
   validates :account_id, presence: true
-  validates :execution_delay, numericality: { only_integer: true, in: EXECUTION_DELAY_RANGE }, allow_nil: true
-  validate :execution_delay_supported_conditions
-  validate :execution_delay_supported_event
 
   after_update_commit :reauthorized!, if: -> { saved_change_to_conditions? }
-  # Discard rows armed under the old definition; they re-arm on the next matching event.
-  after_update :discard_stale_pending_executions, if: :execution_config_changed?
 
   scope :active, -> { where(active: true) }
 
@@ -107,34 +95,6 @@ class AutomationRule < ApplicationRecord
     end
   end
 
-  # The fire-time re-check cannot reconstruct changed_attributes, so delayed rules
-  # cannot use attribute_changed conditions.
-  def execution_delay_supported_conditions
-    return if execution_delay.blank? || conditions.blank?
-    return if conditions.none? { |obj| obj['filter_operator'] == 'attribute_changed' }
-
-    errors.add(:execution_delay, 'cannot be used with attribute_changed conditions.')
-  end
-
-  # Conversation-level episodes key on status_changed_at alone. Mutable attributes would collapse
-  # distinct periods into one episode, so only status and immutable filters (inbox) are allowed.
-  def execution_delay_supported_event
-    return if execution_delay.blank? || conditions.blank? || event_name == 'message_created'
-    return if conditions.all? { |obj| DELAYED_CONVERSATION_ATTRIBUTES.include?(obj['attribute_key']) }
-
-    errors.add(:execution_delay, 'only supports status and inbox conditions for conversation-level events.')
-  end
-
-  def execution_config_changed?
-    saved_change_to_execution_delay? || saved_change_to_event_name? ||
-      saved_change_to_conditions? || saved_change_to_actions?
-  end
-
-  def discard_stale_pending_executions
-    # armed = pending + stale processing, which the sweep would otherwise reclaim.
-    pending_executions.armed.delete_all
-  end
-
   def validate_single_condition(condition)
     query_operator = condition['query_operator']
 

app/models/automation_rule_pending_execution.rb

@@ -1,180 +0,0 @@
-# == Schema Information
-#
-# Table name: automation_rule_pending_executions
-#
-#  id                 :bigint           not null, primary key
-#  due_at             :datetime         not null
-#  episode_key        :string           not null
-#  skip_reason        :string
-#  status             :integer          default("pending"), not null
-#  created_at         :datetime         not null
-#  updated_at         :datetime         not null
-#  account_id         :bigint           not null
-#  automation_rule_id :bigint           not null
-#  conversation_id    :bigint           not null
-#  message_id         :bigint
-#
-# Indexes
-#
-#  index_automation_rule_pending_executions_on_account_id          (account_id)
-#  index_automation_rule_pending_executions_on_automation_rule_id  (automation_rule_id)
-#  index_automation_rule_pending_executions_on_conversation_id     (conversation_id)
-#  index_automation_rule_pending_executions_on_status_and_due_at   (status,due_at)
-#  uniq_automation_pending_execution_episode                       (automation_rule_id,conversation_id,episode_key) UNIQUE
-#
-class AutomationRulePendingExecution < ApplicationRecord
-  # Rows older than this never fire (bounds backlog replay after downtime).
-  DUE_WINDOW = 3.days
-  # A processing row whose lock is older than this is treated as abandoned and reclaimed.
-  STALE_PROCESSING_TIMEOUT = 15.minutes
-  # Terminal rows are purged after this to keep the table bounded.
-  RETENTION_WINDOW = 30.days
-  # Skip reason for a row cancelled only because conditions no longer matched at fire time; unlike
-  # other terminal reasons, a later qualifying message can re-arm it (see .schedule).
-  CONDITIONS_CHANGED_SKIP = 'conditions_changed'.freeze
-
-  belongs_to :automation_rule
-  belongs_to :conversation
-  belongs_to :account
-  belongs_to :message, optional: true
-
-  enum status: { pending: 0, processing: 1, executed: 2, skipped: 3 }
-
-  # Rows a sweep should hand to a worker: due pending rows, plus processing rows whose lock went stale.
-  scope :sweepable, lambda {
-    pending.where(due_at: ..Time.current).or(processing.where(updated_at: ...STALE_PROCESSING_TIMEOUT.ago))
-  }
-
-  # Non-terminal rows still bound to fire (a stale processing row is reclaimed by the sweep).
-  scope :armed, -> { where(status: [statuses[:pending], statuses[:processing]]) }
-
-  # Excludes rows whose account paused delayed automations, so one disabled account's backlog
-  # can't fill the sweep limit and starve enabled accounts (paused rows resume on re-enable).
-  scope :for_enabled_accounts, -> { joins(:account).merge(Account.feature_delayed_automations) }
-
-  def self.schedule(rule:, conversation:, message: nil)
-    key = arm_episode_key_for(conversation, message)
-    anchor = arm_anchor_for(conversation, message)
-    create!(
-      automation_rule: rule, conversation: conversation, account_id: conversation.account_id,
-      message_id: message&.id, episode_key: key, due_at: rule.execution_delay.minutes.since(anchor)
-    )
-  rescue ActiveRecord::RecordNotUnique
-    rearm_or_advance_episode(rule, conversation, key, message, anchor)
-  end
-
-  # The episode is already armed. Status episodes keep their first clock (a status change would
-  # give a new key), so only message episodes advance or re-arm here.
-  def self.rearm_or_advance_episode(rule, conversation, key, message, anchor)
-    return unless message
-
-    row = find_by!(automation_rule_id: rule.id, conversation_id: conversation.id, episode_key: key)
-    # Jobs can arrive out of order; only a strictly newer message advances or re-arms, so a late
-    # older message can't pull due_at backwards and fire before the delay elapses.
-    return unless message.id > row.message_id
-
-    due_at = rule.execution_delay.minutes.since(anchor)
-    if row.condition_skipped?
-      # A message episode key can recur (no new incoming reply) while conditions swing back into
-      # match, so a later qualifying message re-arms the condition-only skip instead of dropping.
-      row.update!(status: :pending, skip_reason: nil, due_at: due_at, message_id: message.id)
-    elsif !row.terminal?
-      # Track the newest qualifying message. Reply-chase advances due_at with each agent reply;
-      # awaiting-agent keeps its first clock (its anchor is the stable waiting_since, so due_at is
-      # unchanged). Re-anchoring a row still processing (its worker died mid-run) back to pending
-      # also keeps a stale reclaim from firing the old clock instead of the latest one.
-      row.update!(status: :pending, due_at: due_at, message_id: message.id)
-    end
-  end
-
-  # The wait is measured from when the qualifying event happened, not when this (possibly
-  # backlogged or retried) listener runs, so a late dispatch still fires on schedule. Mirrors
-  # the timestamps the episode keys track.
-  def self.arm_anchor_for(conversation, message)
-    if message.nil?
-      conversation.status_changed_at.presence || conversation.created_at
-    elsif message.incoming?
-      conversation.waiting_since.presence || message.created_at
-    else
-      message.created_at
-    end
-  end
-
-  # waiting_since is written just after MESSAGE_CREATED dispatches, so it can still be nil when
-  # an awaiting-agent episode arms. It becomes the starting message's created_at, so use that
-  # here; the strict fire-time key (episode_key_for) then matches once waiting_since is settled.
-  def self.arm_episode_key_for(conversation, message)
-    return episode_key_for(conversation, message) unless message&.incoming? && conversation.waiting_since.blank?
-
-    "awaiting_agent:#{microsecond_stamp(message.created_at)}"
-  end
-
-  # Microsecond integer, not a float: epoch seconds carry ~16 significant digits, past float64's
-  # precision, so an in-memory timestamp (arm time) and its DB-reloaded value (fire time) would
-  # round to different floats. strftime is exact on both. Sub-second distinguishes rapid episodes.
-  def self.microsecond_stamp(time)
-    time&.strftime('%s%6N') || '0'
-  end
-
-  # Episode keys identify one qualifying stretch of conversation state; when the recomputed
-  # key no longer matches, the episode ended and the pending action is cancelled at fire time.
-  def self.episode_key_for(conversation, message)
-    if message.nil?
-      # Sub-second precision so a resolve→reopen inside one second still ends the episode.
-      # Integer microseconds (not a float) so an in-memory arm and a DB-reloaded fire agree.
-      "status:#{microsecond_stamp(conversation.status_changed_at.presence || conversation.created_at)}"
-    elsif message.incoming?
-      # waiting_since is cleared on agent/bot reply, so a reply invalidates this episode. Strict
-      # here: at fire time a nil waiting_since means the agent replied (episode ended).
-      "awaiting_agent:#{microsecond_stamp(conversation.waiting_since)}"
-    else
-      # A new customer message changes the max incoming id, invalidating this episode.
-      "reply_chase:#{conversation.messages.incoming.maximum(:id) || 0}"
-    end
-  end
-
-  def self.purge_terminal!
-    where(status: [statuses[:executed], statuses[:skipped]], updated_at: ...RETENTION_WINDOW.ago)
-      .in_batches(of: 1000).delete_all
-  end
-
-  # Rows that came due while an account had delayed automations paused would expire the moment
-  # the sweep reaches them on resume. Reset their clock so pause/resume replays them (still
-  # subject to the fire-time episode/condition re-checks) instead of silently dropping them.
-  def self.reschedule_paused(account)
-    overdue = pending.where(account_id: account.id, due_at: ...DUE_WINDOW.ago)
-    overdue.find_each { |row| row.update!(due_at: Time.current) }
-  end
-
-  # Atomic claim: only one worker can move a row into processing, so a row re-enqueued by an
-  # overlapping sweep (or after a stale reclaim) cannot double-execute. Refreshing updated_at
-  # renews the lock, keeping the row out of the stale window while this worker holds it.
-  def claim!
-    with_lock do
-      next false unless claimable?
-
-      update!(status: :processing, updated_at: Time.current)
-      true
-    end
-  end
-
-  def episode_current?
-    self.class.episode_key_for(conversation, message) == episode_key
-  end
-
-  def condition_skipped?
-    skipped? && skip_reason == CONDITIONS_CHANGED_SKIP
-  end
-
-  def terminal?
-    executed? || skipped?
-  end
-
-  private
-
-  def claimable?
-    # due_at guard: a reply-chase reschedule can push due_at forward after this row was enqueued;
-    # such a row must wait for a later sweep instead of firing early.
-    (pending? && due_at <= Time.current) || (processing? && updated_at < STALE_PROCESSING_TIMEOUT.ago)
-  end
-end

app/models/conversation.rb

@@ -15,7 +15,6 @@
 #  priority               :integer
 #  snoozed_until          :datetime
 #  status                 :integer          default("open"), not null
-#  status_changed_at      :datetime
 #  uuid                   :uuid             not null
 #  waiting_since          :datetime
 #  created_at             :datetime         not null
@@ -125,10 +124,8 @@ class Conversation < ApplicationRecord
   has_many :notifications, as: :primary_actor, dependent: :destroy_async
   has_many :attachments, through: :messages
   has_many :reporting_events, dependent: :destroy_async
-  has_many :automation_rule_pending_executions, dependent: :delete_all
 
   before_save :ensure_snooze_until_reset
-  before_save :set_status_changed_at
   before_create :determine_conversation_status
   before_create :ensure_waiting_since
 
@@ -275,10 +272,6 @@ class Conversation < ApplicationRecord
     self.snoozed_until = nil unless snoozed?
   end
 
-  def set_status_changed_at
-    self.status_changed_at = Time.current if new_record? || status_changed?
-  end
-
   def ensure_waiting_since
     self.waiting_since = created_at
   end

app/services/whatsapp/incoming_message_base_service.rb

@@ -113,14 +113,12 @@ class Whatsapp::IncomingMessageBaseService
   end
 
   def set_conversation
-    # Scope reuse to the contact across all its contact_inboxes in this inbox: WhatsApp coexistence
-    # gives one contact multiple source_ids (phone + BSUID), so reopen must not be limited to a single contact_inbox.
-    conversations = @contact.conversations.where(inbox_id: @inbox.id)
     # if lock to single conversation is disabled, we will create a new conversation if previous conversation is resolved
     @conversation = if @inbox.lock_to_single_conversation
-                      conversations.last
+                      @contact_inbox.conversations.last
                     else
-                      conversations.where.not(status: :resolved).last
+                      @contact_inbox.conversations
+                                    .where.not(status: :resolved).last
                     end
     return if @conversation
 

app/services/whatsapp/send_on_whatsapp_service.rb

@@ -6,10 +6,12 @@ class Whatsapp::SendOnWhatsappService < Base::SendOnChannelService
   end
 
   def perform_reply
-    return send_template_message if template_params.present?
-    return send_session_message if message.conversation.can_reply?
-
-    message.update!(status: :failed, external_error: I18n.t('errors.whatsapp.message_outside_messaging_window'))
+    should_send_template_message = template_params.present? || !message.conversation.can_reply?
+    if should_send_template_message
+      send_template_message
+    else
+      send_session_message
+    end
   end
 
   def send_template_message

app/services/whatsapp/webhook_channel_finder_service.rb

@@ -1,35 +0,0 @@
-# Resolves the WhatsApp channel for an inbound WhatsApp Cloud webhook. Meta's
-# display_phone_number can arrive formatted or in a country-specific variant (e.g. Brazil
-# omits the mobile 9, Argentina adds a digit after the country code), so we try the
-# raw digits first and then a normalized fallback, accepting only a candidate whose
-# phone_number_id matches.
-class Whatsapp::WebhookChannelFinderService
-  def initialize(display_phone_number:, phone_number_id:)
-    @display_phone_number = display_phone_number
-    @phone_number_id = phone_number_id
-  end
-
-  def perform
-    return if digits.blank?
-
-    candidates = [
-      Channel::Whatsapp.find_by(phone_number: "+#{digits}"),
-      channel_by_normalized_number
-    ]
-    candidates.compact.find { |channel| channel.provider_config['phone_number_id'] == @phone_number_id }
-  end
-
-  private
-
-  def digits
-    @digits ||= @display_phone_number.to_s.gsub(/[^0-9]/, '')
-  end
-
-  def channel_by_normalized_number
-    normalizer = Whatsapp::PhoneNumberNormalizationService::NORMALIZERS
-                 .lazy.map(&:new).find { |n| n.handles_country?(digits) }
-    return unless normalizer
-
-    Channel::Whatsapp.find_by(phone_number: "+#{normalizer.normalize(digits)}")
-  end
-end

app/views/api/v1/accounts/automation_rules/partials/_automation_rule.json.jbuilder

@@ -7,5 +7,4 @@ json.conditions automation_rule.conditions
 json.actions automation_rule.actions
 json.created_on automation_rule.created_at.to_i
 json.active automation_rule.active?
-json.execution_delay automation_rule.execution_delay
 json.files automation_rule.file_base_data if automation_rule.files.any?

config/features.yml

@@ -265,11 +265,6 @@
   enabled: false
   column: feature_flags_ext_1
 - name: whatsapp_embedded_signup_inbox_creation
-  display_name: WhatsApp Embedded Signup Flow
+  display_name: WhatsApp Embedded Signup Inbox Creation
   enabled: false
   column: feature_flags_ext_1
-- name: delayed_automations
-  display_name: Delayed Automations
-  enabled: false
-  chatwoot_internal: true
-  column: feature_flags_ext_1

config/initializers/rack_attack.rb

@@ -31,11 +31,10 @@ class Rack::Attack
       (default_allowed_ips + env_allowed_ips).include?(remote_ip)
     end
 
-    # Rails allows paths with extensions and trailing slashes, so compare against a normalized path.
-    # For example, /auth, /auth.json, and /auth/ should all use the same throttle.
+    # Rails would allow requests to paths with extensions, so lets compare against the path with extension stripped
+    # example /auth & /auth.json would both work
     def path_without_extensions
-      normalized_path = path[/^[^.]+/]
-      normalized_path == '/' ? normalized_path : normalized_path.sub(%r{/+\z}, '')
+      path[/^[^.]+/]
     end
   end
 
@@ -189,11 +188,6 @@ class Rack::Attack
     throttle('widget?website_token={website_token}&cw_conversation={x-auth-token}', limit: 5, period: 1.hour) do |req|
       req.ip if req.path_without_extensions == '/widget' && ActionDispatch::Request.new(req.env).params['cw_conversation'].blank?
     end
-
-    ## Prevent Transcript Bombing on Widget API ###
-    throttle('api/v1/widget/conversations/transcript', limit: 5, period: 1.hour) do |req|
-      req.ip if req.path_without_extensions == '/api/v1/widget/conversations/transcript' && req.post?
-    end
   end
 
   ##-----------------------------------------------##
@@ -218,24 +212,6 @@ class Rack::Attack
     match_data[:account_id] if match_data.present?
   end
 
-  ## Prevent abuse of agent create APIs (per account, covers bulk_create)
-  throttle('/api/v1/accounts/:account_id/agents POST',
-           limit: ENV.fetch('RATE_LIMIT_AGENT_CREATE', '100').to_i, period: 1.day) do |req|
-    next unless req.post?
-
-    match_data = %r{\A/api/v1/accounts/(?<account_id>\d+)/agents(?:/bulk_create)?/?\z}.match(req.path_without_extensions)
-    match_data[:account_id] if match_data.present?
-  end
-
-  ## Prevent abuse of agent delete API (per account)
-  throttle('/api/v1/accounts/:account_id/agents/:id DELETE',
-           limit: ENV.fetch('RATE_LIMIT_AGENT_DELETE', '50').to_i, period: 1.day) do |req|
-    next unless req.delete?
-
-    match_data = %r{\A/api/v1/accounts/(?<account_id>\d+)/agents/(?<id>\d+)/?\z}.match(req.path_without_extensions)
-    match_data[:account_id] if match_data.present?
-  end
-
   ## Prevent Abuse of attachment upload APIs ##
   throttle('/api/v1/accounts/:account_id/upload', limit: 60, period: 1.hour) do |req|
     match_data = %r{/api/v1/accounts/(?<account_id>\d+)/upload}.match(req.path)

config/installation_config.yml

@@ -567,10 +567,3 @@
   value: 'https://us.cloud.langfuse.com'
   locked: false
 ## ---- End of LLM Observability ---- ##
-
-- name: DISABLE_DELAYED_AUTOMATIONS
-  display_title: 'Disable delayed automations'
-  description: 'Emergency stop for delayed automation rules: halts the pending-execution sweep and per-row execution within one tick'
-  value: false
-  locked: false
-  type: boolean

config/locales/en.yml

@@ -154,7 +154,6 @@ en:
       invalid_token_permissions: 'The access token does not have the required permissions for WhatsApp.'
       phone_info_fetch_failed: 'Failed to fetch phone number information. Please try again.'
       phone_number_already_exists: 'Channel already exists for this phone number: %{phone_number}, please contact support if the error persists'
-      message_outside_messaging_window: 'Message not sent because the WhatsApp 24-hour customer service window is closed and no template parameters were provided. Send an approved template message instead.'
       reauthorization:
         generic: 'Failed to reauthorize WhatsApp. Please try again.'
         not_supported: 'Reauthorization is not supported for this type of WhatsApp channel.'

config/routes.rb

@@ -76,7 +76,6 @@ Rails.application.routes.draw do
               resources :inboxes, only: [:index, :create, :destroy], param: :inbox_id
               resources :scenarios
             end
-            resources :agent_sessions, only: [:show]
             resources :assistant_responses
             resources :message_reports, only: [:create]
             resources :bulk_actions, only: [:create]

db/migrate/20260709060000_add_execution_delay_to_automation_rules.rb

@@ -1,5 +0,0 @@
-class AddExecutionDelayToAutomationRules < ActiveRecord::Migration[7.0]
-  def change
-    add_column :automation_rules, :execution_delay, :integer
-  end
-end

db/migrate/20260709060100_add_status_changed_at_to_conversations.rb

@@ -1,5 +0,0 @@
-class AddStatusChangedAtToConversations < ActiveRecord::Migration[7.0]
-  def change
-    add_column :conversations, :status_changed_at, :datetime
-  end
-end

db/migrate/20260709060200_create_automation_rule_pending_executions.rb

@@ -1,21 +0,0 @@
-class CreateAutomationRulePendingExecutions < ActiveRecord::Migration[7.0]
-  def change
-    create_table :automation_rule_pending_executions do |t|
-      t.references :automation_rule, null: false
-      t.references :conversation, null: false
-      t.references :account, null: false
-      t.bigint :message_id
-      t.datetime :due_at, null: false
-      t.string :episode_key, null: false
-      t.integer :status, null: false, default: 0
-      t.string :skip_reason
-
-      t.timestamps
-    end
-
-    add_index :automation_rule_pending_executions, [:status, :due_at]
-    add_index :automation_rule_pending_executions,
-              [:automation_rule_id, :conversation_id, :episode_key],
-              unique: true, name: 'uniq_automation_pending_execution_episode'
-  end
-end

db/schema.rb

@@ -277,24 +277,6 @@ ActiveRecord::Schema[7.1].define(version: 2026_07_13_184351) do
     t.index ["user_id", "user_type"], name: "user_index"
   end
 
-  create_table "automation_rule_pending_executions", force: :cascade do |t|
-    t.bigint "automation_rule_id", null: false
-    t.bigint "conversation_id", null: false
-    t.bigint "account_id", null: false
-    t.bigint "message_id"
-    t.datetime "due_at", null: false
-    t.string "episode_key", null: false
-    t.integer "status", default: 0, null: false
-    t.string "skip_reason"
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["account_id"], name: "index_automation_rule_pending_executions_on_account_id"
-    t.index ["automation_rule_id", "conversation_id", "episode_key"], name: "uniq_automation_pending_execution_episode", unique: true
-    t.index ["automation_rule_id"], name: "index_automation_rule_pending_executions_on_automation_rule_id"
-    t.index ["conversation_id"], name: "index_automation_rule_pending_executions_on_conversation_id"
-    t.index ["status", "due_at"], name: "index_automation_rule_pending_executions_on_status_and_due_at"
-  end
-
   create_table "automation_rules", force: :cascade do |t|
     t.bigint "account_id", null: false
     t.string "name", null: false
@@ -305,7 +287,6 @@ ActiveRecord::Schema[7.1].define(version: 2026_07_13_184351) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.boolean "active", default: true, null: false
-    t.integer "execution_delay"
     t.index ["account_id"], name: "index_automation_rules_on_account_id"
   end
 
@@ -807,7 +788,6 @@ ActiveRecord::Schema[7.1].define(version: 2026_07_13_184351) do
     t.datetime "waiting_since"
     t.text "cached_label_list"
     t.bigint "assignee_agent_bot_id"
-    t.datetime "status_changed_at"
     t.index ["account_id", "display_id"], name: "index_conversations_on_account_id_and_display_id", unique: true
     t.index ["account_id", "id"], name: "index_conversations_on_id_and_account_id"
     t.index ["account_id", "inbox_id", "status", "assignee_id"], name: "conv_acid_inbid_stat_asgnid_idx"

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

@@ -1,25 +0,0 @@
-class Api::V1::Accounts::Captain::AgentSessionsController < Api::V1::Accounts::BaseController
-  before_action :set_message
-  before_action :authorize_conversation
-
-  def show
-    @agent_session = Current.account.captain_agent_sessions.find_by(result_type: 'Message', result_id: @message.id)
-    return head :not_found if @agent_session.blank?
-
-    @citations = Current.account.captain_assistant_responses
-                        .where(id: @agent_session.faq_ids)
-                        .includes(:documentable)
-    @scenario_titles = Captain::Scenario.where(account_id: Current.account.id, id: @agent_session.scenario_ids)
-                                        .pluck(:id, :title).to_h
-  end
-
-  private
-
-  def set_message
-    @message = Current.account.messages.find(params[:id])
-  end
-
-  def authorize_conversation
-    authorize @message.conversation, :show?
-  end
-end

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

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::AssistantResponsesController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action -> { check_authorization(Captain::Assistant) }
 
   before_action :set_current_page, only: [:index]

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

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action -> { check_authorization(Captain::Assistant) }
 
   before_action :set_assistant, only: [:show, :update, :destroy, :playground, :stats, :summary, :drilldown]
@@ -47,8 +48,7 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
   end
 
   def summary
-    window = Captain::AssistantStatsWindow.new(params[:range], params[:timezone_offset])
-    result = cached_or_generated_summary(window, summary_stats)
+    result = cached_or_generated_summary(Captain::AssistantStatsBuilder.new(@assistant, params[:range], params[:timezone_offset]))
 
     if result[:error]
       render json: { error: result[:error] }, status: :unprocessable_content
@@ -69,8 +69,8 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
     params.permit(:metric, :range, :timezone_offset, :page, :per_page)
   end
 
-  def cached_or_generated_summary(window, stats)
-    cache_key = summary_cache_key(window.range)
+  def cached_or_generated_summary(builder)
+    cache_key = summary_cache_key(builder.range)
     cached = Rails.cache.read(cache_key)
     return cached if cached
 
@@ -78,25 +78,14 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
       account: Current.account,
       assistant: @assistant,
       first_name: Current.user.name.to_s.split.first,
-      stats: stats,
-      period: window.period
+      stats: builder.metrics,
+      period: builder.period
     ).perform
     # Don't cache transient LLM/config failures, otherwise every reload returns 422 for the next hour.
     Rails.cache.write(cache_key, result, expires_in: 1.hour) unless result[:error]
     result
   end
 
-  def summary_stats
-    params.require(:stats).permit(
-      conversations_handled: %i[current],
-      hours_saved: %i[current],
-      auto_resolution_rate: %i[current trend],
-      handoff_rate: %i[current trend],
-      reopen_rate: %i[current trend],
-      knowledge: %i[coverage approved documents]
-    ).to_h.deep_symbolize_keys
-  end
-
   def summary_cache_key(range)
     "captain_overview_summary/#{@assistant.id}/#{Current.user.id}/#{range}/#{Date.current}"
   end

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

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::BulkActionsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action -> { check_authorization(Captain::Assistant) }
   before_action :validate_params
   before_action :type_matches?

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

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::CustomToolsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action :ensure_custom_tools_enabled
   before_action -> { check_authorization(Captain::CustomTool) }
   before_action :set_custom_tool, only: [:show, :update, :destroy]

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

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::DocumentsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action -> { check_authorization(Captain::Assistant) }
 
   before_action :set_current_page, only: [:index]

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

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::InboxesController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action -> { check_authorization(Captain::Assistant) }
 
   before_action :set_assistant

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

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::ScenariosController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action -> { check_authorization(Captain::Scenario) }
   before_action :set_assistant
   before_action :set_scenario, only: [:show, :update, :destroy]

enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb

@@ -1,6 +1,8 @@
 class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseController
+  PERMISSION_REQUEST_THROTTLE = 5.minutes
+
   before_action :set_call, only: %i[show accept reject terminate upload_recording]
-  before_action :set_call_context, only: :initiate
+  before_action :set_conversation, only: :initiate
   before_action :ensure_calling_enabled, only: :initiate
   before_action :ensure_sdp_offer, only: :initiate
   before_action :ensure_contact_phone, only: :initiate
@@ -51,7 +53,7 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
   end
 
   def provider_service
-    @provider_service ||= @inbox.channel.provider_service
+    @provider_service ||= @conversation.inbox.channel.provider_service
   end
 
   def set_call
@@ -59,38 +61,13 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
     authorize @call.conversation, :show?
   end
 
-  def set_call_context
-    params[:conversation_id].present? ? set_context_from_conversation : set_context_from_contact
-  end
-
-  def set_context_from_conversation
+  def set_conversation
     @conversation = Current.account.conversations.find_by!(display_id: params[:conversation_id])
     authorize @conversation, :show?
-    @inbox = @conversation.inbox
-    @contact = @conversation.contact
-  end
-
-  def set_context_from_contact
-    @inbox = Current.account.inboxes.find(params[:inbox_id])
-    authorize @inbox, :show?
-    @contact = Current.account.contacts.find(params[:contact_id])
-    @conversation = conversation_builder.existing_conversation
-    # Authorize the thread the call will land in — after the dial is too late to refuse a ringing call.
-    authorize(@conversation || conversation_builder.new_conversation, :show?)
-  end
-
-  def conversation_builder
-    @conversation_builder ||= Whatsapp::CallConversationBuilder.new(inbox: @inbox, contact: @contact, user: Current.user)
-  end
-
-  # Created only after the dial succeeds, so a failed call leaves no empty thread and there is nothing to
-  # roll back. Re-authorized because a concurrent caller may have created the thread we get back.
-  def open_conversation!
-    (@conversation || conversation_builder.perform!).tap { |conversation| authorize conversation, :show? }
   end
 
   def ensure_calling_enabled
-    channel = @inbox.channel
+    channel = @conversation.inbox.channel
     return if channel.is_a?(Channel::Whatsapp) && channel.voice_enabled?
 
     render_could_not_create_error(I18n.t('errors.whatsapp.calls.not_enabled'))
@@ -103,7 +80,7 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
   end
 
   def ensure_contact_phone
-    return if @contact.phone_number.present?
+    return if @conversation.contact&.phone_number.present?
 
     render_could_not_create_error(I18n.t('errors.whatsapp.calls.contact_phone_required'))
   end
@@ -128,45 +105,92 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
   end
 
   def create_outbound_call
-    # A reused thread unassigned at click time is claimed for the caller (wins over auto-assignment); a
-    # fresh thread (@conversation nil until the dial succeeds) is created already assigned to the caller.
-    claim_for_caller = @conversation.present? && @conversation.assignee_id.nil?
+    contact_phone = @conversation.contact.phone_number.delete('+')
+    # Claim for the caller only if unassigned at trigger time (before the round-trip); wins over auto-assignment.
+    claim_for_caller = @conversation.assignee_id.nil?
 
-    result = provider_service.initiate_call(@contact.phone_number.delete('+'), params[:sdp_offer])
+    result = provider_service.initiate_call(contact_phone, params[:sdp_offer])
     provider_call_id = result.dig('calls', 0, 'id') || result['call_id']
 
-    @conversation = open_conversation!
     @conversation.with_lock { @conversation.update!(assignee: Current.user) } if claim_for_caller
 
-    create_call_record(provider_call_id)
-  end
-
-  def create_call_record(provider_call_id)
-    existing = Current.account.calls.whatsapp.find_by(provider_call_id: provider_call_id)
-    return existing if existing
-
     Current.account.calls.create!(
       provider: :whatsapp, inbox: @conversation.inbox, conversation: @conversation, contact: @conversation.contact,
       provider_call_id: provider_call_id, direction: :outgoing, status: 'ringing',
       accepted_by_agent_id: Current.user.id,
       meta: { 'sdp_offer' => params[:sdp_offer], 'ice_servers' => Call.default_ice_servers }
     )
-  rescue ActiveRecord::RecordNotUnique
-    # A webhook inserted the row between the find_by above and this create; reconcile to it.
-    Current.account.calls.whatsapp.find_by!(provider_call_id: provider_call_id)
   end
 
+  # Meta error 138006 means the contact hasn't opted in yet; send the opt-in
+  # template (throttled, behind a conversation lock to prevent double-send).
   def render_permission_request
-    # Raised mid-dial, so a fresh contact has no thread yet — open one for the opt-in template to land in.
-    @conversation = open_conversation!
-    status = Whatsapp::CallPermissionRequestService.new(conversation: @conversation).perform
+    status = nil
+    @conversation.with_lock do
+      if permission_request_throttled?
+        status = 'permission_pending'
+        next
+      end
+
+      sent = send_permission_request_safely
+      if sent
+        record_permission_request_wamid(sent)
+        emit_permission_requested_activity
+        status = 'permission_requested'
+      else
+        status = 'failed'
+      end
+    end
 
     return render_could_not_create_error(I18n.t('errors.whatsapp.calls.permission_request_failed')) if status == 'failed'
 
     # 422 (not 200) so any client treating 2xx as "call placed" can't mistake
     # the permission-template path for a successful dial. The FE composable
     # detects this status and surfaces the banner instead of throwing.
-    render json: { status: status, conversation_id: @conversation.display_id }, status: :unprocessable_entity
+    render json: { status: status }, status: :unprocessable_entity
+  end
+
+  def permission_request_throttled?
+    last_requested = @conversation.additional_attributes&.dig('call_permission_requested_at')
+    last_requested.present? && Time.zone.parse(last_requested) > PERMISSION_REQUEST_THROTTLE.ago
+  end
+
+  # Treat transport errors as a falsy return so we render 422 rather than 500.
+  def send_permission_request_safely
+    provider_service.send_call_permission_request(
+      @conversation.contact.phone_number.delete('+'),
+      *permission_request_body_args
+    )
+  rescue StandardError => e
+    Rails.logger.warn "[WHATSAPP CALL] permission_request failed: #{e.class} #{e.message}"
+    nil
+  end
+
+  # Pass the inbox-level override only when present so the provider falls back
+  # to the i18n default for inboxes that haven't customized the prompt.
+  def permission_request_body_args
+    custom_body = @conversation.inbox.channel.provider_config&.dig('call_permission_request_body').presence
+    custom_body ? [custom_body] : []
+  end
+
+  def emit_permission_requested_activity
+    content = I18n.t(
+      'conversations.activity.whatsapp_call.permission_requested',
+      contact_name: @conversation.contact.name
+    )
+    ::Conversations::ActivityMessageJob.perform_later(
+      @conversation,
+      { account_id: @conversation.account_id, inbox_id: @conversation.inbox_id, message_type: :activity, content: content }
+    )
+  end
+
+  # Stash the outbound wamid so the reply webhook can match context.id back here.
+  def record_permission_request_wamid(sent)
+    attrs = (@conversation.additional_attributes || {}).merge(
+      'call_permission_requested_at' => Time.current.iso8601,
+      'call_permission_request_message_id' => sent.dig('messages', 0, 'id')
+    )
+    @conversation.update!(additional_attributes: attrs)
   end
 
   def render_call_error(error)

enterprise/app/controllers/twilio/voice_controller.rb

@@ -107,8 +107,8 @@ class Twilio::VoiceController < ApplicationController
     when 'inbound'
       Voice::InboundCallBuilder.perform!(
         inbox: inbox,
-        call_sid: twilio_call_sid,
-        caller: { source_ids: [twilio_from], contact_attributes: { name: twilio_from, phone_number: twilio_from } }
+        from_number: twilio_from,
+        call_sid: twilio_call_sid
       )
     when 'outbound-api', 'outbound-dial'
       sync_outbound_leg(call_sid: twilio_call_sid, direction: twilio_direction)

enterprise/app/models/enterprise/account.rb

@@ -1,9 +1,4 @@
 module Enterprise::Account
-  # Transitional marker for the Captain V1 to V2 rollout. New cloud accounts get
-  # this marker so plan reconciliation can enable V2 for them without upgrading
-  # existing paid accounts. Remove once every account is migrated to V2.
-  CAPTAIN_V2_DEFAULT_ELIGIBLE = 'captain_v2_default_eligible'.freeze
-
   class << self
     def captain_document_sync_intervals
       parse_captain_document_sync_intervals(InstallationConfig.find_by(name: 'CAPTAIN_DOCUMENT_AUTO_SYNC_INTERVALS')&.value)
@@ -107,11 +102,7 @@ module Enterprise::Account
 
   def enable_default_features
     super
-    if ChatwootApp.self_hosted_enterprise?
-      enable_features('captain_integration', 'captain_integration_v2')
-    elsif ChatwootApp.chatwoot_cloud?
-      internal_attributes[CAPTAIN_V2_DEFAULT_ELIGIBLE] = true
-    end
+    enable_features('captain_integration', 'captain_integration_v2') if ChatwootApp.self_hosted_enterprise?
   end
 
   def sync_assignment_features

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

@@ -22,12 +22,13 @@ class Captain::Assistant::SessionCaptureService
 
   def capture!
     model = @assistant.agent_model
+    metadata = context.dig(:state, :cw_metadata) || {}
 
     Captain::AgentSession.create!(
       assistant: @assistant,
       session_type: :assistant,
       subject: @conversation,
-      result: result_message,
+      result: @result_message,
       llm_model: "#{Llm::Models.provider_for(model)}-#{model}",
       credits_consumed: @credits_consumed,
       faq_ids: metadata[:faq_ids] || [],
@@ -43,23 +44,6 @@ class Captain::Assistant::SessionCaptureService
     @run_result.context || {}
   end
 
-  def metadata
-    @metadata ||= context.dig(:state, :cw_metadata) || {}
-  end
-
-  # On handoff, HandoffTool records the private reason note it created; the session
-  # attaches there so agents can inspect the generation path on the note itself.
-  def result_message
-    handoff_note || @result_message
-  end
-
-  def handoff_note
-    note_id = metadata[:handoff_note_id]
-    return if note_id.blank?
-
-    @conversation.messages.find_by(id: note_id)
-  end
-
   def scenario_ids
     ids = current_turn_history.filter_map do |message|
       next unless message[:role].to_s == 'assistant'
@@ -75,11 +59,6 @@ class Captain::Assistant::SessionCaptureService
   def current_turn_history
     history = Array(context[:conversation_history])
     last_user_index = history.rindex { |message| message[:role].to_s == 'user' }
-    current_turn = last_user_index ? history[last_user_index..] : history
-
-    current_turn.map do |message|
-      content = message[:content]
-      content.is_a?(RubyLLM::Content) ? message.merge(content: content.to_h) : message
-    end
+    last_user_index ? history[last_user_index..] : history
   end
 end

enterprise/app/services/enterprise/billing/reconcile_plan_features_service.rb

@@ -13,6 +13,7 @@ class Enterprise::Billing::ReconcilePlanFeaturesService
     channel_instagram
     channel_tiktok
     captain_integration
+    captain_integration_v2
     captain_document_auto_sync
     advanced_search_indexing
     advanced_search
@@ -37,9 +38,7 @@ class Enterprise::Billing::ReconcilePlanFeaturesService
 
   def perform
     account.disable_features(*PREMIUM_PLAN_FEATURES)
-    account.disable_features('captain_integration_v2') if default_plan?
     account.enable_features(*current_plan_features)
-    account.enable_features('captain_integration_v2') if captain_v2_default_eligible?
     account.enable_features(*manually_managed_features)
     account.save!
   end
@@ -72,8 +71,4 @@ class Enterprise::Billing::ReconcilePlanFeaturesService
   def manually_managed_features
     @manually_managed_features ||= Internal::Accounts::InternalAttributesService.new(account).manually_managed_features
   end
-
-  def captain_v2_default_eligible?
-    !default_plan? && account.internal_attributes[Enterprise::Account::CAPTAIN_V2_DEFAULT_ELIGIBLE] == true
-  end
 end

enterprise/app/services/voice/inbound_call_builder.rb

@@ -1,19 +1,17 @@
 class Voice::InboundCallBuilder
-  attr_reader :inbox, :call_sid, :provider, :extra_meta, :source_ids, :contact_attributes
+  attr_reader :inbox, :from_number, :call_sid, :provider, :extra_meta
 
-  # `caller` carries the contact identity: { source_ids:, contact_attributes: }. Twilio passes
-  # its single +phone source_id; WhatsApp passes the message-path phone/user_id/parent_user_id set.
-  def self.perform!(inbox:, call_sid:, caller:, provider: :twilio, extra_meta: {})
-    new(inbox: inbox, call_sid: call_sid, caller: caller, provider: provider, extra_meta: extra_meta).perform!
+  def self.perform!(inbox:, from_number:, call_sid:, provider: :twilio, extra_meta: {})
+    new(inbox: inbox, from_number: from_number, call_sid: call_sid,
+        provider: provider, extra_meta: extra_meta).perform!
   end
 
-  def initialize(inbox:, call_sid:, caller:, provider: :twilio, extra_meta: {})
+  def initialize(inbox:, from_number:, call_sid:, provider: :twilio, extra_meta: {})
     @inbox = inbox
+    @from_number = from_number
     @call_sid = call_sid
     @provider = provider.to_sym
     @extra_meta = extra_meta || {}
-    @source_ids = Array(caller[:source_ids]).compact_blank
-    @contact_attributes = caller[:contact_attributes] || {}
   end
 
   def perform!
@@ -45,17 +43,46 @@ class Voice::InboundCallBuilder
         .find_by(provider: provider, provider_call_id: call_sid)
   end
 
-  # Resolve the contact/ContactInbox the same way inbound messages do — match across every
-  # candidate source_id (phone + BSUID aliases) so a call reuses the existing thread, creating
-  # one keyed on the first (phone, else BSUID) only when none exists. Shared with messaging via
-  # ContactInboxSourceIdResolver, which also rescues the concurrent-webhook create race.
+  # Always look up by (inbox, source_id) first — that pair has a UNIQUE index, so
+  # creating with a colliding source_id under a different contact would raise
+  # RecordNotUnique. Reuse the existing ContactInbox (and its contact) when found.
+  # A concurrent message webhook for the same wa_id can win the (inbox_id, source_id)
+  # race; rescue and re-find so the call path doesn't drop the connect.
   def ensure_contact_inbox!
-    ContactInboxSourceIdResolver.new(
-      inbox: inbox, source_ids: source_ids, contact_attributes: contact_attributes
-    ).perform
+    sid = source_id_for_provider
+    existing = inbox.contact_inboxes.find_by(source_id: sid)
+    return existing if existing
+
+    ContactInbox.create!(contact: ensure_contact!, inbox: inbox, source_id: sid)
+  rescue ActiveRecord::RecordNotUnique
+    inbox.contact_inboxes.find_by!(source_id: sid)
   end
 
-  # Mirror Whatsapp::IncomingMessageBaseService#set_conversation: reuse this row's open conversation (or last when locked), else create.
+  def ensure_contact!
+    contact = account.contacts.find_or_create_by!(phone_number: from_number) do |record|
+      record.name = contact_name.presence || from_number
+    end
+    contact.update!(name: contact_name) if contact_name.present? && contact.name == from_number
+    contact
+  end
+
+  # WhatsApp inbound calls carry the caller's profile name in extra_meta; Twilio
+  # calls don't, so contact naming falls back to the phone number.
+  def contact_name
+    extra_meta['contact_name'].presence
+  end
+
+  # WhatsApp ContactInbox.source_id must be digits-only (the wa_id); Twilio accepts the +.
+  # Run BR/AR-style wa_id normalization (same path messaging uses) so an inbound call
+  # finds the existing ContactInbox instead of forking a new contact/conversation.
+  def source_id_for_provider
+    return from_number unless provider == :whatsapp
+
+    digits = from_number.to_s.delete_prefix('+')
+    Whatsapp::PhoneNumberNormalizationService.new(inbox).normalize_and_find_contact_by_provider(digits, :cloud)
+  end
+
+  # Mirror incoming-message routing: reuse the open conversation (or the last one when locked), else create new.
   def resolve_conversation!(contact, contact_inbox)
     reusable = if inbox.lock_to_single_conversation
                  contact_inbox.conversations.last

enterprise/app/services/whatsapp/call_conversation_builder.rb

@@ -1,32 +0,0 @@
-class Whatsapp::CallConversationBuilder
-  pattr_initialize [:inbox!, :contact!, :user!]
-
-  # Mirrors the continuity rule in Whatsapp::IncomingMessageBaseService#set_conversation.
-  # Locked inboxes hold a contact to one thread, so the caller is refused rather than given a second one.
-  def existing_conversation
-    return contact_conversations.first if inbox.lock_to_single_conversation
-
-    # Only threads the caller can open, else a newest-but-hidden thread would block the call.
-    Conversations::PermissionFilterService.new(
-      contact_conversations.where.not(status: :resolved), user, inbox.account
-    ).perform.first
-  end
-
-  def contact_conversations
-    inbox.conversations.where(contact_id: contact.id).order(last_activity_at: :desc)
-  end
-
-  # Unsaved, so callers can authorize the thread a call would open before dialing.
-  def new_conversation
-    inbox.account.conversations.new(inbox: inbox, contact: contact, assignee_id: user.id, status: :open)
-  end
-
-  # Locked so two agents calling the same fresh contact can't open two threads.
-  def perform!
-    contact_inbox = ContactInboxBuilder.new(contact: contact, inbox: inbox).perform
-
-    contact_inbox.with_lock do
-      existing_conversation || new_conversation.tap { |conversation| conversation.update!(contact_inbox: contact_inbox) }
-    end
-  end
-end

enterprise/app/services/whatsapp/call_permission_request_service.rb

@@ -1,63 +0,0 @@
-# Meta error 138006 means the contact hasn't opted in to calls yet; send the opt-in template.
-class Whatsapp::CallPermissionRequestService
-  THROTTLE = 5.minutes
-
-  pattr_initialize [:conversation!]
-
-  # Locked so two agents calling the same contact can't both send the template.
-  def perform
-    conversation.with_lock do
-      next 'permission_pending' if throttled?
-
-      sent = send_request_safely
-      next 'failed' if sent.blank?
-
-      record_wamid(sent)
-      emit_activity
-      'permission_requested'
-    end
-  end
-
-  private
-
-  def throttled?
-    last_requested = conversation.additional_attributes&.dig('call_permission_requested_at')
-    last_requested.present? && Time.zone.parse(last_requested) > THROTTLE.ago
-  end
-
-  # Treat transport errors as a falsy return so the caller renders 422 rather than 500.
-  def send_request_safely
-    provider_service.send_call_permission_request(conversation.contact.phone_number.delete('+'), *body_args)
-  rescue StandardError => e
-    Rails.logger.warn "[WHATSAPP CALL] permission_request failed: #{e.class} #{e.message}"
-    nil
-  end
-
-  # Pass the inbox-level override only when present so the provider falls back
-  # to the i18n default for inboxes that haven't customized the prompt.
-  def body_args
-    custom_body = conversation.inbox.channel.provider_config&.dig('call_permission_request_body').presence
-    custom_body ? [custom_body] : []
-  end
-
-  def emit_activity
-    content = I18n.t('conversations.activity.whatsapp_call.permission_requested', contact_name: conversation.contact.name)
-    ::Conversations::ActivityMessageJob.perform_later(
-      conversation,
-      { account_id: conversation.account_id, inbox_id: conversation.inbox_id, message_type: :activity, content: content }
-    )
-  end
-
-  # Stash the outbound wamid so the reply webhook can match context.id back here.
-  def record_wamid(sent)
-    attrs = (conversation.additional_attributes || {}).merge(
-      'call_permission_requested_at' => Time.current.iso8601,
-      'call_permission_request_message_id' => sent.dig('messages', 0, 'id')
-    )
-    conversation.update!(additional_attributes: attrs)
-  end
-
-  def provider_service
-    @provider_service ||= conversation.inbox.channel.provider_service
-  end
-end

enterprise/app/services/whatsapp/inbound_call_identity_builder.rb

@@ -1,48 +0,0 @@
-class Whatsapp::InboundCallIdentityBuilder
-  pattr_initialize [:inbox!, :params!]
-
-  # Build the message path's source_id set (phone wa_id -> user_id -> parent_user_id) plus
-  # contact attributes, so the resolver lands a call on the same ContactInbox a message would.
-  # BSUIDs ride in from_user_id/from_parent_user_id (or the contact's user_id/parent_user_id),
-  # never in `from` (the phone wa_id).
-  def perform(payload)
-    contact = caller_contact(payload)
-    phone = contact[:wa_id].presence || payload[:from].presence
-    source_ids = [
-      phone_source_id(phone),
-      payload[:from_user_id].presence || contact[:user_id].presence,
-      payload[:from_parent_user_id].presence || contact[:parent_user_id].presence
-    ].compact_blank.uniq
-    { source_ids: source_ids, contact_attributes: contact_attributes(contact, phone, source_ids.first) }
-  end
-
-  private
-
-  # Normalize the wa_id the same way messaging does so a call matches its stored source_id.
-  def phone_source_id(phone)
-    return unless phone.to_s.match?(/\A\d{1,15}\z/)
-
-    Whatsapp::PhoneNumberNormalizationService.new(inbox).normalize_and_find_contact_by_provider(phone.to_s, :cloud)
-  end
-
-  def contact_attributes(contact, phone, source_identifier)
-    name = contact.dig(:profile, :name).presence || source_identifier
-    return { name: name } unless phone.to_s.match?(/\A\d{1,15}\z/)
-
-    formatted = "+#{phone}"
-    { name: name == phone ? formatted : name, phone_number: formatted }
-  end
-
-  # Match the contacts entry to THIS caller so batched payloads don't borrow another's identity.
-  def caller_contact(payload)
-    Array(params[:contacts]).map(&:with_indifferent_access).find do |c|
-      identifier_match?(c[:wa_id], payload[:from]) ||
-        identifier_match?(c[:user_id], payload[:from_user_id]) ||
-        identifier_match?(c[:parent_user_id], payload[:from_parent_user_id])
-    end || {}.with_indifferent_access
-  end
-
-  def identifier_match?(left, right)
-    left.present? && right.present? && left.to_s == right.to_s
-  end
-end

enterprise/app/services/whatsapp/incoming_call_service.rb

@@ -95,21 +95,28 @@ class Whatsapp::IncomingCallService
   # commit) already terminal, never `ringing` — agents aren't rung for a dead call.
   def build_inbound_call(payload, sdp_offer)
     ActiveRecord::Base.transaction do
-      identity = Whatsapp::InboundCallIdentityBuilder.new(inbox: inbox, params: params).perform(payload)
-      extra_meta = { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
-      call = Voice::InboundCallBuilder.perform!(inbox: inbox, call_sid: payload[:id],
-                                                provider: :whatsapp, extra_meta: extra_meta, caller: identity)
-      sync_caller_identifiers(call, identity)
+      call = Voice::InboundCallBuilder.perform!(inbox: inbox, from_number: "+#{payload[:from]}", call_sid: payload[:id],
+                                                provider: :whatsapp, extra_meta: inbound_extra_meta(payload, sdp_offer))
       tombstone = consume_terminate_tombstone(payload[:id])
       finalize_terminate(call, tombstone['duration'], tombstone['terminate_reason']) if tombstone
       call
     end
   end
 
-  # Backfill every caller alias (the builder only stores the first) so a later event keyed on any one lands on this thread.
-  def sync_caller_identifiers(call, identity)
-    Whatsapp::IdentifierSyncService.new(contact_inbox: call.conversation.contact_inbox, contact: call.contact)
-                                   .perform(source_ids: identity[:source_ids], phone_number: identity.dig(:contact_attributes, :phone_number))
+  def inbound_extra_meta(payload, sdp_offer)
+    extra_meta = { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
+    name = caller_profile_name(payload)
+    extra_meta['contact_name'] = name if name.present?
+    extra_meta
+  end
+
+  # Match strictly on wa_id (== calls[].from): in a batched payload missing this
+  # call's contact entry, borrowing another caller's name would corrupt this
+  # contact, so fall back to the phone number (nil here) instead of contacts.first.
+  def caller_profile_name(payload)
+    contacts = Array(params[:contacts]).map(&:with_indifferent_access)
+    match = contacts.find { |c| c[:wa_id].to_s == payload[:from].to_s }
+    match&.dig(:profile, :name).presence
   end
 
   # `connect` is the WebRTC tunnel-ready signal, not the pickup signal. Apply

enterprise/app/views/api/v1/accounts/captain/agent_sessions/show.json.jbuilder

@@ -1,18 +0,0 @@
-json.id @agent_session.id
-json.message_id @agent_session.result_id
-json.llm_model @agent_session.llm_model
-json.credits_consumed @agent_session.credits_consumed
-json.run_context @agent_session.run_context.is_a?(Array) ? @agent_session.run_context : []
-json.citations @citations do |citation|
-  json.id citation.id
-  json.title citation.question
-  # display_url resolves uploaded PDFs to their blob URL; external_link holds a
-  # "PDF: ..." placeholder for those. Guard on scheme so placeholders render as
-  # plain text instead of dead anchors.
-  link = citation.documentable.is_a?(Captain::Document) ? citation.documentable.display_url : nil
-  json.link link&.match?(%r{\Ahttps?://}) ? link : nil
-end
-json.scenarios @scenario_titles do |id, title|
-  json.id id
-  json.title title
-end

enterprise/app/views/api/v1/accounts/whatsapp_calls/initiate.json.jbuilder

@@ -2,5 +2,4 @@ json.status 'calling'
 json.call_id @call.provider_call_id
 json.id @call.id
 json.message_id @message.id
-json.conversation_id @conversation.display_id
 json.provider 'whatsapp'

enterprise/lib/captain/tools/handoff_tool.rb

@@ -13,7 +13,7 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
                    })
 
     # Use existing handoff mechanism from ResponseBuilderJob
-    trigger_handoff(tool_context, conversation, reason)
+    trigger_handoff(conversation, reason)
 
     "Conversation handed off to human support team#{" (Reason: #{reason})" if reason}"
   rescue StandardError => e
@@ -23,9 +23,9 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
 
   private
 
-  def trigger_handoff(tool_context, conversation, reason)
+  def trigger_handoff(conversation, reason)
     # post the reason as a private note
-    note = conversation.messages.create!(
+    conversation.messages.create!(
       message_type: :outgoing,
       private: true,
       sender: @assistant,
@@ -34,15 +34,6 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
       content: reason
     )
 
-    # Session capture attributes the run to this note so agents can inspect the
-    # generation path on the handoff reason instead of the canned follow-up message.
-    # A reason-less note has no content and never renders in the dashboard, so
-    # leave it unrecorded and let capture fall back to the follow-up message.
-    if reason.present?
-      metadata = tool_context.state[:cw_metadata] ||= {}
-      metadata[:handoff_note_id] = note.id
-    end
-
     # Trigger the bot handoff (sets status to open + dispatches events)
     conversation.bot_handoff!
 

lib/captain/overview_summary_service.rb

@@ -32,7 +32,6 @@ class Captain::OverviewSummaryService < Captain::BaseTaskService
     {
       'first_name' => first_name.to_s,
       'assistant_name' => assistant.name.to_s,
-      'language' => account.locale_english_name,
       'conversations_handled' => current(:conversations_handled),
       'hours_saved' => current(:hours_saved),
       'auto_resolution_rate' => current(:auto_resolution_rate),

lib/integrations/openai/openai_prompts/captain_overview_summary.liquid

@@ -1,8 +1,7 @@
 You are writing a short, warm summary of how an AI support assistant named "{{ assistant_name }}" performed over a reporting period, for {{ first_name }}, the person who manages it.
 
 Voice and format:
-- Write the entire summary in {{ language }}.
-- Address {{ first_name }} directly and open with a short casual greeting to {{ first_name }} in {{ language }}, the natural equivalent of "Hey {{ first_name }},". Never leave the greeting in English when {{ language }} is not English. Be conversational, never robotic.
+- Address {{ first_name }} directly and open with "Hey {{ first_name }},". Be conversational, never robotic.
 - Always call the assistant by its name, {{ assistant_name }}. Never call it "Captain", "the assistant", or "your assistant".
 - This is a static, read-only poster on an analytics dashboard, not a chat. The reader cannot reply or ask you for anything. Never ask a question, invite a reply, offer further help, or say things like "let me know" or "I can dive in".
 - Write 2 to 4 sentences in one short paragraph. Add a second short paragraph only for a genuinely useful heads-up.