Merge branch 'develop' into feat/CW-7403

fix(whatsapp): allow calling a contact with no existing conversation (#15014 )
## Description Agents can now place a WhatsApp call to a contact straight from the contacts screen, even if that contact has never messaged in. Previously the call only worked once a conversation already existed, so a freshly added contact would fail with "Unable to start the call. Please try again." — the only workaround was to get the contact to message the channel first. ## Type of change - [ ] Bug fix (non-breaking change which fixes an issue) ## How Has This Been Tested? - Manually via UI ## Checklist: - [ ] My code follows the style guidelines of this project - [ ] I have performed a self-review of my code - [ ] I have commented on my code, particularly in hard-to-understand areas - [ ] I have made corresponding changes to the documentation - [ ] My changes generate no new warnings - [ ] I have added tests that prove my fix is effective or that my feature works - [ ] New and existing unit tests pass locally with my changes - [ ] Any dependent changes have been merged and published in downstream modules --------- Co-authored-by: Muhsin Keloth <muhsinkeramam@gmail.com>
2026-07-21 19:32:05 +05:30 · 2026-07-21 18:08:32 +05:30 · 2026-07-21 15:05:11 +04:00 · 2026-07-21 16:29:08 +05:30 · 2026-07-21 16:21:40 +05:30 · 2026-07-21 16:19:53 +05:30
61 changed files with 1686 additions and 586 deletions
@@ -1,4 +1,5 @@
 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? }
@@ -18,6 +19,13 @@ 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,
@@ -44,8 +52,7 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
  def can_reconfigure_channel?
    channel = @inbox.channel
    return false unless channel.provider == 'whatsapp_cloud'
-
-    # Reconfiguring a live embedded-signup channel requires the feature flag.
+    return true if ChatwootApp.chatwoot_cloud?
    return Current.account.feature_enabled?('whatsapp_reconfigure') if channel.provider_config['source'] == 'embedded_signup'

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

-  getStats({ assistantId, range }) {
-    return axios.get(`${this.url}/${assistantId}/stats`, {
+  getStats({ assistantId, range, signal }) {
+    const requestConfig = {
      params: { range, timezone_offset: getTimezoneOffset() },
-    });
+    };
+    if (signal) requestConfig.signal = signal;
+
+    return axios.get(`${this.url}/${assistantId}/stats`, requestConfig);
  }

-  getSummary({ assistantId, range }) {
+  getSummary({ assistantId, range, stats }) {
    return axios.get(`${this.url}/${assistantId}/summary`, {
-      params: { range, timezone_offset: getTimezoneOffset() },
+      params: { range, timezone_offset: getTimezoneOffset(), stats },
    });
  }

@@ -10,10 +10,13 @@ class WhatsappCallsAPI extends ApiClient {
    return axios.get(`${this.url}/${callId}`).then(r => r.data);
  }

-  initiate(conversationId, sdpOffer) {
+  // Either conversationId, or contactId + inboxId to let the BE resolve the conversation.
+  initiate({ conversationId, contactId, inboxId }, sdpOffer) {
    return axios
      .post(`${this.url}/initiate`, {
        conversation_id: conversationId,
+        contact_id: contactId,
+        inbox_id: inboxId,
        sdp_offer: sdpOffer,
      })
      .then(r => r.data);
@@ -25,8 +25,11 @@ const route = useRoute();

 const kind = computed(() => getCallKind(props.call));

-const contactName = computed(
-  () => props.call.contact.name || props.call.contact.phoneNumber
+const contactName = computed(() =>
+  (props.call.contact.name || props.call.contact.phoneNumber || '').replace(
+    /^\+/,
+    ''
+  )
 );

 const agentActionLabel = computed(() => {
@@ -1,8 +1,7 @@
 <script setup>
-import { computed, useSlots, ref } from 'vue';
+import { computed } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute } from 'vue-router';
-import { vOnClickOutside } from '@vueuse/components';

 import Button from 'dashboard/components-next/button/Button.vue';
 import Breadcrumb from 'dashboard/components-next/breadcrumb/Breadcrumb.vue';
@@ -23,11 +22,8 @@ const props = defineProps({
 const emit = defineEmits(['goToContactsList', 'toggleBlock']);

 const { t } = useI18n();
-const slots = useSlots();
 const route = useRoute();

-const isContactSidebarOpen = ref(false);
-
 const contactId = computed(() => route.params.contactId);

 const selectedContactName = computed(() => {
@@ -60,26 +56,15 @@ const handleBreadcrumbClick = () => {
 const toggleBlock = () => {
  emit('toggleBlock', isContactBlocked.value);
 };
-
-const handleConversationSidebarToggle = () => {
-  isContactSidebarOpen.value = !isContactSidebarOpen.value;
-};
-
-const closeMobileSidebar = () => {
-  if (!isContactSidebarOpen.value) return;
-  isContactSidebarOpen.value = false;
-};
 </script>

 <template>
  <section
    class="flex w-full h-full overflow-hidden justify-evenly bg-n-surface-1"
  >
-    <div
-      class="flex flex-col w-full h-full transition-all duration-300 ltr:2xl:ml-56 rtl:2xl:mr-56"
-    >
+    <div class="flex flex-col w-full h-full transition-all duration-300">
      <header class="sticky top-0 z-10 px-6 3xl:px-0">
-        <div class="w-full mx-auto max-w-[40.625rem]">
+        <div class="w-full mx-auto max-w-5xl">
          <div
            class="flex flex-col xs:flex-row items-start xs:items-center justify-between w-full py-7 gap-2"
          >
@@ -119,81 +104,10 @@ const closeMobileSidebar = () => {
        </div>
      </header>
      <main class="flex-1 px-6 overflow-y-auto 3xl:px-px">
-        <div class="w-full py-4 mx-auto max-w-[40.625rem]">
+        <div class="w-full py-4 mx-auto max-w-5xl">
          <slot name="default" />
        </div>
      </main>
    </div>
-
-    <!-- Desktop sidebar -->
-    <div
-      v-if="slots.sidebar"
-      class="hidden lg:flex flex-col min-w-52 w-full max-w-md border-l border-n-weak bg-n-solid-2"
-    >
-      <div class="shrink-0">
-        <slot name="sidebarHeader" />
-      </div>
-      <div class="flex-1 min-h-0 overflow-y-auto pb-6 pt-3">
-        <slot name="sidebar" />
-      </div>
-    </div>
-
-    <!-- Mobile sidebar container -->
-    <div
-      v-if="slots.sidebar"
-      class="lg:hidden fixed top-0 ltr:right-0 rtl:left-0 h-full z-50 flex justify-end transition-all duration-200 ease-in-out"
-      :class="isContactSidebarOpen ? 'w-full' : 'w-16'"
-    >
-      <!-- Toggle button -->
-      <div
-        v-on-click-outside="[
-          closeMobileSidebar,
-          { ignore: ['#contact-sidebar-content'] },
-        ]"
-        class="flex items-start p-1 w-fit h-fit relative order-1 xs:top-24 top-28 transition-all bg-n-solid-2 border border-n-weak duration-500 ease-in-out"
-        :class="[
-          isContactSidebarOpen
-            ? 'justify-end ltr:rounded-l-full rtl:rounded-r-full ltr:rounded-r-none rtl:rounded-l-none'
-            : 'justify-center rounded-full ltr:mr-6 rtl:ml-6',
-        ]"
-      >
-        <Button
-          ghost
-          slate
-          sm
-          class="!rounded-full rtl:rotate-180"
-          :class="{ 'bg-n-alpha-2': isContactSidebarOpen }"
-          :icon="
-            isContactSidebarOpen
-              ? 'i-lucide-panel-right-close'
-              : 'i-lucide-panel-right-open'
-          "
-          data-contact-sidebar-toggle
-          @click="handleConversationSidebarToggle"
-        />
-      </div>
-
-      <Transition
-        enter-active-class="transition-transform duration-200 ease-in-out"
-        leave-active-class="transition-transform duration-200 ease-in-out"
-        enter-from-class="ltr:translate-x-full rtl:-translate-x-full"
-        enter-to-class="ltr:translate-x-0 rtl:-translate-x-0"
-        leave-from-class="ltr:translate-x-0 rtl:-translate-x-0"
-        leave-to-class="ltr:translate-x-full rtl:-translate-x-full"
-      >
-        <div
-          v-if="isContactSidebarOpen"
-          id="contact-sidebar-content"
-          class="order-2 w-[85%] sm:w-[50%] flex flex-col bg-n-solid-2 ltr:border-l rtl:border-r border-n-weak shadow-lg"
-        >
-          <div class="shrink-0">
-            <slot name="sidebarHeader" />
-          </div>
-          <div class="flex-1 min-h-0 overflow-y-auto pb-6 pt-3">
-            <slot name="sidebar" />
-          </div>
-        </div>
-      </Transition>
-    </div>
  </section>
 </template>
@@ -5,6 +5,7 @@ import { useMapGetter } from 'dashboard/composables/store';
 import { useUISettings } from 'dashboard/composables/useUISettings';

 import ContactCustomAttributeItem from 'dashboard/components-next/Contacts/ContactsSidebar/ContactCustomAttributeItem.vue';
+import ContactSidebarSection from 'dashboard/components-next/Contacts/ContactsSidebar/ContactSidebarSection.vue';

 const props = defineProps({
  selectedContact: {
@@ -108,8 +109,12 @@ const hasNoUsedAttributes = computed(() => usedAttributes.value.length === 0);
 </script>

 <template>
-  <div v-if="hasContactAttributes" class="flex flex-col gap-6 px-6">
-    <div v-if="!hasNoUsedAttributes" class="flex flex-col gap-2">
+  <ContactSidebarSection
+    v-if="hasContactAttributes"
+    :title="t('CONTACTS_LAYOUT.SIDEBAR.TABS.ATTRIBUTES')"
+    body-class="p-0"
+  >
+    <div v-if="!hasNoUsedAttributes" class="flex flex-col px-4 py-1.5">
      <ContactCustomAttributeItem
        v-for="attribute in usedAttributes"
        :key="attribute.id"
@@ -117,36 +122,43 @@ const hasNoUsedAttributes = computed(() => usedAttributes.value.length === 0);
        :attribute="attribute"
      />
    </div>
-    <div v-if="!hasNoUnusedAttributes" class="flex items-center gap-3">
-      <div class="flex-1 h-[1px] bg-n-slate-5" />
-      <span class="text-sm font-medium text-n-slate-10">{{
-        t('CONTACTS_LAYOUT.SIDEBAR.ATTRIBUTES.UNUSED_ATTRIBUTES', {
-          count: unusedAttributesCount,
-        })
-      }}</span>
-      <div class="flex-1 h-[1px] bg-n-slate-5" />
-    </div>
-    <div class="flex flex-col gap-3">
-      <div v-if="!hasNoUnusedAttributes" class="relative">
-        <span class="absolute i-lucide-search size-3.5 top-2 left-3" />
+
+    <div
+      v-if="!hasNoUnusedAttributes"
+      class="flex flex-col gap-3 px-4 py-4"
+      :class="{ 'border-t border-n-weak': !hasNoUsedAttributes }"
+    >
+      <span
+        class="text-xs font-semibold tracking-wider uppercase text-n-slate-10"
+      >
+        {{
+          t('CONTACTS_LAYOUT.SIDEBAR.ATTRIBUTES.UNUSED_ATTRIBUTES', {
+            count: unusedAttributesCount,
+          })
+        }}
+      </span>
+      <div class="relative">
+        <span
+          class="absolute i-lucide-search size-3.5 top-2.5 left-3 text-n-slate-10"
+        />
        <input
          v-model="searchQuery"
          type="search"
          :placeholder="
            t('CONTACTS_LAYOUT.SIDEBAR.ATTRIBUTES.SEARCH_PLACEHOLDER')
          "
-          class="w-full h-8 py-2 pl-10 pr-2 text-sm reset-base outline-none border-none rounded-lg bg-n-alpha-black2 dark:bg-n-solid-1 text-n-slate-12"
+          class="w-full h-8 py-2 pl-10 pr-2 text-sm border outline-none reset-base rounded-lg border-n-weak bg-n-alpha-black2 dark:bg-n-solid-2 text-n-slate-12"
        />
      </div>
      <div
-        v-if="filteredUnusedAttributes.length === 0 && !hasNoUnusedAttributes"
+        v-if="filteredUnusedAttributes.length === 0"
        class="flex items-center justify-start h-11"
      >
        <p class="text-sm text-n-slate-11">
          {{ t('CONTACTS_LAYOUT.SIDEBAR.ATTRIBUTES.NO_ATTRIBUTES') }}
        </p>
      </div>
-      <div v-if="!hasNoUnusedAttributes" class="flex flex-col gap-2">
+      <div v-else class="flex flex-col">
        <ContactCustomAttributeItem
          v-for="attribute in filteredUnusedAttributes"
          :key="attribute.id"
@@ -154,7 +166,7 @@ const hasNoUsedAttributes = computed(() => usedAttributes.value.length === 0);
        />
      </div>
    </div>
-  </div>
+  </ContactSidebarSection>
  <p v-else class="px-6 py-10 text-sm leading-6 text-center text-n-slate-11">
    {{ t('CONTACTS_LAYOUT.SIDEBAR.ATTRIBUTES.EMPTY_STATE') }}
  </p>
@@ -6,6 +6,7 @@ import { useI18n } from 'vue-i18n';

 import Spinner from 'dashboard/components-next/spinner/Spinner.vue';
 import ConversationCard from 'dashboard/components-next/Conversation/ConversationCard/ConversationCard.vue';
+import ContactSidebarSection from 'dashboard/components-next/Contacts/ContactsSidebar/ContactSidebarSection.vue';

 const { t } = useI18n();
 const route = useRoute();
@@ -34,19 +35,24 @@ const contactConversations = computed(() =>
  >
    <Spinner />
  </div>
-  <div
-    v-else-if="contactConversations.length > 0"
-    class="px-6 divide-y divide-n-strong [&>*:hover]:!border-y-transparent [&>*:hover+*]:!border-t-transparent"
-  >
-    <ConversationCard
-      v-for="conversation in contactConversations"
-      :key="conversation.id"
-      :conversation="conversation"
-      :contact="contactsById(conversation.meta.sender.id)"
-      :state-inbox="stateInbox(conversation.inboxId)"
-      :account-labels="accountLabelsValue"
-      class="rounded-none hover:rounded-xl hover:bg-n-alpha-1 dark:hover:bg-n-alpha-3"
-    />
+  <div v-else-if="contactConversations.length > 0">
+    <ContactSidebarSection
+      :title="t('CONTACTS_LAYOUT.SIDEBAR.TABS.HISTORY')"
+      :count="contactConversations.length"
+      body-class="p-1.5 max-h-[60vh] overflow-y-auto"
+    >
+      <div class="flex flex-col">
+        <ConversationCard
+          v-for="conversation in contactConversations"
+          :key="conversation.id"
+          :conversation="conversation"
+          :contact="contactsById(conversation.meta.sender.id)"
+          :state-inbox="stateInbox(conversation.inboxId)"
+          :account-labels="accountLabelsValue"
+          class="border-0 rounded-xl hover:bg-n-alpha-1 dark:hover:bg-n-alpha-3"
+        />
+      </div>
+    </ContactSidebarSection>
  </div>
  <p v-else class="px-6 py-10 text-sm leading-6 text-center text-n-slate-11">
    {{ t('CONTACTS_LAYOUT.SIDEBAR.HISTORY.EMPTY_STATE') }}
@@ -12,9 +12,10 @@ import GalleryView from 'dashboard/components/widgets/conversation/components/Ga
 import Media from 'dashboard/components-next/SharedAttachments/Media.vue';
 import Files from 'dashboard/components-next/SharedAttachments/Files.vue';
 import Spinner from 'dashboard/components-next/spinner/Spinner.vue';
+import ContactSidebarSection from 'dashboard/components-next/Contacts/ContactsSidebar/ContactSidebarSection.vue';

-const MEDIA_PEEK_LIMIT = 12;
-const FILES_PEEK_LIMIT = 6;
+const MEDIA_PEEK_LIMIT = 10;
+const FILES_PEEK_LIMIT = 4;

 const route = useRoute();
 const router = useRouter();
@@ -73,17 +74,21 @@ onMounted(() => {
 </script>

 <template>
-  <div class="px-6">
+  <div>
    <div v-if="isFetching" class="flex justify-center p-3">
      <Spinner class="size-5" />
    </div>
    <p v-else-if="!hasContent" class="p-3 text-sm text-center text-n-slate-11">
      {{ t('CONVERSATION_SIDEBAR.SHARED_FILES.EMPTY') }}
    </p>
-    <div v-else class="flex flex-col gap-5">
+    <ContactSidebarSection
+      v-else
+      body-class="flex flex-col gap-5 px-4 py-4 max-h-[60vh] overflow-y-auto"
+    >
      <Media
        :attachments="attachments"
        :peek-limit="MEDIA_PEEK_LIMIT"
+        :columns="5"
        show-jump-to-message
        @select="onMediaSelect"
        @jump-to-message="onJumpToMessage"
@@ -95,7 +100,7 @@ onMounted(() => {
        @select="onFileSelect"
        @jump-to-message="onJumpToMessage"
      />
-    </div>
+    </ContactSidebarSection>
    <GalleryView
      v-if="showGallery && selectedAttachment"
      v-model:show="showGallery"
@@ -12,6 +12,7 @@ import { CONTACTS_EVENTS } from 'dashboard/helper/AnalyticsHelper/events';

 import Button from 'dashboard/components-next/button/Button.vue';
 import ContactMergeForm from 'dashboard/components-next/Contacts/ContactsForm/ContactMergeForm.vue';
+import ContactSidebarSection from 'dashboard/components-next/Contacts/ContactsSidebar/ContactSidebarSection.vue';

 const props = defineProps({
  selectedContact: {
@@ -103,43 +104,44 @@ const onMergeContacts = async () => {
 </script>

 <template>
-  <div class="flex flex-col gap-8 px-6">
-    <div class="flex flex-col gap-2">
-      <h4 class="text-base text-n-slate-12">
-        {{ t('CONTACTS_LAYOUT.SIDEBAR.MERGE.TITLE') }}
-      </h4>
+  <div>
+    <ContactSidebarSection
+      :title="t('CONTACTS_LAYOUT.SIDEBAR.MERGE.TITLE')"
+      body-class="flex flex-col gap-5 px-4 py-4"
+    >
      <p class="text-sm text-n-slate-11">
        {{ t('CONTACTS_LAYOUT.SIDEBAR.MERGE.DESCRIPTION') }}
      </p>
-    </div>
-    <ContactMergeForm
-      v-model:primary-contact-id="state.primaryContactId"
-      :selected-contact="selectedContact"
-      :primary-contact-list="primaryContactList"
-      :is-searching="isSearching"
-      :has-error="!!v$.primaryContactId.$error"
-      :error-message="
-        v$.primaryContactId.$error
-          ? t('CONTACTS_LAYOUT.SIDEBAR.MERGE.PRIMARY_REQUIRED_ERROR')
-          : ''
-      "
-      @search="onContactSearch"
-    />
-    <div class="flex items-center justify-between gap-3">
-      <Button
-        variant="faded"
-        color="slate"
-        :label="t('CONTACTS_LAYOUT.SIDEBAR.MERGE.BUTTONS.CANCEL')"
-        class="w-full bg-n-alpha-2 text-n-blue-11 hover:bg-n-alpha-3"
-        @click="resetState"
+      <ContactMergeForm
+        v-model:primary-contact-id="state.primaryContactId"
+        :selected-contact="selectedContact"
+        :primary-contact-list="primaryContactList"
+        :is-searching="isSearching"
+        :has-error="!!v$.primaryContactId.$error"
+        :error-message="
+          v$.primaryContactId.$error
+            ? t('CONTACTS_LAYOUT.SIDEBAR.MERGE.PRIMARY_REQUIRED_ERROR')
+            : ''
+        "
+        @search="onContactSearch"
      />
-      <Button
-        :label="t('CONTACTS_LAYOUT.SIDEBAR.MERGE.BUTTONS.CONFIRM')"
-        class="w-full"
-        :is-loading="isMergingContact"
-        :disabled="isMergingContact"
-        @click="onMergeContacts"
-      />
-    </div>
+      <div class="flex items-center justify-end gap-3">
+        <Button
+          variant="faded"
+          color="slate"
+          size="sm"
+          :label="t('CONTACTS_LAYOUT.SIDEBAR.MERGE.BUTTONS.CANCEL')"
+          class="bg-n-alpha-2 text-n-blue-11 hover:bg-n-alpha-3"
+          @click="resetState"
+        />
+        <Button
+          :label="t('CONTACTS_LAYOUT.SIDEBAR.MERGE.BUTTONS.CONFIRM')"
+          size="sm"
+          :is-loading="isMergingContact"
+          :disabled="isMergingContact"
+          @click="onMergeContacts"
+        />
+      </div>
+    </ContactSidebarSection>
  </div>
 </template>
@@ -1,5 +1,5 @@
 <script setup>
-import { reactive, computed } from 'vue';
+import { reactive, computed, ref } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useStore, useMapGetter } from 'dashboard/composables/store';
 import { useRoute } from 'vue-router';
@@ -8,6 +8,7 @@ import { useKeyboardEvents } from 'dashboard/composables/useKeyboardEvents';
 import Editor from 'dashboard/components-next/Editor/Editor.vue';
 import Spinner from 'dashboard/components-next/spinner/Spinner.vue';
 import Button from 'dashboard/components-next/button/Button.vue';
+import ContactSidebarSection from 'dashboard/components-next/Contacts/ContactsSidebar/ContactSidebarSection.vue';
 import ContactNoteItem from './components/ContactNoteItem.vue';

 const { t } = useI18n();
@@ -25,6 +26,16 @@ const isFetchingNotes = computed(() => uiFlags.value.isFetching);
 const isCreatingNote = computed(() => uiFlags.value.isCreating);
 const notes = computed(() => notesByContact.value(route.params.contactId));

+const searchQuery = ref('');
+
+const filteredNotes = computed(() => {
+  const query = searchQuery.value.trim().toLowerCase();
+  if (!query) return notes.value;
+  return notes.value.filter(note =>
+    (note.content || '').toLowerCase().includes(query)
+  );
+});
+
 const getWrittenBy = note => {
  const isCurrentUser = note?.user?.id === currentUser.value.id;
  return isCurrentUser
@@ -55,47 +66,73 @@ useKeyboardEvents(keyboardEvents);
 </script>

 <template>
-  <div class="flex flex-col gap-6">
-    <Editor
-      v-model="state.message"
-      :placeholder="t('CONTACTS_LAYOUT.SIDEBAR.NOTES.PLACEHOLDER')"
-      focus-on-mount
-      class="[&>div]:!border-transparent [&>div]:px-4 [&>div]:py-4 px-6"
-    >
-      <template #actions>
-        <div class="flex items-center gap-3">
-          <Button
-            variant="link"
-            color="blue"
-            size="sm"
-            :label="t('CONTACTS_LAYOUT.SIDEBAR.NOTES.SAVE')"
-            class="hover:no-underline"
-            :is-loading="isCreatingNote"
-            :disabled="!state.message || isCreatingNote"
-            @click="onAdd(state.message)"
-          />
-        </div>
-      </template>
-    </Editor>
+  <ContactSidebarSection
+    :title="t('CONTACTS_LAYOUT.PROFILE.SECTIONS.NOTES')"
+    :count="notes.length || null"
+    body-class="p-0"
+  >
+    <div class="border-b border-n-weak">
+      <Editor
+        v-model="state.message"
+        :placeholder="t('CONTACTS_LAYOUT.SIDEBAR.NOTES.PLACEHOLDER')"
+        class="[&>div]:!border-transparent [&>div]:!bg-transparent [&>div]:px-4 [&>div]:py-3"
+      >
+        <template #actions>
+          <div class="flex items-center gap-3">
+            <Button
+              variant="link"
+              color="blue"
+              size="sm"
+              :label="t('CONTACTS_LAYOUT.SIDEBAR.NOTES.SAVE')"
+              class="hover:no-underline"
+              :is-loading="isCreatingNote"
+              :disabled="!state.message || isCreatingNote"
+              @click="onAdd(state.message)"
+            />
+          </div>
+        </template>
+      </Editor>
+    </div>
    <div
      v-if="isFetchingNotes"
      class="flex items-center justify-center py-10 text-n-slate-11"
    >
      <Spinner />
    </div>
-    <div v-else-if="notes.length > 0">
-      <ContactNoteItem
-        v-for="note in notes"
-        :key="note.id"
-        class="mx-6 py-4"
-        :note="note"
-        :written-by="getWrittenBy(note)"
-        allow-delete
-        @delete="onDelete"
-      />
-    </div>
-    <p v-else class="px-6 py-6 text-sm leading-6 text-center text-n-slate-11">
+    <template v-else-if="notes.length > 0">
+      <div class="px-4 py-3 border-b border-n-weak">
+        <div class="relative">
+          <span
+            class="absolute i-lucide-search size-3.5 top-2.5 left-3 text-n-slate-10"
+          />
+          <input
+            v-model="searchQuery"
+            type="search"
+            :placeholder="t('CONTACTS_LAYOUT.SIDEBAR.NOTES.SEARCH_PLACEHOLDER')"
+            class="w-full h-8 py-2 pl-10 pr-2 text-sm border outline-none reset-base rounded-lg border-n-weak bg-n-alpha-black2 dark:bg-n-solid-2 text-n-slate-12"
+          />
+        </div>
+      </div>
+      <div class="px-4 max-h-[60vh] overflow-y-auto [&>div]:!border-b-0">
+        <ContactNoteItem
+          v-for="note in filteredNotes"
+          :key="note.id"
+          class="py-3.5"
+          :note="note"
+          :written-by="getWrittenBy(note)"
+          allow-delete
+          @delete="onDelete"
+        />
+        <p
+          v-if="filteredNotes.length === 0"
+          class="py-6 text-sm leading-6 text-center text-n-slate-11"
+        >
+          {{ t('CONTACTS_LAYOUT.SIDEBAR.NOTES.NO_RESULTS') }}
+        </p>
+      </div>
+    </template>
+    <p v-else class="px-4 py-6 text-sm leading-6 text-center text-n-slate-11">
      {{ t('CONTACTS_LAYOUT.SIDEBAR.NOTES.EMPTY_STATE') }}
    </p>
-  </div>
+  </ContactSidebarSection>
 </template>
@@ -0,0 +1,43 @@
+<script setup>
+defineProps({
+  title: {
+    type: String,
+    default: '',
+  },
+  count: {
+    type: [Number, String],
+    default: null,
+  },
+  bodyClass: {
+    type: String,
+    default: 'px-4 py-4',
+  },
+});
+</script>
+
+<template>
+  <section
+    class="flex flex-col overflow-hidden border rounded-2xl border-n-weak bg-n-solid-1"
+  >
+    <header
+      v-if="title || $slots.action"
+      class="flex items-center justify-between gap-2 px-5 py-4 border-b border-n-weak"
+    >
+      <h4
+        class="text-xs font-semibold tracking-wider uppercase text-n-slate-10"
+      >
+        {{ title }}
+        <span
+          v-if="count !== null && count !== ''"
+          class="font-medium tracking-normal normal-case ms-1 text-n-slate-10"
+        >
+          {{ count }}
+        </span>
+      </h4>
+      <slot name="action" />
+    </header>
+    <div :class="bodyClass">
+      <slot />
+    </div>
+  </section>
+</template>
@@ -12,6 +12,15 @@ import ContactsForm from 'dashboard/components-next/Contacts/ContactsForm/Contac
 import ConfirmContactDeleteDialog from 'dashboard/components-next/Contacts/ContactsForm/ConfirmContactDeleteDialog.vue';
 import Policy from 'dashboard/components/policy.vue';

+import TabBar from 'dashboard/components-next/tabbar/TabBar.vue';
+import ContactStats from 'dashboard/components-next/Contacts/Pages/ContactStats.vue';
+import ContactSidebarSection from 'dashboard/components-next/Contacts/ContactsSidebar/ContactSidebarSection.vue';
+import ContactCustomAttributes from 'dashboard/components-next/Contacts/ContactsSidebar/ContactCustomAttributes.vue';
+import ContactHistory from 'dashboard/components-next/Contacts/ContactsSidebar/ContactHistory.vue';
+import ContactNotes from 'dashboard/components-next/Contacts/ContactsSidebar/ContactNotes.vue';
+import ContactMedia from 'dashboard/components-next/Contacts/ContactsSidebar/ContactMedia.vue';
+import ContactMerge from 'dashboard/components-next/Contacts/ContactsSidebar/ContactMerge.vue';
+
 const props = defineProps({
  selectedContact: {
    type: Object,
@@ -38,6 +47,34 @@ const isFormInvalid = computed(() => contactsFormRef.value?.isFormInvalid);

 const contactData = ref({});

+const metaSeparator = '•';
+
+const contactId = computed(() => props.selectedContact?.id);
+
+const CONTACT_SECTIONS = [
+  { value: 'details', label: 'CONTACTS_LAYOUT.PROFILE.SECTIONS.DETAILS' },
+  { value: 'attributes', label: 'CONTACTS_LAYOUT.SIDEBAR.TABS.ATTRIBUTES' },
+  { value: 'history', label: 'CONTACTS_LAYOUT.PROFILE.STATS.CONVERSATIONS' },
+  { value: 'notes', label: 'CONTACTS_LAYOUT.PROFILE.STATS.NOTES' },
+  { value: 'media', label: 'CONTACTS_LAYOUT.PROFILE.STATS.FILES' },
+  { value: 'merge', label: 'CONTACTS_LAYOUT.SIDEBAR.TABS.MERGE' },
+];
+
+const activeSection = ref('details');
+
+const sectionTabs = computed(() =>
+  CONTACT_SECTIONS.map(section => ({ label: t(section.label) }))
+);
+
+const activeSectionIndex = computed(() =>
+  CONTACT_SECTIONS.findIndex(section => section.value === activeSection.value)
+);
+
+const handleSectionChange = tab => {
+  const index = sectionTabs.value.findIndex(item => item.label === tab.label);
+  if (index !== -1) activeSection.value = CONTACT_SECTIONS[index].value;
+};
+
 const getInitialContactData = () => {
  if (!props.selectedContact) return {};
  return { ...props.selectedContact };
@@ -45,6 +82,9 @@ const getInitialContactData = () => {

 onMounted(() => {
  Object.assign(contactData.value, getInitialContactData());
+  if (contactId.value) {
+    store.dispatch('contacts/fetchAttachments', contactId.value);
+  }
 });

 const createdAt = computed(() => {
@@ -121,8 +161,8 @@ const handleAvatarDelete = async () => {
 </script>

 <template>
-  <div class="flex flex-col items-start gap-8 pb-6">
-    <div class="flex flex-col items-start gap-3">
+  <div class="flex flex-col gap-8 pb-10">
+    <div class="flex items-start gap-5 min-w-0">
      <Avatar
        :src="avatarSrc || ''"
        :name="selectedContact?.name || ''"
@@ -131,73 +171,112 @@ const handleAvatarDelete = async () => {
        @upload="handleAvatarUpload"
        @delete="handleAvatarDelete"
      />
-      <div class="flex flex-col gap-1">
-        <h3 class="text-base font-medium text-n-slate-12">
+      <div class="flex flex-col gap-2 min-w-0">
+        <h1
+          class="text-xl font-semibold leading-tight tracking-tight truncate text-n-slate-12"
+        >
          {{ selectedContact?.name }}
-        </h3>
-        <div class="flex flex-col gap-1.5">
+        </h1>
+        <div
+          class="flex flex-wrap items-center text-sm gap-x-2 gap-y-1 text-n-slate-11"
+        >
          <span
            v-if="selectedContact?.identifier"
-            class="inline-flex items-center gap-1 text-sm text-n-slate-11"
+            class="inline-flex items-center gap-1"
          >
            <span class="i-ph-user-gear text-n-slate-10 size-4" />
            {{ selectedContact?.identifier }}
          </span>
-          <span class="inline-flex items-center gap-1 text-sm text-n-slate-11">
-            <span
-              v-if="selectedContact?.identifier"
-              class="i-ph-activity text-n-slate-10 size-4"
-            />
-            {{ $t('CONTACTS_LAYOUT.DETAILS.CREATED_AT', { date: createdAt }) }}
-            •
+          <span v-if="selectedContact?.identifier" class="text-n-slate-8">
+            {{ metaSeparator }}
+          </span>
+          <span>
+            {{ t('CONTACTS_LAYOUT.DETAILS.CREATED_AT', { date: createdAt }) }}
+          </span>
+          <span class="text-n-slate-8">{{ metaSeparator }}</span>
+          <span>
            {{
-              $t('CONTACTS_LAYOUT.DETAILS.LAST_ACTIVITY', {
+              t('CONTACTS_LAYOUT.DETAILS.LAST_ACTIVITY', {
                date: lastActivityAt,
              })
            }}
          </span>
        </div>
+        <ContactLabels :contact-id="selectedContact?.id" />
      </div>
-      <ContactLabels :contact-id="selectedContact?.id" />
    </div>
-    <div class="flex flex-col items-start gap-6">
-      <ContactsForm
-        ref="contactsFormRef"
-        :contact-data="contactData"
-        is-details-view
-        @update="handleFormUpdate"
+
+    <ContactStats :contact-id="contactId" :last-seen="lastActivityAt" />
+
+    <div class="flex flex-col gap-4">
+      <TabBar
+        :tabs="sectionTabs"
+        :initial-active-tab="activeSectionIndex"
+        class="max-w-full bg-n-alpha-black2"
+        @tab-changed="handleSectionChange"
      />
-      <Button
-        :label="t('CONTACTS_LAYOUT.CARD.EDIT_DETAILS_FORM.UPDATE_BUTTON')"
-        size="sm"
-        :is-loading="isUpdating"
-        :disabled="isUpdating || isFormInvalid"
-        @click="updateContact"
-      />
-    </div>
-    <Policy :permissions="['administrator']">
-      <div
-        class="flex flex-col items-start w-full gap-4 pt-6 border-t border-n-strong"
-      >
-        <div class="flex flex-col gap-2">
-          <h6 class="text-base font-medium text-n-slate-12">
-            {{ t('CONTACTS_LAYOUT.DETAILS.DELETE_CONTACT') }}
-          </h6>
-          <span class="text-sm text-n-slate-11">
-            {{ t('CONTACTS_LAYOUT.DETAILS.DELETE_CONTACT_DESCRIPTION') }}
-          </span>
-        </div>
-        <Button
-          :label="t('CONTACTS_LAYOUT.DETAILS.DELETE_CONTACT')"
-          color="ruby"
-          @click="openConfirmDeleteContactDialog"
+
+      <div>
+        <template v-if="activeSection === 'details'">
+          <div class="flex flex-col gap-4">
+            <ContactSidebarSection
+              :title="t('CONTACTS_LAYOUT.PROFILE.SECTIONS.DETAILS')"
+              body-class="px-4 py-4"
+            >
+              <div class="flex flex-col items-start gap-6">
+                <ContactsForm
+                  ref="contactsFormRef"
+                  :contact-data="contactData"
+                  is-details-view
+                  @update="handleFormUpdate"
+                />
+                <Button
+                  :label="
+                    t('CONTACTS_LAYOUT.CARD.EDIT_DETAILS_FORM.UPDATE_BUTTON')
+                  "
+                  size="sm"
+                  :is-loading="isUpdating"
+                  :disabled="isUpdating || isFormInvalid"
+                  @click="updateContact"
+                />
+              </div>
+            </ContactSidebarSection>
+            <Policy :permissions="['administrator']">
+              <ContactSidebarSection
+                :title="t('CONTACTS_LAYOUT.DETAILS.DELETE_CONTACT')"
+                body-class="flex flex-col items-start gap-4 p-4"
+              >
+                <span class="text-sm text-n-slate-11">
+                  {{ t('CONTACTS_LAYOUT.DETAILS.DELETE_CONTACT_DESCRIPTION') }}
+                </span>
+                <Button
+                  :label="t('CONTACTS_LAYOUT.DETAILS.DELETE_CONTACT')"
+                  color="ruby"
+                  size="sm"
+                  @click="openConfirmDeleteContactDialog"
+                />
+              </ContactSidebarSection>
+              <ConfirmContactDeleteDialog
+                ref="confirmDeleteContactDialogRef"
+                :selected-contact="selectedContact"
+                @go-to-contacts-list="emit('goToContactsList')"
+              />
+            </Policy>
+          </div>
+        </template>
+        <ContactCustomAttributes
+          v-else-if="activeSection === 'attributes'"
+          :selected-contact="selectedContact"
+        />
+        <ContactHistory v-else-if="activeSection === 'history'" />
+        <ContactNotes v-else-if="activeSection === 'notes'" />
+        <ContactMedia v-else-if="activeSection === 'media'" />
+        <ContactMerge
+          v-else-if="activeSection === 'merge'"
+          :selected-contact="selectedContact"
+          @go-to-contacts-list="emit('goToContactsList')"
        />
      </div>
-      <ConfirmContactDeleteDialog
-        ref="confirmDeleteContactDialogRef"
-        :selected-contact="selectedContact"
-        @go-to-contacts-list="emit('goToContactsList')"
-      />
-    </Policy>
+    </div>
  </div>
 </template>
@@ -0,0 +1,75 @@
+<script setup>
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useMapGetter } from 'dashboard/composables/store';
+
+const props = defineProps({
+  contactId: {
+    type: [Number, String],
+    default: null,
+  },
+  lastSeen: {
+    type: String,
+    default: '',
+  },
+});
+
+const { t } = useI18n();
+
+const conversationsByContact = useMapGetter(
+  'contactConversations/getAllConversationsByContactId'
+);
+const notesByContact = useMapGetter('contactNotes/getAllNotesByContactId');
+const attachmentsByContact = useMapGetter('contacts/getContactAttachments');
+
+const statTiles = computed(() => [
+  {
+    key: 'conversations',
+    label: t('CONTACTS_LAYOUT.PROFILE.STATS.CONVERSATIONS'),
+    value: conversationsByContact.value(props.contactId)?.length ?? 0,
+  },
+  {
+    key: 'notes',
+    label: t('CONTACTS_LAYOUT.PROFILE.STATS.NOTES'),
+    value: notesByContact.value(props.contactId)?.length ?? 0,
+  },
+  {
+    key: 'files',
+    label: t('CONTACTS_LAYOUT.PROFILE.STATS.FILES'),
+    value:
+      attachmentsByContact.value(props.contactId)?.filter(a => a.data_url)
+        ?.length ?? 0,
+  },
+]);
+</script>
+
+<template>
+  <div
+    class="grid grid-cols-2 overflow-hidden border sm:grid-cols-4 gap-px rounded-xl border-n-weak bg-n-weak"
+  >
+    <div
+      v-for="tile in statTiles"
+      :key="tile.key"
+      class="flex flex-col gap-2 px-5 py-5 bg-n-solid-1"
+    >
+      <span
+        class="text-xs font-semibold tracking-wider uppercase text-n-slate-10"
+      >
+        {{ tile.label }}
+      </span>
+      <span class="text-3xl font-semibold tabular-nums text-n-slate-12">
+        {{ tile.value }}
+      </span>
+    </div>
+    <div class="flex flex-col gap-2 px-5 py-5 bg-n-solid-1">
+      <span
+        class="text-xs font-semibold tracking-wider uppercase text-n-slate-10"
+      >
+        {{ t('CONTACTS_LAYOUT.PROFILE.STATS.LAST_SEEN') }}
+      </span>
+      <span class="text-base font-medium truncate text-n-slate-12">
+        {{ lastSeen || t('CONTACTS_LAYOUT.PROFILE.STATS.NEVER') }}
+      </span>
+    </div>
+  </div>
+</template>
@@ -16,7 +16,6 @@ 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';
@@ -83,39 +82,18 @@ 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) => {
-  // 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);
+  const response = await whatsappCallSession.initiateOutboundCall(
+    conversationIdHint
+      ? { conversationId: conversationIdHint }
+      : { contactId: props.contactId, inboxId }
+  );
  // 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
@@ -20,10 +20,21 @@ const props = defineProps({
  attachments: { type: Array, default: () => [] },
  peekLimit: { type: Number, default: 0 },
  showJumpToMessage: { type: Boolean, default: false },
+  columns: { type: Number, default: 3 },
 });

 const emit = defineEmits(['select', 'jumpToMessage']);

+const gridColsClass = computed(
+  () =>
+    ({
+      3: 'grid-cols-3',
+      4: 'grid-cols-4',
+      5: 'grid-cols-5',
+      6: 'grid-cols-6',
+    })[props.columns] || 'grid-cols-3'
+);
+
 const { t } = useI18n();

 const mediaAttachments = computed(() =>
@@ -177,7 +188,7 @@ const onDownloadFile = async attachment => {
        @click="showAll = !showAll"
      />
    </header>
-    <div class="grid grid-cols-3 gap-2">
+    <div class="grid gap-2" :class="gridColsClass">
      <div
        v-for="(attachment, index) in visibleMedia"
        :key="attachment.id"
@@ -9,6 +9,7 @@ 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']);
@@ -45,7 +46,11 @@ 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 class="flex items-end justify-between gap-2">
+    <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">
      <span
        class="text-3xl font-semibold tracking-tight tabular-nums text-n-slate-12"
      >
@@ -9,6 +9,10 @@ const props = defineProps({
    type: String,
    default: '30',
  },
+  stats: {
+    type: Object,
+    default: null,
+  },
 });

 const route = useRoute();
@@ -20,22 +24,41 @@ 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,
    });
-    welcomeMarkdown.value = data.message ?? '';
+    message = data.message ?? '';
  } catch {
-    welcomeMarkdown.value = '';
-  } finally {
-    isLoading.value = false;
+    message = '';
  }
+
+  if (token !== fetchToken) return;
+  welcomeMarkdown.value = message;
+  isLoading.value = false;
 };

-watch([() => props.range, assistantId], fetchSummary, { immediate: true });
+watch([() => props.range, () => props.stats, 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
@@ -0,0 +1,342 @@
+<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>
@@ -2,6 +2,7 @@
 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';
@@ -9,16 +10,38 @@ import { useI18n } from 'vue-i18n';

 import MessageFormatter from 'shared/helpers/MessageFormatter.js';
 import { BUS_EVENTS } from 'shared/constants/busEvents';
-import { MESSAGE_VARIANTS, ORIENTATION } from '../constants';
+import { MESSAGE_VARIANTS, ORIENTATION, SENDER_TYPES } from '../constants';

 const props = defineProps({
  hideMeta: { type: Boolean, default: false },
 });

-const { variant, orientation, inReplyTo, shouldGroupWithNext } =
-  useMessageContext();
+const {
+  variant,
+  orientation,
+  inReplyTo,
+  shouldGroupWithNext,
+  id,
+  sender,
+  senderType,
+} = 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]:
@@ -114,16 +137,21 @@ const replyToPreview = computed(() => {
      />
    </div>
    <slot />
-    <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"
-    />
+    <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>
  </div>
 </template>
@@ -263,9 +263,9 @@ const handleCallBack = async () => {
  if (!canCallBack.value || isInitiatingCall.value) return;
  try {
    if (isWhatsapp.value) {
-      const response = await whatsappCallSession.initiateOutboundCall(
-        conversationId.value
-      );
+      const response = await whatsappCallSession.initiateOutboundCall({
+        conversationId: 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) {
@@ -69,9 +69,9 @@ const callButtonTooltip = computed(() =>
 const startWhatsappCall = async () => {
  if (whatsappCallSession.isInitiating.value) return;
  try {
-    const response = await whatsappCallSession.initiateOutboundCall(
-      props.chat.id
-    );
+    const response = await whatsappCallSession.initiateOutboundCall({
+      conversationId: 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.
@@ -308,7 +308,8 @@ export function useWhatsappCallSession() {
    }
  };

-  const initiateOutboundCall = async conversationId => {
+  // target: { conversationId } or { contactId, inboxId }
+  const initiateOutboundCall = async target => {
    // 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
@@ -320,10 +321,7 @@ export function useWhatsappCallSession() {
    isInitiatingOutbound.value = true;
    try {
      const sdpOffer = await prepareOutboundOffer();
-      const response = await WhatsappCallsAPI.initiate(
-        conversationId,
-        sdpOffer
-      );
+      const response = await WhatsappCallsAPI.initiate(target, sdpOffer);
      if (response?.id) {
        activeCallId = response.id;
        // A connect webhook that raced ahead of this response was buffered;
@@ -354,7 +352,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 };
+        return { status: data.status, conversation_id: data.conversation_id };
      }
      throw e;
    } finally {
@@ -7,8 +7,7 @@ export const FEATURE_FLAGS = {
  AUTOMATIONS: 'automations',
  CAMPAIGNS: 'campaigns',
  WHATSAPP_CAMPAIGNS: 'whatsapp_campaign',
-  WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION:
-    'whatsapp_embedded_signup_inbox_creation',
+  WHATSAPP_EMBEDDED_SIGNUP_FLOW: 'whatsapp_embedded_signup_inbox_creation',
  WHATSAPP_MANUAL_TRANSFER: 'whatsapp_manual_transfer',
  WHATSAPP_RECONFIGURE: 'whatsapp_reconfigure',
  CANNED_RESPONSES: 'canned_responses',
@@ -506,6 +506,19 @@
        }
      }
    },
+    "PROFILE": {
+      "STATS": {
+        "CONVERSATIONS": "Conversations",
+        "NOTES": "Notes",
+        "FILES": "Files",
+        "LAST_SEEN": "Last seen",
+        "NEVER": "Never"
+      },
+      "SECTIONS": {
+        "DETAILS": "Details",
+        "NOTES": "Notes"
+      }
+    },
    "SIDEBAR": {
      "TABS": {
        "ATTRIBUTES": "Attributes",
@@ -564,6 +577,8 @@
      },
      "NOTES": {
        "PLACEHOLDER": "Add a note",
+        "SEARCH_PLACEHOLDER": "Search notes",
+        "NO_RESULTS": "No notes match your search",
        "WROTE": "wrote",
        "YOU": "You",
        "SAVE": "Save note",
@@ -72,6 +72,20 @@
    "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",
@@ -1,5 +1,6 @@
 <script setup>
-import { computed, ref, watch } from 'vue';
+import { computed, ref, watch, onMounted } from 'vue';
+import { until } from '@vueuse/core';
 import { useI18n } from 'vue-i18n';
 import { useRoute, useRouter } from 'vue-router';
 import { useMapGetter, useStore } from 'dashboard/composables/store';
@@ -49,7 +50,9 @@ const isVoiceEnabled = computed(
 const calls = computed(() => callHistoryStore.records);
 const meta = computed(() => callHistoryStore.meta);
 const isFetching = computed(() => callHistoryStore.uiFlags.isFetching);
-const inboxesUiFlags = useMapGetter('inboxes/getUIFlags');
+const accountUiFlags = useMapGetter('accounts/getUIFlags');
+
+const isInitializing = ref(true);

 // Filters are seeded from the URL so a shared link restores the same view.
 const activity = ref(
@@ -98,20 +101,25 @@ const onPageChange = page => {
  fetchCalls();
 };

-// 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();
+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;
+  }
 });
 </script>

 <template>
  <div
-    v-if="inboxesUiFlags.isFetching"
+    v-if="isInitializing"
    class="flex items-center justify-center w-full h-full bg-n-surface-1"
  >
    <Spinner :size="24" />
@@ -1,5 +1,5 @@
 <script setup>
-import { computed, ref, watch } from 'vue';
+import { computed, onUnmounted, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute } from 'vue-router';
 import { FEATURE_FLAGS } from 'dashboard/featureFlags';
@@ -27,19 +27,49 @@ 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 () => {
-  try {
-    const { data } = await CaptainAssistant.getStats({
+  fetchToken += 1;
+  const token = fetchToken;
+  abortController?.abort();
+  abortController = new AbortController();
+  const { signal } = abortController;
+  stats.value = null;
+  isFetching.value = true;
+
+  const requestStats = () =>
+    CaptainAssistant.getStats({
      assistantId: assistantId.value,
      range: selectedRange.value,
+      signal,
    });
-    stats.value = data;
+
+  let data = null;
+  try {
+    ({ data } = await requestStats());
  } catch {
-    stats.value = null;
+    // One silent retry before giving up, unless the request was aborted.
+    try {
+      if (token === fetchToken && !signal.aborted)
+        ({ data } = await requestStats());
+    } catch {
+      data = 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
@@ -156,7 +186,7 @@ const closeDrilldown = () => {

        <CoverageBanner :knowledge="stats?.knowledge" />

-        <WelcomeCard :range="selectedRange" />
+        <WelcomeCard :range="selectedRange" :stats="stats" />

        <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"
@@ -169,7 +199,8 @@ const closeDrilldown = () => {
            :trend="metric.trend"
            :hint="metric.hint"
            :trend-good="metric.trendGood"
-            :clickable="canDrilldown && Boolean(metric.metric)"
+            :loading="isFetching"
+            :clickable="canDrilldown && Boolean(metric.metric) && !isFetching"
            @click="openDrilldown(metric)"
          />
        </div>
@@ -1,5 +1,5 @@
 <script setup>
-import { onMounted, computed, ref } from 'vue';
+import { onMounted, computed } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useAlert } from 'dashboard/composables';
 import { useStore, useMapGetter } from 'dashboard/composables/store';
@@ -8,12 +8,6 @@ import { useRoute, useRouter } from 'vue-router';
 import ContactsDetailsLayout from 'dashboard/components-next/Contacts/ContactsDetailsLayout.vue';
 import Spinner from 'dashboard/components-next/spinner/Spinner.vue';
 import ContactDetails from 'dashboard/components-next/Contacts/Pages/ContactDetails.vue';
-import TabBar from 'dashboard/components-next/tabbar/TabBar.vue';
-import ContactNotes from 'dashboard/components-next/Contacts/ContactsSidebar/ContactNotes.vue';
-import ContactHistory from 'dashboard/components-next/Contacts/ContactsSidebar/ContactHistory.vue';
-import ContactMedia from 'dashboard/components-next/Contacts/ContactsSidebar/ContactMedia.vue';
-import ContactMerge from 'dashboard/components-next/Contacts/ContactsSidebar/ContactMerge.vue';
-import ContactCustomAttributes from 'dashboard/components-next/Contacts/ContactsSidebar/ContactCustomAttributes.vue';

 const store = useStore();
 const route = useRoute();
@@ -22,9 +16,6 @@ const router = useRouter();
 const contact = useMapGetter('contacts/getContactById');
 const uiFlags = useMapGetter('contacts/getUIFlags');

-const activeTab = ref('attributes');
-const contactMergeRef = ref(null);
-
 const isFetchingItem = computed(() => uiFlags.value.isFetchingItem);
 const isMergingContact = computed(() => uiFlags.value.isMerging);
 const isUpdatingContact = computed(() => uiFlags.value.isUpdating);
@@ -37,25 +28,6 @@ const showSpinner = computed(

 const { t } = useI18n();

-const CONTACT_TABS_OPTIONS = [
-  { key: 'ATTRIBUTES', value: 'attributes' },
-  { key: 'HISTORY', value: 'history' },
-  { key: 'NOTES', value: 'notes' },
-  { key: 'MEDIA', value: 'media' },
-  { key: 'MERGE', value: 'merge' },
-];
-
-const tabs = computed(() => {
-  return CONTACT_TABS_OPTIONS.map(tab => ({
-    label: t(`CONTACTS_LAYOUT.SIDEBAR.TABS.${tab.key}`),
-    value: tab.value,
-  }));
-});
-
-const activeTabIndex = computed(() => {
-  return CONTACT_TABS_OPTIONS.findIndex(v => v.value === activeTab.value);
-});
-
 const goToContactsList = () => {
  if (window.history.state?.back || window.history.length > 1) {
    router.back();
@@ -74,10 +46,6 @@ const fetchActiveContact = async () => {
  }
 };

-const handleTabChange = tab => {
-  activeTab.value = tab.value;
-};
-
 const fetchContactNotes = () => {
  const { contactId } = route.params;
  if (contactId) store.dispatch('contactNotes/get', { contactId });
@@ -151,40 +119,6 @@ onMounted(() => {
        :selected-contact="selectedContact"
        @go-to-contacts-list="goToContactsList"
      />
-      <template #sidebarHeader>
-        <div class="px-6 pt-6 pb-3">
-          <TabBar
-            :tabs="tabs"
-            :initial-active-tab="activeTabIndex"
-            class="w-full [&>button]:w-full bg-n-alpha-black2"
-            @tab-changed="handleTabChange"
-          />
-        </div>
-      </template>
-      <template #sidebar>
-        <div
-          v-if="isFetchingItem"
-          class="flex items-center justify-center py-10 text-n-slate-11"
-        >
-          <Spinner />
-        </div>
-        <template v-else>
-          <ContactCustomAttributes
-            v-if="activeTab === 'attributes'"
-            :selected-contact="selectedContact"
-          />
-          <ContactNotes v-if="activeTab === 'notes'" />
-          <ContactHistory v-if="activeTab === 'history'" />
-          <ContactMedia v-if="activeTab === 'media'" />
-          <ContactMerge
-            v-if="activeTab === 'merge'"
-            ref="contactMergeRef"
-            :selected-contact="selectedContact"
-            @go-to-contacts-list="goToContactsList"
-            @reset-tab="handleTabChange(CONTACT_TABS_OPTIONS[0])"
-          />
-        </template>
-      </template>
    </ContactsDetailsLayout>
  </div>
 </template>
@@ -18,9 +18,7 @@ export function useChannelConfig() {
    // app id (not the 'none' sentinel) and the signup configuration id.
    whatsapp: () =>
      (!isOnChatwootCloud.value ||
-        isCloudFeatureEnabled(
-          FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION
-        )) &&
+        isCloudFeatureEnabled(FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW)) &&
      Boolean(installationConfig.whatsappAppId) &&
      installationConfig.whatsappAppId !== 'none' &&
      Boolean(installationConfig.whatsappConfigurationId),
@@ -390,6 +390,11 @@ export default {
      return (
        this.isAWhatsAppCloudChannel &&
        this.isEmbeddedSignupWhatsApp &&
+        (!this.isOnChatwootCloud ||
+          this.isFeatureEnabledonAccount(
+            this.accountId,
+            FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
+          )) &&
        this.inbox.reauthorization_required
      );
    },
@@ -42,9 +42,7 @@ const shouldShowWhatsappEmbeddedSignup = computed(() => {
    selectedProvider.value === PROVIDER_TYPES.WHATSAPP &&
    hasWhatsappAppId.value &&
    (!isOnChatwootCloud.value ||
-      isCloudFeatureEnabled(
-        FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION
-      ))
+      isCloudFeatureEnabled(FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW))
  );
 });

@@ -56,6 +56,7 @@ export default {
    ...mapGetters({
      accountId: 'getCurrentAccountId',
      isFeatureEnabledonAccount: 'accounts/isFeatureEnabledonAccount',
+      isOnChatwootCloud: 'globalConfig/isOnChatwootCloud',
    }),
    isEmbeddedSignupWhatsApp() {
      return this.inbox.provider_config?.source === 'embedded_signup';
@@ -65,7 +66,9 @@ export default {
        this.isEmbeddedSignupWhatsApp &&
        this.isFeatureEnabledonAccount(
          this.accountId,
-          FEATURE_FLAGS.WHATSAPP_RECONFIGURE
+          this.isOnChatwootCloud
+            ? FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
+            : FEATURE_FLAGS.WHATSAPP_RECONFIGURE
        )
      );
    },
@@ -0,0 +1,62 @@
+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);
+    },
+  },
+};
@@ -50,6 +50,7 @@ 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';
@@ -115,6 +116,7 @@ export default createStore({
    teams,
    userNotificationSettings,
    webhooks,
+    captainAgentSessions,
    captainAssistants,
    captainDocuments,
    captainResponses,
@@ -113,12 +113,14 @@ 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
-                      @contact_inbox.conversations.last
+                      conversations.last
                    else
-                      @contact_inbox.conversations
-                                    .where.not(status: :resolved).last
+                      conversations.where.not(status: :resolved).last
                    end
    return if @conversation

@@ -265,6 +265,6 @@
  enabled: false
  column: feature_flags_ext_1
 - name: whatsapp_embedded_signup_inbox_creation
-  display_name: WhatsApp Embedded Signup Inbox Creation
+  display_name: WhatsApp Embedded Signup Flow
  enabled: false
  column: feature_flags_ext_1
@@ -76,6 +76,7 @@ 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]
@@ -0,0 +1,25 @@
+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
@@ -47,7 +47,8 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
  end

  def summary
-    result = cached_or_generated_summary(Captain::AssistantStatsBuilder.new(@assistant, params[:range], params[:timezone_offset]))
+    window = Captain::AssistantStatsWindow.new(params[:range], params[:timezone_offset])
+    result = cached_or_generated_summary(window, summary_stats)

    if result[:error]
      render json: { error: result[:error] }, status: :unprocessable_content
@@ -68,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(builder)
-    cache_key = summary_cache_key(builder.range)
+  def cached_or_generated_summary(window, stats)
+    cache_key = summary_cache_key(window.range)
    cached = Rails.cache.read(cache_key)
    return cached if cached

@@ -77,14 +78,25 @@ 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: builder.metrics,
-      period: builder.period
+      stats: stats,
+      period: window.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
@@ -1,8 +1,6 @@
 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_conversation, only: :initiate
+  before_action :set_call_context, only: :initiate
  before_action :ensure_calling_enabled, only: :initiate
  before_action :ensure_sdp_offer, only: :initiate
  before_action :ensure_contact_phone, only: :initiate
@@ -53,7 +51,7 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
  end

  def provider_service
-    @provider_service ||= @conversation.inbox.channel.provider_service
+    @provider_service ||= @inbox.channel.provider_service
  end

  def set_call
@@ -61,13 +59,38 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
    authorize @call.conversation, :show?
  end

-  def set_conversation
+  def set_call_context
+    params[:conversation_id].present? ? set_context_from_conversation : set_context_from_contact
+  end
+
+  def set_context_from_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 = @conversation.inbox.channel
+    channel = @inbox.channel
    return if channel.is_a?(Channel::Whatsapp) && channel.voice_enabled?

    render_could_not_create_error(I18n.t('errors.whatsapp.calls.not_enabled'))
@@ -80,7 +103,7 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
  end

  def ensure_contact_phone
-    return if @conversation.contact&.phone_number.present?
+    return if @contact.phone_number.present?

    render_could_not_create_error(I18n.t('errors.whatsapp.calls.contact_phone_required'))
  end
@@ -105,92 +128,45 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
  end

  def create_outbound_call
-    contact_phone = @conversation.contact.phone_number.delete('+')
-    # Claim for the caller only if unassigned at trigger time (before the round-trip); wins over auto-assignment.
-    claim_for_caller = @conversation.assignee_id.nil?
+    # 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?

-    result = provider_service.initiate_call(contact_phone, params[:sdp_offer])
+    result = provider_service.initiate_call(@contact.phone_number.delete('+'), 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
-    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
+    # 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

    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 }, 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)
+    render json: { status: status, conversation_id: @conversation.display_id }, status: :unprocessable_entity
  end

  def render_call_error(error)
@@ -107,8 +107,8 @@ class Twilio::VoiceController < ApplicationController
    when 'inbound'
      Voice::InboundCallBuilder.perform!(
        inbox: inbox,
-        from_number: twilio_from,
-        call_sid: twilio_call_sid
+        call_sid: twilio_call_sid,
+        caller: { source_ids: [twilio_from], contact_attributes: { name: twilio_from, phone_number: twilio_from } }
      )
    when 'outbound-api', 'outbound-dial'
      sync_outbound_leg(call_sid: twilio_call_sid, direction: twilio_direction)
@@ -22,13 +22,12 @@ 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] || [],
@@ -44,6 +43,23 @@ 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'
@@ -1,17 +1,19 @@
 class Voice::InboundCallBuilder
-  attr_reader :inbox, :from_number, :call_sid, :provider, :extra_meta
+  attr_reader :inbox, :call_sid, :provider, :extra_meta, :source_ids, :contact_attributes

-  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!
+  # `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!
  end

-  def initialize(inbox:, from_number:, call_sid:, provider: :twilio, extra_meta: {})
+  def initialize(inbox:, call_sid:, caller:, 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!
@@ -43,46 +45,17 @@ class Voice::InboundCallBuilder
        .find_by(provider: provider, provider_call_id: call_sid)
  end

-  # 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.
+  # 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.
  def ensure_contact_inbox!
-    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)
+    ContactInboxSourceIdResolver.new(
+      inbox: inbox, source_ids: source_ids, contact_attributes: contact_attributes
+    ).perform
  end

-  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.
+  # Mirror Whatsapp::IncomingMessageBaseService#set_conversation: reuse this row's open conversation (or last when locked), else create.
  def resolve_conversation!(contact, contact_inbox)
    reusable = if inbox.lock_to_single_conversation
                 contact_inbox.conversations.last
@@ -0,0 +1,32 @@
+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
@@ -0,0 +1,63 @@
+# 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
@@ -0,0 +1,48 @@
+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
@@ -95,28 +95,21 @@ 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
-      call = Voice::InboundCallBuilder.perform!(inbox: inbox, from_number: "+#{payload[:from]}", call_sid: payload[:id],
-                                                provider: :whatsapp, extra_meta: inbound_extra_meta(payload, sdp_offer))
+      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)
      tombstone = consume_terminate_tombstone(payload[:id])
      finalize_terminate(call, tombstone['duration'], tombstone['terminate_reason']) if tombstone
      call
    end
  end

-  def inbound_extra_meta(payload, sdp_offer)
-    extra_meta = { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
-    name = caller_profile_name(payload)
-    extra_meta['contact_name'] = name if name.present?
-    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
+  # 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))
  end

  # `connect` is the WebRTC tunnel-ready signal, not the pickup signal. Apply
@@ -0,0 +1,18 @@
+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
@@ -2,4 +2,5 @@ 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'
@@ -13,7 +13,7 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
                   })

    # Use existing handoff mechanism from ResponseBuilderJob
-    trigger_handoff(conversation, reason)
+    trigger_handoff(tool_context, 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(conversation, reason)
+  def trigger_handoff(tool_context, conversation, reason)
    # post the reason as a private note
-    conversation.messages.create!(
+    note = conversation.messages.create!(
      message_type: :outgoing,
      private: true,
      sender: @assistant,
@@ -34,6 +34,15 @@ 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!

@@ -32,6 +32,7 @@ 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),
@@ -1,7 +1,8 @@
 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:
- Address {{ first_name }} directly and open with "Hey {{ first_name }},". Be conversational, never robotic.
+- 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.
 - 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.
@@ -0,0 +1,120 @@
+require 'rails_helper'
+
+RSpec.describe 'Api::V1::Accounts::Captain::AgentSessions', type: :request do
+  let(:account) { create(:account) }
+  let(:agent) { create(:user, account: account, role: :agent) }
+  let(:inbox) { create(:inbox, account: account) }
+  let(:conversation) { create(:conversation, account: account, inbox: inbox) }
+  let(:assistant) { create(:captain_assistant, account: account) }
+  let(:message) do
+    create(:message, account: account, conversation: conversation, message_type: :outgoing, sender: assistant)
+  end
+
+  before { create(:inbox_member, user: agent, inbox: inbox) }
+
+  def json_response
+    JSON.parse(response.body, symbolize_names: true)
+  end
+
+  describe 'GET /api/v1/accounts/:account_id/captain/agent_sessions/:id' do
+    context 'when it is an unauthenticated user' do
+      it 'returns unauthorized' do
+        get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}", as: :json
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when the message has an agent session' do
+      let(:document) { create(:captain_document, account: account, assistant: assistant) }
+      let(:documented_faq) do
+        create(:captain_assistant_response, account: account, assistant: assistant,
+                                            question: 'How do I reset my password?', documentable: document)
+      end
+      let(:plain_faq) do
+        create(:captain_assistant_response, account: account, assistant: assistant, question: 'How do I change my email?')
+      end
+      let(:pdf_document) do
+        create(:captain_document, account: account, assistant: assistant, external_link: nil,
+                                  pdf_file: Rack::Test::UploadedFile.new(Rails.root.join('spec/assets/sample.pdf'), 'application/pdf'))
+      end
+      let(:pdf_faq) do
+        create(:captain_assistant_response, account: account, assistant: assistant,
+                                            question: 'What are the pricing tiers?', documentable: pdf_document)
+      end
+      let(:scenario) { create(:captain_scenario, account: account, assistant: assistant, title: 'Refund flow') }
+      let(:run_context) do
+        [
+          { 'role' => 'user', 'content' => 'I want a refund' },
+          { 'role' => 'assistant', 'content' => '', 'agent_name' => 'Assistant',
+            'tool_calls' => [{ 'id' => 'call_1', 'name' => 'faq_lookup', 'arguments' => { 'query' => 'refund' } }] },
+          { 'role' => 'tool', 'content' => 'Refunds take 5 days', 'tool_call_id' => 'call_1' },
+          { 'role' => 'assistant', 'content' => 'Refunds take 5 days', 'agent_name' => "scenario_#{scenario.id}_refund_flow" }
+        ]
+      end
+      let!(:agent_session) do
+        create(:captain_agent_session, account: account, assistant: assistant,
+                                       subject: conversation, result: message,
+                                       llm_model: 'openai-gpt-5.2', credits_consumed: 1.0,
+                                       faq_ids: [documented_faq.id, plain_faq.id, pdf_faq.id, documented_faq.id + 100_000],
+                                       scenario_ids: [scenario.id],
+                                       run_context: run_context)
+      end
+
+      it 'returns the session with hydrated citations and scenarios' do
+        get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}",
+            headers: agent.create_new_auth_token, as: :json
+
+        expect(response).to have_http_status(:success)
+        aggregate_failures do
+          expect(json_response[:id]).to eq(agent_session.id)
+          expect(json_response[:message_id]).to eq(message.id)
+          expect(json_response[:llm_model]).to eq('openai-gpt-5.2')
+          expect(json_response[:credits_consumed]).to eq(1.0)
+          expect(json_response[:run_context].length).to eq(4)
+          expect(json_response[:run_context].second[:tool_calls].first[:arguments][:query]).to eq('refund')
+
+          citations = json_response[:citations].index_by { |citation| citation[:id] }
+          expect(citations.keys).to contain_exactly(documented_faq.id, plain_faq.id, pdf_faq.id)
+          expect(citations[documented_faq.id][:title]).to eq('How do I reset my password?')
+          expect(citations[documented_faq.id][:link]).to eq(document.external_link)
+          expect(citations[plain_faq.id][:link]).to be_nil
+          expect(pdf_document.external_link).to start_with('PDF:')
+          expect(citations[pdf_faq.id][:link]).to eq(pdf_document.display_url)
+          expect(citations[pdf_faq.id][:link]).to match(%r{\Ahttps?://})
+
+          expect(json_response[:scenarios]).to eq([{ id: scenario.id, title: 'Refund flow' }])
+        end
+      end
+
+      it 'does not allow an agent without access to the conversation' do
+        other_agent = create(:user, account: account, role: :agent)
+
+        get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}",
+            headers: other_agent.create_new_auth_token, as: :json
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when the message has no agent session' do
+      it 'returns not found' do
+        get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}",
+            headers: agent.create_new_auth_token, as: :json
+
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+
+    context 'when the message does not belong to the account' do
+      it 'returns not found' do
+        other_message = create(:message)
+
+        get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{other_message.id}",
+            headers: agent.create_new_auth_token, as: :json
+
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+  end
+end
@@ -257,10 +257,20 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
    let(:alice) { create(:user, account: account, role: :administrator, name: 'Alice Adams') }
    let(:bob) { create(:user, account: account, role: :administrator, name: 'Bob Brown') }
    let(:summary_service) { instance_double(Captain::OverviewSummaryService) }
+    let(:summary_stats) do
+      {
+        conversations_handled: { current: 42 },
+        hours_saved: { current: 12 },
+        auto_resolution_rate: { current: 65.0, trend: 5.0 },
+        handoff_rate: { current: 20.0, trend: -2.0 },
+        reopen_rate: { current: 5.0, trend: -1.0 },
+        knowledge: { coverage: 80, approved: 8, documents: 3 }
+      }
+    end

    def get_summary(user)
      get "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}/summary",
-          params: { range: '30' },
+          params: { range: '30', stats: summary_stats },
          headers: user.create_new_auth_token,
          as: :json
    end
@@ -273,6 +283,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do

    it 'caches the summary per viewer so one user never receives another user\'s greeting' do
      allow(summary_service).to receive(:perform).and_return({ message: 'Hi Alice' })
+      expect(Captain::AssistantStatsBuilder).not_to receive(:new)

      get_summary(alice)
      get_summary(alice) # served from Alice's cache, no regeneration
@@ -280,6 +291,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do

      expect(response).to have_http_status(:success)
      expect(Captain::OverviewSummaryService).to have_received(:new).twice
+      expect(Captain::OverviewSummaryService).to have_received(:new).with(hash_including(stats: summary_stats)).twice
    end

    it 'does not cache failures so a transient error is retried' do
@@ -33,8 +33,8 @@ RSpec.describe 'Twilio::VoiceController', type: :request do

      expect(Voice::InboundCallBuilder).to receive(:perform!).with(
        inbox: inbox,
-        from_number: from_number,
-        call_sid: call_sid
+        call_sid: call_sid,
+        caller: { source_ids: [from_number], contact_attributes: { name: from_number, phone_number: from_number } }
      ).and_return(call)

      post "/twilio/voice/call/#{digits}", params: {
@@ -561,6 +561,22 @@ RSpec.describe Captain::Conversation::ResponseBuilderJob, type: :job do
        expect(account.reload.usage_limits[:captain][:responses][:consumed]).to eq(0)
      end

+      it 'attributes the handoff session to the private reason note when the tool recorded one' do
+        handoff_note = create(:message, conversation: conversation, account: account, message_type: :outgoing,
+                                        private: true, sender: assistant, content: 'Needs a human')
+        run_context[:state][:cw_metadata][:handoff_note_id] = handoff_note.id
+        allow(mock_agent_runner_service).to receive(:generate_response) do
+          conversation.update!(status: :open)
+          { 'response' => 'Let me connect you', 'handoff_tool_called' => true }
+        end
+
+        described_class.perform_now(conversation, assistant)
+
+        session = Captain::AgentSession.last
+        expect(session.credits_consumed).to eq(0.0)
+        expect(session.result_id).to eq(handoff_note.id)
+      end
+
      it 'creates a zero-credit session when the handoff tool fired but failed to commit' do
        allow(mock_agent_runner_service).to receive(:generate_response).and_return({
                                                                                     'response' => 'I tried to hand off',
@@ -86,6 +86,12 @@ RSpec.describe Captain::Tools::HandoffTool, type: :model do

          tool.perform(tool_context, reason: reason)
        end
+
+        it 'records the handoff note id in the run state for session capture' do
+          tool.perform(tool_context, reason: 'Customer needs specialized support')
+
+          expect(tool_context.state[:cw_metadata][:handoff_note_id]).to eq(Message.last.id)
+        end
      end

      context 'without reason provided' do
@@ -107,6 +113,12 @@ RSpec.describe Captain::Tools::HandoffTool, type: :model do

          tool.perform(tool_context)
        end
+
+        it 'does not record a handoff note id since the empty note never renders' do
+          tool.perform(tool_context)
+
+          expect(tool_context.state[:cw_metadata]).to be_nil
+        end
      end

      context 'when handoff fails' do
@@ -17,8 +17,8 @@ RSpec.describe Voice::InboundCallBuilder do
  def perform_builder
    described_class.perform!(
      inbox: inbox,
-      from_number: from_number,
-      call_sid: call_sid
+      call_sid: call_sid,
+      caller: { source_ids: [from_number], contact_attributes: { name: from_number, phone_number: from_number } }
    )
  end

@@ -100,26 +100,29 @@ RSpec.describe Voice::InboundCallBuilder do
    end
  end

-  context 'when the WhatsApp wa_id needs Brazil normalization to match an existing ContactInbox' do
+  context 'when a WhatsApp call shares a BSUID with an existing ContactInbox' do
    let(:whatsapp_channel) do
      create(:channel_whatsapp, account: account, provider: 'whatsapp_cloud',
                                provider_config: { 'phone_number_id' => '123', 'source' => 'embedded_signup', 'calling_enabled' => true },
                                validate_provider_config: false, sync_templates: false)
    end
    let(:whatsapp_inbox) { whatsapp_channel.inbox }
-    let!(:stored_contact) { create(:contact, account: account, phone_number: '+5541988887777') }
+    let!(:stored_contact) { create(:contact, account: account) }
    let!(:stored_contact_inbox) do
-      create(:contact_inbox, contact: stored_contact, inbox: whatsapp_inbox, source_id: '5541988887777')
+      create(:contact_inbox, contact: stored_contact, inbox: whatsapp_inbox, source_id: 'IN.2081978709342942')
    end

    before { account.enable_features!('channel_voice') }

-    it 'reuses the contact via normalized wa_id rather than forking a new ContactInbox' do
+    # Closes the gap: the contact was keyed by BSUID, but the call also carries a phone.
+    # Matching across every source_id reuses the contact instead of forking on the phone.
+    it 'reuses the contact by matching any source_id, not just the first' do
      call = described_class.perform!(
        inbox: whatsapp_inbox,
-        from_number: '+554188887777',
-        call_sid: 'wacall_br_1',
-        provider: :whatsapp
+        call_sid: 'wacall_bsuid_1',
+        provider: :whatsapp,
+        caller: { source_ids: ['5541988887777', 'IN.2081978709342942'],
+                  contact_attributes: { name: 'Ada Lovelace', phone_number: '+5541988887777' } }
      )

      expect(call.contact).to eq(stored_contact)
@@ -74,6 +74,120 @@ describe Whatsapp::IncomingCallService do
    end
  end

+  describe 'inbound connect from a username (BSUID) caller' do
+    let(:sdp_offer) { "v=0\r\n...sdp..." }
+    let(:bsuid) { 'IN.2081978709342942' }
+    let!(:agent) { create(:user, account: account) }
+
+    before { create(:inbox_member, inbox: inbox, user: agent) }
+
+    it 'keys a phone caller by the phone (matching messaging) even when a BSUID is also present' do
+      allow(ActionCable.server).to receive(:broadcast)
+
+      params = {
+        calls: [{ id: provider_call_id, from: from_number, from_user_id: bsuid, event: 'connect',
+                  session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+        contacts: [{ wa_id: from_number, user_id: bsuid, profile: { name: 'Ada Lovelace' } }]
+      }
+      expect { described_class.new(inbox: inbox, params: params).perform }
+        .to change(Call, :count).by(1).and change(Conversation, :count).by(1)
+
+      contact_inbox = Call.last.conversation.contact_inbox
+      expect(contact_inbox.source_id).to eq(from_number)
+      expect(contact_inbox.contact.name).to eq('Ada Lovelace')
+    end
+
+    it 'keys a username-only caller by the BSUID when no phone `from` is present' do
+      allow(ActionCable.server).to receive(:broadcast)
+
+      params = {
+        calls: [{ id: provider_call_id, from_user_id: bsuid, event: 'connect',
+                  session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+        contacts: [{ user_id: bsuid, profile: { name: 'Ada Lovelace' } }]
+      }
+      expect { described_class.new(inbox: inbox, params: params).perform }
+        .to change(Call, :count).by(1)
+
+      contact_inbox = Call.last.conversation.contact_inbox
+      expect(contact_inbox.source_id).to eq(bsuid)
+      expect(contact_inbox.contact.name).to eq('Ada Lovelace')
+    end
+
+    it 'reuses the phone-keyed ContactInbox messaging created for a phone caller and backfills the BSUID alias' do
+      allow(ActionCable.server).to receive(:broadcast)
+      contact = create(:contact, account: account)
+      existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: from_number)
+
+      params = {
+        calls: [{ id: provider_call_id, from: from_number, from_user_id: bsuid, event: 'connect',
+                  session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+        contacts: [{ wa_id: from_number, user_id: bsuid }]
+      }
+      # The conversation reuses the existing phone thread; the BSUID alias is backfilled onto the same contact.
+      expect { described_class.new(inbox: inbox, params: params).perform }
+        .to change(Call, :count).by(1).and change(ContactInbox, :count).by(1)
+
+      expect(Call.last.contact).to eq(contact)
+      expect(Call.last.conversation.contact_inbox).to eq(existing)
+      expect(inbox.contact_inboxes.find_by(source_id: bsuid).contact).to eq(contact)
+    end
+
+    it 'reuses a phone ContactInbox via the same wa_id normalization messaging uses' do
+      allow(ActionCable.server).to receive(:broadcast)
+      contact = create(:contact, account: account, phone_number: '+5541988887777')
+      existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: '5541988887777')
+
+      params = {
+        calls: [{ id: provider_call_id, from: '554188887777', event: 'connect',
+                  session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+        contacts: [{ wa_id: '554188887777' }]
+      }
+      expect { described_class.new(inbox: inbox, params: params).perform }
+        .to change(Call, :count).by(1).and not_change(ContactInbox, :count)
+
+      expect(Call.last.conversation.contact_inbox).to eq(existing)
+    end
+
+    it 'reuses the BSUID-keyed ContactInbox messaging created for a username-only caller' do
+      allow(ActionCable.server).to receive(:broadcast)
+      contact = create(:contact, account: account)
+      existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: bsuid)
+
+      params = {
+        calls: [{ id: provider_call_id, from_user_id: bsuid, event: 'connect',
+                  session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+        contacts: [{ user_id: bsuid }]
+      }
+      expect { described_class.new(inbox: inbox, params: params).perform }
+        .to change(Call, :count).by(1).and not_change(ContactInbox, :count)
+
+      expect(Call.last.contact).to eq(contact)
+      expect(Call.last.conversation.contact_inbox).to eq(existing)
+    end
+
+    # The gap: messaging created the contact username-only (BSUID-keyed), and the call now
+    # also exposes a phone. Matching across every source_id reuses the BSUID thread instead
+    # of forking a new phone-keyed contact.
+    it 'reuses a BSUID-keyed ContactInbox even when the call also carries a phone and backfills the phone alias' do
+      allow(ActionCable.server).to receive(:broadcast)
+      contact = create(:contact, account: account)
+      existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: bsuid)
+
+      params = {
+        calls: [{ id: provider_call_id, from: from_number, from_user_id: bsuid, event: 'connect',
+                  session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+        contacts: [{ wa_id: from_number, user_id: bsuid }]
+      }
+      # The conversation reuses the existing BSUID thread; the phone alias is backfilled onto the same contact.
+      expect { described_class.new(inbox: inbox, params: params).perform }
+        .to change(Call, :count).by(1).and change(ContactInbox, :count).by(1)
+
+      expect(Call.last.contact).to eq(contact)
+      expect(Call.last.conversation.contact_inbox).to eq(existing)
+      expect(inbox.contact_inboxes.find_by(source_id: from_number).contact).to eq(contact)
+    end
+  end
+
  describe 'outbound connect (existing call)' do
    let!(:call) do
      conversation = create(:conversation, account: account, inbox: inbox)
@@ -34,8 +34,8 @@ describe Whatsapp::IncomingMessageService do

      it 'appends to last conversation when if conversation already exists' do
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
-        2.times.each { create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox) }
-        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+        2.times.each { create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact) }
+        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(3)
@@ -46,7 +46,7 @@ describe Whatsapp::IncomingMessageService do
      it 'reopen last conversation if last conversation is resolved and lock to single conversation is enabled' do
        whatsapp_channel.inbox.update(lock_to_single_conversation: true)
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
-        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
        last_conversation.update(status: 'resolved')
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # no new conversation should be created
@@ -59,7 +59,7 @@ describe Whatsapp::IncomingMessageService do
      it 'creates a new conversation if last conversation is resolved and lock to single conversation is disabled' do
        whatsapp_channel.inbox.update(lock_to_single_conversation: false)
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
-        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
        last_conversation.update(status: 'resolved')
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # new conversation should be created
@@ -70,7 +70,7 @@ describe Whatsapp::IncomingMessageService do
      it 'will not create a new conversation if last conversation is not resolved and lock to single conversation is disabled' do
        whatsapp_channel.inbox.update(lock_to_single_conversation: false)
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
-        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
        last_conversation.update(status: Conversation.statuses.except('resolved').keys.sample)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # new conversation should be created
@@ -238,7 +238,7 @@ describe Whatsapp::IncomingMessageService do
      end

      before do
-        create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+        create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
      end

@@ -453,7 +453,7 @@ describe Whatsapp::IncomingMessageService do

      it 'appends to existing contact if contact inbox exists' do
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
-        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -468,7 +468,7 @@ describe Whatsapp::IncomingMessageService do
      context 'when a contact inbox exists in the old format without 9 included' do
        it 'appends to existing contact' do
          contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
-          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
          described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
          # no new conversation should be created
          expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -480,7 +480,7 @@ describe Whatsapp::IncomingMessageService do
      context 'when a contact inbox exists in the new format with 9 included' do
        it 'appends to existing contact' do
          contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: '5541988887777')
-          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
          described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
          # no new conversation should be created
          expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -515,7 +515,7 @@ describe Whatsapp::IncomingMessageService do
        # Normalized format removes the 9 after country code
        normalized_wa_id = '541123456789'
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: normalized_wa_id)
-        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -532,7 +532,7 @@ describe Whatsapp::IncomingMessageService do
      context 'when a contact inbox exists with the same format' do
        it 'appends to existing contact' do
          contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
-          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
          described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
          # no new conversation should be created
          expect(whatsapp_channel.inbox.conversations.count).to eq(1)
Author	SHA1	Message	Date
Sivin VargheseandGitHub	8a6ab8de3d	Merge branch 'develop' into feat/CW-7403	2026-07-21 19:32:05 +05:30
Tanmay Deep Sharma GitHub Muhsin Keloth	ed30ff9c22	fix(whatsapp): allow calling a contact with no existing conversation (#15014 ) ## Description Agents can now place a WhatsApp call to a contact straight from the contacts screen, even if that contact has never messaged in. Previously the call only worked once a conversation already existed, so a freshly added contact would fail with "Unable to start the call. Please try again." — the only workaround was to get the contact to message the channel first. ## Type of change - [ ] Bug fix (non-breaking change which fixes an issue) ## How Has This Been Tested? - Manually via UI ## Checklist: - [ ] My code follows the style guidelines of this project - [ ] I have performed a self-review of my code - [ ] I have commented on my code, particularly in hard-to-understand areas - [ ] I have made corresponding changes to the documentation - [ ] My changes generate no new warnings - [ ] I have added tests that prove my fix is effective or that my feature works - [ ] New and existing unit tests pass locally with my changes - [ ] Any dependent changes have been merged and published in downstream modules --------- Co-authored-by: Muhsin Keloth <muhsinkeramam@gmail.com>	2026-07-21 18:08:32 +05:30
Muhsin Keloth GitHub Muhsin	7d2f01e402	feat(whatsapp): unify embedded signup feature gating (#15106 ) WhatsApp embedded signup now uses `whatsapp_embedded_signup_inbox_creation` as the single Chatwoot Cloud rollout gate for inbox creation, proactive reconfiguration, and disconnected inbox reauthorization. The authorization endpoint enforces the same gate, so the UI and backend remain consistent. Self-hosted installations keep their existing behavior. ## Things to know - This reuses the existing feature flag; there is no migration or schema change. - The feature is shown as “WhatsApp Embedded Signup Flow” in feature management. - `whatsapp_reconfigure` remains visible and honored for self-hosted proactive reconfiguration to preserve existing accounts. It can be deprecated after the self-hosted dependency is removed or migrated. ## How to test 1. On Chatwoot Cloud, enable `whatsapp_embedded_signup_inbox_creation` for an account. 2. Confirm that new WhatsApp inbox creation, proactive reconfiguration, and disconnected inbox reauthorization are available. 3. Disable the flag and confirm those entry points are hidden and authorization requests are rejected. 4. On self-hosted, confirm proactive reconfiguration remains controlled by the existing `whatsapp_reconfigure` account setting. --------- Co-authored-by: Muhsin <12408980+muhsin-k@users.noreply.github.com>	2026-07-21 15:05:11 +04:00
Shivam MishraandGitHub	8c013415b8	fix: localize the captain overview summary greeting (#15108 )	2026-07-21 16:29:08 +05:30
Tanmay Deep SharmaandGitHub	2144de92f2	fix(whatsapp): reopen conversation across a contact's coexistence identities (#15098 ) WhatsApp contacts using coexistence are identified by more than one source ID (a phone `wa_id` and a `BR.`/BSUID identity), so a single contact ends up owning multiple `contact_inbox` records. The "reopen the same conversation" feature scoped conversation reuse to a single `contact_inbox`, so messages arriving under a different identity of the same contact started a brand-new conversation — even with reopen enabled — producing duplicate conversations. This scopes reuse to the contact across all of its `contact_inbox` records in the inbox instead of a single `contact_inbox`. ## Closes - [CW-7651 ](https://linear.app/chatwoot/issue/CW-7651/duplicate-conversations) ## How to reproduce 1. On a WhatsApp Cloud inbox with "reopen the same conversation" (lock to single conversation) enabled. 2. Have a coexistence contact whose webhooks alternate between carrying the phone `wa_id` and only the BSUID identity. 3. Before: each identity opens its own conversation → duplicates. After: incoming messages reopen the contact's existing conversation regardless of which identity the webhook carried. ## What changed - `Whatsapp::IncomingMessageBaseService#set_conversation` now looks up reusable conversations via `@contact.conversations.where(inbox_id: @inbox.id)` instead of `@contact_inbox.conversations`. - Updated existing specs to wire the conversation's `contact` to the contact_inbox's contact, mirroring production data.	2026-07-21 16:21:40 +05:30
Tanmay Deep Sharma GitHub Muhsin Keloth	0e376f4fe2	feat(whatsapp-call): support BSUID callers for inbound voice calls (#14743 ) ## Linear Ticket - https://linear.app/chatwoot/issue/CW-7276/bsuid-support-to-whatsapp-voice-calling ## Description Keeps WhatsApp voice calls in the same thread as the chat when a caller has adopted a WhatsApp username and hidden their phone number. This makes the inbound-call path BSUID-aware, reusing the same identifier the messaging pipeline keys on so calls land on the existing `ContactInbox`/conversation. ## Type of change - [ ] New feature (non-breaking change which adds functionality) ## How Has This Been Tested? - Locally via UI ## Checklist: - [ ] My code follows the style guidelines of this project - [ ] I have performed a self-review of my code - [ ] I have commented on my code, particularly in hard-to-understand areas - [ ] I have made corresponding changes to the documentation - [ ] My changes generate no new warnings - [ ] I have added tests that prove my fix is effective or that my feature works - [ ] New and existing unit tests pass locally with my changes - [ ] Any dependent changes have been merged and published in downstream modules --------- Co-authored-by: Muhsin Keloth <muhsinkeramam@gmail.com>	2026-07-21 16:19:53 +05:30
Shivam MishraandGitHub	67cab7171d	feat: show Captain generation path on conversation messages [CW-7484] (#15078 )	2026-07-21 15:15:13 +05:30
Shivam MishraandGitHub	7a5385cc32	feat: improve captain overview loading and reuse stats for summary [CW-7610] (#15105 )	2026-07-21 15:14:18 +05:30
Sivin VargheseandGitHub	920a98ccf4	fix: calls dashboard load race (#15094 )	2026-07-21 15:00:08 +05:30
Sivin VargheseandGitHub	a745f418cf	Merge branch 'develop' into feat/CW-7403	2026-07-20 15:03:45 +05:30
Sivin VargheseandGitHub	305e13c830	Merge branch 'develop' into feat/CW-7403	2026-07-01 21:24:08 +05:30
Sivin VargheseandGitHub	d5e30f7545	Merge branch 'develop' into feat/CW-7403	2026-06-25 17:27:04 +05:30
iamsivin	df7ec2f596	feat: updated the contact details page layout	2026-06-23 11:14:42 +05:30