diff --git a/app/src/components/skills/MeetingBotsCard.tsx b/app/src/components/skills/MeetingBotsCard.tsx
index b357f0103..6d0d3fa47 100644
--- a/app/src/components/skills/MeetingBotsCard.tsx
+++ b/app/src/components/skills/MeetingBotsCard.tsx
@@ -202,7 +202,15 @@ function MeetingBotsInline({ onToast, hasSubmittedRef }: MeetingBotsInlineProps)
   const { t } = useT();
   const dispatch = useAppDispatch();
   const [meetUrl, setMeetUrl] = useState('');
-  const [respondTo] = useState('');
+  // The participant the bot answers to (authorized speaker). Wired to the
+  // backend join payload as `respondToParticipant` → `respondTo`, which the
+  // meeting stream uses to gate in-call requests to this speaker only.
+  const [respondTo, setRespondTo] = useState('');
+  // Active (respond when addressed) vs listen-only (transcribe only). Defaults
+  // to active; the bot still only replies after being addressed by the wake
+  // phrase. Forwarded to the backend as `listenOnly` and mirrored into the
+  // meet slice so the active view shows the right status.
+  const [listenOnly, setListenOnly] = useState(false);
   const personaDisplayName = useAppSelector(selectPersonaDisplayName);
   const personaDescription = useAppSelector(selectPersonaDescription);
   const selectedMascotId = useAppSelector(selectSelectedMascotId);
@@ -234,7 +242,7 @@ function MeetingBotsInline({ onToast, hasSubmittedRef }: MeetingBotsInlineProps)
   }, [refreshRecentCalls]);
 
   const selectedLabel = t('skills.meetingBots.platforms.gmeet');
-  const agentName = personaDisplayName.trim() || 'OpenHuman';
+  const agentName = personaDisplayName.trim() || 'Tiny';
   const systemPrompt = personaDescription.trim() || undefined;
   const mascotId = selectedMascotId ?? (mascotColor === 'custom' ? undefined : mascotColor);
   const riveColors =
@@ -264,7 +272,7 @@ function MeetingBotsInline({ onToast, hasSubmittedRef }: MeetingBotsInlineProps)
     hasSubmittedRef.current = true;
     try {
       const meetingId = crypto.randomUUID();
-      dispatch(setBackendMeetJoining({ meetUrl: meetUrl.trim(), meetingId }));
+      dispatch(setBackendMeetJoining({ meetUrl: meetUrl.trim(), meetingId, listenOnly }));
       await joinMeetViaBackendBot({
         meetUrl,
         displayName: agentName,
@@ -275,6 +283,7 @@ function MeetingBotsInline({ onToast, hasSubmittedRef }: MeetingBotsInlineProps)
         riveColors,
         correlationId: meetingId,
         respondToParticipant: respondTo.trim() || undefined,
+        listenOnly,
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : t('skills.meetingBots.failedToStart');
@@ -315,6 +324,44 @@ function MeetingBotsInline({ onToast, hasSubmittedRef }: MeetingBotsInlineProps)
           />
         </label>
 
+        <label className="block">
+          <span className="text-[10px] font-medium uppercase tracking-wide text-stone-500 dark:text-neutral-400">
+            {t('skills.meetingBots.respondToParticipant')}
+          </span>
+          <input
+            type="text"
+            autoComplete="off"
+            spellCheck={false}
+            value={respondTo}
+            onChange={e => setRespondTo(e.target.value)}
+            placeholder={t('skills.meetingBots.respondToParticipantHint')}
+            disabled={submitting}
+            required
+            className="mt-1 w-full rounded-xl border border-stone-200 dark:border-neutral-800 bg-white dark:bg-neutral-900 px-3 py-2 text-sm text-stone-900 dark:text-neutral-100 placeholder:text-stone-400 dark:placeholder:text-neutral-500 focus:border-primary-500 focus:outline-none focus:ring-2 focus:ring-primary-100 disabled:cursor-not-allowed disabled:bg-stone-50 dark:disabled:bg-neutral-800/60"
+          />
+          <p className="mt-1 text-[10px] text-stone-400 dark:text-neutral-500">
+            {t('skills.meetingBots.respondToParticipantDesc')}
+          </p>
+        </label>
+
+        <label className="flex items-start gap-3 rounded-xl border border-stone-200 dark:border-neutral-800 px-3 py-2.5">
+          <input
+            type="checkbox"
+            checked={!listenOnly}
+            onChange={e => setListenOnly(!e.target.checked)}
+            disabled={submitting}
+            className="mt-0.5 h-4 w-4 shrink-0 rounded border-stone-300 text-primary-500 focus:ring-2 focus:ring-primary-100 disabled:cursor-not-allowed"
+          />
+          <span className="min-w-0">
+            <span className="block text-sm font-medium text-stone-800 dark:text-neutral-100">
+              {t('skills.meetingBots.activeMode')}
+            </span>
+            <span className="mt-0.5 block text-[10px] leading-relaxed text-stone-400 dark:text-neutral-500">
+              {t('skills.meetingBots.activeModeDesc')}
+            </span>
+          </span>
+        </label>
+
         {error && (
           <div
             role="alert"
@@ -326,7 +373,7 @@ function MeetingBotsInline({ onToast, hasSubmittedRef }: MeetingBotsInlineProps)
         <div className="flex items-center justify-end gap-2 pt-1">
           <button
             type="submit"
-            disabled={submitting || !meetUrl.trim()}
+            disabled={submitting || !meetUrl.trim() || !respondTo.trim()}
             className="rounded-xl bg-primary-500 px-4 py-2 text-sm font-semibold text-white hover:bg-primary-600 disabled:cursor-not-allowed disabled:bg-stone-200 dark:disabled:bg-neutral-700 disabled:text-stone-400 dark:disabled:text-neutral-500">
             {submitting
               ? t('skills.meetingBots.starting')
diff --git a/app/src/components/skills/__tests__/MeetingBotsCard.test.tsx b/app/src/components/skills/__tests__/MeetingBotsCard.test.tsx
index e00681599..9bc663e0a 100644
--- a/app/src/components/skills/__tests__/MeetingBotsCard.test.tsx
+++ b/app/src/components/skills/__tests__/MeetingBotsCard.test.tsx
@@ -49,6 +49,9 @@ describe('MeetingBotsCard', () => {
     fireEvent.change(screen.getByLabelText(/meeting link/i), {
       target: { value: 'https://meet.google.com/abc-defg-hij' },
     });
+    fireEvent.change(screen.getByLabelText(/your name in this meeting/i), {
+      target: { value: 'Alice' },
+    });
     const form = document.querySelector('form')!;
     fireEvent.submit(form);
 
@@ -56,9 +59,13 @@ describe('MeetingBotsCard', () => {
       expect(joinMock).toHaveBeenCalledWith(
         expect.objectContaining({
           meetUrl: 'https://meet.google.com/abc-defg-hij',
-          displayName: 'OpenHuman',
+          displayName: 'Tiny',
           platform: 'gmeet',
-          agentName: 'OpenHuman',
+          agentName: 'Tiny',
+          // Participant-name field is wired to the backend authorized-speaker gate.
+          respondToParticipant: 'Alice',
+          // Active toggle defaults to checked → listen-only false.
+          listenOnly: false,
         })
       );
     });
@@ -169,10 +176,32 @@ describe('MeetingBotsCard', () => {
     expect(screen.getByRole('button', { name: /send to google meet/i })).toBeInTheDocument();
   });
 
-  it('only asks for the meeting link in passive mode', () => {
+  it('asks for the meeting link and the participant the bot answers to', () => {
     renderWithProviders(<MeetingBotsCard />);
     expect(screen.getByLabelText(/meeting link/i)).toBeInTheDocument();
-    expect(screen.queryByLabelText(/your name in this meeting/i)).not.toBeInTheDocument();
+    expect(screen.getByLabelText(/your name in this meeting/i)).toBeInTheDocument();
+  });
+
+  it('forwards listen-only when the active toggle is unchecked', async () => {
+    joinMock.mockResolvedValueOnce({
+      meetUrl: 'https://meet.google.com/abc-defg-hij',
+      platform: 'gmeet',
+    });
+    renderWithProviders(<MeetingBotsCard />);
+
+    fireEvent.change(screen.getByLabelText(/meeting link/i), {
+      target: { value: 'https://meet.google.com/abc-defg-hij' },
+    });
+    fireEvent.change(screen.getByLabelText(/your name in this meeting/i), {
+      target: { value: 'Alice' },
+    });
+    // Active toggle is checked by default; unchecking it selects listen-only.
+    fireEvent.click(screen.getByRole('checkbox'));
+    fireEvent.submit(document.querySelector('form')!);
+
+    await vi.waitFor(() => {
+      expect(joinMock).toHaveBeenCalledWith(expect.objectContaining({ listenOnly: true }));
+    });
   });
 });
 
diff --git a/app/src/lib/i18n/ar.ts b/app/src/lib/i18n/ar.ts
index 944c4f467..c96024934 100644
--- a/app/src/lib/i18n/ar.ts
+++ b/app/src/lib/i18n/ar.ts
@@ -4492,6 +4492,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'عبارة التنشيط',
   'skills.meetingBots.wakePhraseHint': 'مرحباً OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'يجب أن يقول المشارك هذا قبل أن يرد البوت.',
+  'skills.meetingBots.activeMode': 'الرد عندما أناديه',
+  'skills.meetingBots.activeModeDesc':
+    'عند التفعيل، يرد البوت بصوت مسموع بعد أن تقول عبارة التنبيه. عند الإيقاف، يكتفي بالاستماع وتدوين النص.',
   'skills.resource.preview.closeAriaLabel': 'إغلاق المعاينة',
   'skills.resource.preview.failed': 'فشلت المعاينة',
   'skills.resource.preview.loading': 'جارٍ تحميل المعاينة…',
diff --git a/app/src/lib/i18n/bn.ts b/app/src/lib/i18n/bn.ts
index 122ec3499..24f5d18d5 100644
--- a/app/src/lib/i18n/bn.ts
+++ b/app/src/lib/i18n/bn.ts
@@ -4584,6 +4584,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'ওয়েক ফ্রেজ',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'বট সাড়া দেওয়ার আগে অংশগ্রহণকারীকে এটি বলতে হবে।',
+  'skills.meetingBots.activeMode': 'আমি ডাকলে উত্তর দেবে',
+  'skills.meetingBots.activeModeDesc':
+    'চালু থাকলে, আপনি ওয়েক ফ্রেজ বললে বটটি সশব্দে উত্তর দেয়। বন্ধ থাকলে, এটি শুধু শোনে ও প্রতিলিপি তৈরি করে।',
   'skills.resource.preview.closeAriaLabel': 'প্রিভিউ বন্ধ করুন',
   'skills.resource.preview.failed': 'প্রিভিউ ব্যর্থ',
   'skills.resource.preview.loading': 'প্রিভিউ লোড হচ্ছে…',
diff --git a/app/src/lib/i18n/de.ts b/app/src/lib/i18n/de.ts
index e4acb4c08..b6b62a10b 100644
--- a/app/src/lib/i18n/de.ts
+++ b/app/src/lib/i18n/de.ts
@@ -4701,6 +4701,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Wake-Phrase',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'Der Teilnehmer muss dies sagen, bevor der Bot antwortet.',
+  'skills.meetingBots.activeMode': 'Antworten, wenn ich es anspreche',
+  'skills.meetingBots.activeModeDesc':
+    'Wenn aktiviert, antwortet der Bot hörbar, nachdem du seinen Weckruf gesagt hast. Wenn deaktiviert, hört er nur zu und transkribiert.',
   'skills.resource.preview.closeAriaLabel': 'Vorschau schließen',
   'skills.resource.preview.failed': 'Vorschau fehlgeschlagen',
   'skills.resource.preview.loading': 'Vorschau wird geladen…',
diff --git a/app/src/lib/i18n/en.ts b/app/src/lib/i18n/en.ts
index 9ce678fc4..b7935ef6a 100644
--- a/app/src/lib/i18n/en.ts
+++ b/app/src/lib/i18n/en.ts
@@ -5136,6 +5136,9 @@ const en: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Wake Phrase',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'Participant must say this before the bot responds.',
+  'skills.meetingBots.activeMode': 'Respond when I address it',
+  'skills.meetingBots.activeModeDesc':
+    'When on, the bot speaks a reply after you say its wake phrase. When off, it only listens and transcribes.',
   'skills.resource.preview.closeAriaLabel': 'Close preview',
   'skills.resource.preview.failed': 'Preview failed',
   'skills.resource.preview.loading': 'Loading preview…',
diff --git a/app/src/lib/i18n/es.ts b/app/src/lib/i18n/es.ts
index e5214e0c4..4147cb770 100644
--- a/app/src/lib/i18n/es.ts
+++ b/app/src/lib/i18n/es.ts
@@ -4672,6 +4672,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc':
     'El participante debe decir esto antes de que el bot responda.',
+  'skills.meetingBots.activeMode': 'Responder cuando me dirija a él',
+  'skills.meetingBots.activeModeDesc':
+    'Si está activado, el bot responde en voz alta después de que digas su frase de activación. Si está desactivado, solo escucha y transcribe.',
   'skills.resource.preview.closeAriaLabel': 'Cerrar vista previa',
   'skills.resource.preview.failed': 'Vista previa fallida',
   'skills.resource.preview.loading': 'Cargando vista previa…',
diff --git a/app/src/lib/i18n/fr.ts b/app/src/lib/i18n/fr.ts
index 6c5583af6..ce7857165 100644
--- a/app/src/lib/i18n/fr.ts
+++ b/app/src/lib/i18n/fr.ts
@@ -4692,6 +4692,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Phrase de réveil',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'Le participant doit dire ceci avant que le bot réponde.',
+  'skills.meetingBots.activeMode': 'Répondre quand je m’adresse à lui',
+  'skills.meetingBots.activeModeDesc':
+    'Activé, le bot répond à voix haute après que vous prononcez sa phrase d’activation. Désactivé, il se contente d’écouter et de transcrire.',
   'skills.resource.preview.closeAriaLabel': "Fermer l'aperçu",
   'skills.resource.preview.failed': "Échec de l'aperçu",
   'skills.resource.preview.loading': "Chargement de l'aperçu…",
diff --git a/app/src/lib/i18n/hi.ts b/app/src/lib/i18n/hi.ts
index 6a908103b..351a47dee 100644
--- a/app/src/lib/i18n/hi.ts
+++ b/app/src/lib/i18n/hi.ts
@@ -4588,6 +4588,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'वेक फ्रेज़',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'बोट के जवाब देने से पहले प्रतिभागी को यह कहना होगा।',
+  'skills.meetingBots.activeMode': 'जब मैं बुलाऊँ तब जवाब दे',
+  'skills.meetingBots.activeModeDesc':
+    'चालू होने पर, वेक फ़्रेज़ कहने के बाद बॉट बोलकर जवाब देता है। बंद होने पर, यह सिर्फ़ सुनता और ट्रांसक्राइब करता है।',
   'skills.resource.preview.closeAriaLabel': 'प्रीव्यू बंद करें',
   'skills.resource.preview.failed': 'पूर्वावलोकन विफल',
   'skills.resource.preview.loading': 'प्रीव्यू लोड हो रहा है…',
diff --git a/app/src/lib/i18n/id.ts b/app/src/lib/i18n/id.ts
index 96d37545d..35ff6905a 100644
--- a/app/src/lib/i18n/id.ts
+++ b/app/src/lib/i18n/id.ts
@@ -4601,6 +4601,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Frasa Bangun',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'Peserta harus mengucapkan ini sebelum bot merespons.',
+  'skills.meetingBots.activeMode': 'Tanggapi saat saya menyapa',
+  'skills.meetingBots.activeModeDesc':
+    'Saat aktif, bot menjawab dengan suara setelah Anda mengucapkan frasa pemicunya. Saat nonaktif, bot hanya mendengarkan dan mentranskripsikan.',
   'skills.resource.preview.closeAriaLabel': 'Tutup pratinjau',
   'skills.resource.preview.failed': 'Pratinjau gagal',
   'skills.resource.preview.loading': 'Memuat pratinjau...',
diff --git a/app/src/lib/i18n/it.ts b/app/src/lib/i18n/it.ts
index 59e0e2872..38430590f 100644
--- a/app/src/lib/i18n/it.ts
+++ b/app/src/lib/i18n/it.ts
@@ -4662,6 +4662,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Frase di attivazione',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'Il partecipante deve dirlo prima che il bot risponda.',
+  'skills.meetingBots.activeMode': 'Rispondi quando mi rivolgo a lui',
+  'skills.meetingBots.activeModeDesc':
+    'Se attivo, il bot risponde ad alta voce dopo che pronunci la sua frase di attivazione. Se disattivato, si limita ad ascoltare e trascrivere.',
   'skills.resource.preview.closeAriaLabel': 'Chiudi anteprima',
   'skills.resource.preview.failed': 'Anteprima fallita',
   'skills.resource.preview.loading': 'Caricamento anteprima…',
diff --git a/app/src/lib/i18n/ko.ts b/app/src/lib/i18n/ko.ts
index 19ce807f5..85d1fe469 100644
--- a/app/src/lib/i18n/ko.ts
+++ b/app/src/lib/i18n/ko.ts
@@ -4540,6 +4540,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': '웨이크 구문',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': '참가자가 봇이 응답하기 전에 이것을 말해야 합니다.',
+  'skills.meetingBots.activeMode': '부르면 응답하기',
+  'skills.meetingBots.activeModeDesc':
+    '켜면 호출 문구를 말한 뒤 봇이 소리 내어 답합니다. 끄면 듣고 기록만 합니다.',
   'skills.resource.preview.closeAriaLabel': '미리보기 닫기',
   'skills.resource.preview.failed': '미리보기 실패',
   'skills.resource.preview.loading': '미리보기 불러오는 중…',
diff --git a/app/src/lib/i18n/pl.ts b/app/src/lib/i18n/pl.ts
index b269bd842..de4751a85 100644
--- a/app/src/lib/i18n/pl.ts
+++ b/app/src/lib/i18n/pl.ts
@@ -4656,6 +4656,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Fraza aktywacji',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'Uczestnik musi to powiedzieć, zanim bot odpowie.',
+  'skills.meetingBots.activeMode': 'Odpowiadaj, gdy się do niego zwracam',
+  'skills.meetingBots.activeModeDesc':
+    'Gdy włączone, bot odpowiada na głos po wypowiedzeniu frazy aktywującej. Gdy wyłączone, tylko słucha i transkrybuje.',
   'skills.resource.preview.closeAriaLabel': 'Zamknij podgląd',
   'skills.resource.preview.failed': 'Podgląd nie powiódł się',
   'skills.resource.preview.loading': 'Wczytywanie podglądu…',
diff --git a/app/src/lib/i18n/pt.ts b/app/src/lib/i18n/pt.ts
index 2e53885c6..14337e273 100644
--- a/app/src/lib/i18n/pt.ts
+++ b/app/src/lib/i18n/pt.ts
@@ -4664,6 +4664,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Frase de ativação',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'O participante deve dizer isso antes de o bot responder.',
+  'skills.meetingBots.activeMode': 'Responder quando eu falar com ele',
+  'skills.meetingBots.activeModeDesc':
+    'Quando ativado, o bot responde em voz alta depois que você diz a frase de ativação. Quando desativado, ele apenas ouve e transcreve.',
   'skills.resource.preview.closeAriaLabel': 'Fechar visualização',
   'skills.resource.preview.failed': 'Falha na pré-visualização',
   'skills.resource.preview.loading': 'Carregando visualização…',
diff --git a/app/src/lib/i18n/ru.ts b/app/src/lib/i18n/ru.ts
index b40a8bc22..2020d8ecd 100644
--- a/app/src/lib/i18n/ru.ts
+++ b/app/src/lib/i18n/ru.ts
@@ -4627,6 +4627,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': 'Фраза активации',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': 'Участник должен произнести это, прежде чем бот ответит.',
+  'skills.meetingBots.activeMode': 'Отвечать, когда я обращаюсь',
+  'skills.meetingBots.activeModeDesc':
+    'Когда включено, бот отвечает вслух после того, как вы произнесёте фразу-обращение. Когда выключено, он только слушает и расшифровывает.',
   'skills.resource.preview.closeAriaLabel': 'Закрыть предпросмотр',
   'skills.resource.preview.failed': 'Не удалось показать превью',
   'skills.resource.preview.loading': 'Загрузка предпросмотра…',
diff --git a/app/src/lib/i18n/zh-CN.ts b/app/src/lib/i18n/zh-CN.ts
index 535db9029..6b1f8a868 100644
--- a/app/src/lib/i18n/zh-CN.ts
+++ b/app/src/lib/i18n/zh-CN.ts
@@ -4357,6 +4357,9 @@ const messages: TranslationMap = {
   'skills.meetingBots.wakePhrase': '唤醒词',
   'skills.meetingBots.wakePhraseHint': 'Hey OpenHuman',
   'skills.meetingBots.wakePhraseDesc': '参与者必须先说出此词，机器人才会回复。',
+  'skills.meetingBots.activeMode': '当我呼叫时回应',
+  'skills.meetingBots.activeModeDesc':
+    '开启后，说出唤醒词后机器人会出声回答。关闭后，它只聆听并转写。',
   'skills.resource.preview.closeAriaLabel': '关闭预览',
   'skills.resource.preview.failed': '预览失败',
   'skills.resource.preview.loading': '加载预览中…',
diff --git a/src/core/event_bus/events.rs b/src/core/event_bus/events.rs
index bafd51901..b151f719a 100644
--- a/src/core/event_bus/events.rs
+++ b/src/core/event_bus/events.rs
@@ -1022,6 +1022,22 @@ pub enum DomainEvent {
         recent_transcript: Vec<BackendMeetTurn>,
         timestamp_ms: u64,
     },
+    /// Core asked the backend bot to speak into the call (`bot:speak`).
+    /// Published for observability after the Socket.IO emit succeeds.
+    BackendMeetSpeak {
+        text: String,
+        correlation_id: Option<String>,
+    },
+    /// An approval was parked during a live-meeting orchestrator turn
+    /// (issue #3513). The meeting bus speaks the prompt into the call;
+    /// the decision arrives by voice ("Hey Tiny, approve") or the
+    /// standard thread approval card — first response wins.
+    InCallApprovalRequested {
+        request_id: String,
+        tool_name: String,
+        action_summary: String,
+        correlation_id: Option<String>,
+    },
     /// A Google Calendar event with a Meet link was detected and the
     /// auto-join policy is "ask" — the UI should prompt the user.
     MeetAutoJoinPrompt {
@@ -1177,6 +1193,8 @@ impl DomainEvent {
             | Self::BackendMeetTranscript { .. }
             | Self::BackendMeetError { .. }
             | Self::BackendMeetInCallRequest { .. }
+            | Self::BackendMeetSpeak { .. }
+            | Self::InCallApprovalRequested { .. }
             | Self::MeetAutoJoinPrompt { .. }
             | Self::MeetingSummaryGenerated { .. } => "agent_meetings",
         }
@@ -1295,6 +1313,8 @@ impl DomainEvent {
             Self::BackendMeetTranscript { .. } => "BackendMeetTranscript",
             Self::BackendMeetError { .. } => "BackendMeetError",
             Self::BackendMeetInCallRequest { .. } => "BackendMeetInCallRequest",
+            Self::BackendMeetSpeak { .. } => "BackendMeetSpeak",
+            Self::InCallApprovalRequested { .. } => "InCallApprovalRequested",
             Self::MeetAutoJoinPrompt { .. } => "MeetAutoJoinPrompt",
             Self::MeetingSummaryGenerated { .. } => "MeetingSummaryGenerated",
             Self::Voice(_) => "Voice",
diff --git a/src/openhuman/agent_meetings/bus.rs b/src/openhuman/agent_meetings/bus.rs
index fae9808ed..8c799333d 100644
--- a/src/openhuman/agent_meetings/bus.rs
+++ b/src/openhuman/agent_meetings/bus.rs
@@ -103,6 +103,25 @@ impl EventHandler for MeetingEventSubscriber {
                     correlation_id = ?correlation_id,
                     "{LOG_PREFIX} bot joined meeting"
                 );
+                // Pre-warm the per-meeting orchestrator so the first
+                // wake-phrase command doesn't pay the 5-10s cold build.
+                // Spawned (the build is slow) and gated on agency being
+                // enabled, so listen-only / agency-off meetings don't build
+                // an agent they'll never use.
+                let correlation_id = correlation_id.clone();
+                tokio::spawn(async move {
+                    let agency_on = crate::openhuman::config::Config::load_or_init()
+                        .await
+                        .map(|c| c.meet.enable_in_call_agency)
+                        .unwrap_or(false);
+                    // Also pre-warm for meetings joined in active mode via the
+                    // per-meeting toggle, so they get the same first-command
+                    // latency win as globally-enabled agency.
+                    let active = super::in_call::is_meeting_active(correlation_id.as_deref()).await;
+                    if agency_on || active {
+                        super::in_call::prewarm_agent(correlation_id.as_deref()).await;
+                    }
+                });
             }
 
             DomainEvent::BackendMeetLeft {
@@ -114,6 +133,63 @@ impl EventHandler for MeetingEventSubscriber {
                     correlation_id = ?correlation_id,
                     "{LOG_PREFIX} bot left meeting"
                 );
+                // Free the per-meeting orchestrator built for in-call agency.
+                super::in_call::clear_meeting_agent(correlation_id.as_deref()).await;
+            }
+
+            DomainEvent::InCallApprovalRequested {
+                request_id,
+                tool_name,
+                action_summary,
+                correlation_id,
+            } => {
+                tracing::info!(
+                    request_id = %request_id,
+                    tool = %tool_name,
+                    correlation_id = ?correlation_id,
+                    "{LOG_PREFIX} in-call approval parked — speaking prompt into call"
+                );
+                let action_summary = action_summary.clone();
+                let correlation_id = correlation_id.clone();
+                tokio::spawn(async move {
+                    super::in_call::speak_approval_prompt(
+                        &action_summary,
+                        correlation_id.as_deref(),
+                    )
+                    .await;
+                });
+            }
+
+            DomainEvent::BackendMeetInCallRequest {
+                correlation_id,
+                speaker,
+                command_text,
+                recent_transcript,
+                timestamp_ms,
+            } => {
+                tracing::info!(
+                    correlation_id = ?correlation_id,
+                    speaker = %speaker,
+                    cmd_len = command_text.len(),
+                    "{LOG_PREFIX} in-call request received"
+                );
+                // The orchestrator turn can run for tens of seconds (tools,
+                // integrations) — spawn so the event bus isn't blocked.
+                let correlation_id = correlation_id.clone();
+                let speaker = speaker.clone();
+                let command_text = command_text.clone();
+                let recent_transcript = recent_transcript.clone();
+                let timestamp_ms = *timestamp_ms;
+                tokio::spawn(async move {
+                    super::in_call::handle_in_call_request(
+                        correlation_id,
+                        speaker,
+                        command_text,
+                        recent_transcript,
+                        timestamp_ms,
+                    )
+                    .await;
+                });
             }
 
             _ => {}
diff --git a/src/openhuman/agent_meetings/calendar.rs b/src/openhuman/agent_meetings/calendar.rs
index 8a77bed0d..b671d3aaa 100644
--- a/src/openhuman/agent_meetings/calendar.rs
+++ b/src/openhuman/agent_meetings/calendar.rs
@@ -26,6 +26,13 @@ use crate::core::event_bus::{
     publish_global, subscribe_global, DomainEvent, EventHandler, SubscriptionHandle,
 };
 use crate::openhuman::config::rpc as config_rpc;
+use crate::openhuman::notifications::bus::publish_core_notification;
+use crate::openhuman::notifications::types::{
+    CoreNotificationAction, CoreNotificationCategory, CoreNotificationEvent,
+};
+
+use super::store;
+use super::types::{AutoJoinSource, MeetingSession, MeetingSessionStatus};
 
 static MEET_CALENDAR_HANDLE: OnceLock<SubscriptionHandle> = OnceLock::new();
 
@@ -166,12 +173,73 @@ impl EventHandler for MeetCalendarSubscriber {
                 return;
             }
             crate::openhuman::config::schema::AutoJoinPolicy::AskEachTime => {
-                // Default: ask — publish a prompt for the UI.
+                // Default: ask — create a Pending session and surface an
+                // actionable notification (issue #3507). The buttons route
+                // through `agent_meetings_notification_action`.
                 tracing::info!(
                     meet_url = %meet_url,
                     title = %event_title,
                     "[meet:calendar] auto_join_policy=ask_each_time, prompting user"
                 );
+
+                // Dedupe: one prompt per meeting URL while a session is
+                // still open (Composio can re-fire the trigger on event
+                // updates).
+                if let Ok(Some(existing)) = store::get_session_by_meet_url(&config, &meet_url) {
+                    if existing.status != MeetingSessionStatus::Ended {
+                        tracing::debug!(
+                            meeting_id = %existing.id,
+                            "[meet:calendar] open session already exists — skipping re-prompt"
+                        );
+                        return;
+                    }
+                }
+
+                let meeting_id = uuid::Uuid::new_v4().to_string();
+                let now_ms = chrono::Utc::now().timestamp_millis().max(0) as u64;
+                let session = MeetingSession {
+                    id: meeting_id.clone(),
+                    meet_url: meet_url.clone(),
+                    title: Some(event_title.clone()),
+                    calendar_event_id: None,
+                    status: MeetingSessionStatus::Pending,
+                    source: AutoJoinSource::Calendar,
+                    thread_id: None,
+                    transcript_received: false,
+                    summary_generated: false,
+                    created_at_ms: now_ms,
+                    updated_at_ms: now_ms,
+                };
+                if let Err(e) = store::create_session(&config, &session) {
+                    tracing::warn!("[meet:calendar] session create failed (non-fatal): {e}");
+                }
+
+                let action_payload = serde_json::json!({
+                    "meetingId": meeting_id,
+                    "meetUrl": meet_url,
+                    "title": event_title,
+                });
+                let action = |action_id: &str, label: &str| CoreNotificationAction {
+                    action_id: action_id.to_string(),
+                    label: label.to_string(),
+                    payload: Some(action_payload.clone()),
+                };
+                publish_core_notification(CoreNotificationEvent {
+                    id: format!("meet-auto-join:{meeting_id}"),
+                    category: CoreNotificationCategory::Meetings,
+                    title: format!("Meeting starting: {event_title}"),
+                    body: "Add Tiny to this meeting?".to_string(),
+                    deep_link: None,
+                    timestamp_ms: now_ms,
+                    actions: Some(vec![
+                        action("join_listen", "Join (listen only)"),
+                        action("join_active", "Join & reply"),
+                        action("skip", "Not this one"),
+                        action("always_join", "Always join"),
+                    ]),
+                });
+
+                // Legacy prompt event kept for existing consumers.
                 publish_global(DomainEvent::MeetAutoJoinPrompt {
                     meet_url,
                     event_title,
@@ -350,7 +418,7 @@ async fn auto_join_meeting(
 
     let payload = json!({
         "meetUrl": meet_url,
-        "displayName": "OpenHuman",
+        "displayName": "Tiny",
         "correlationId": correlation_id,
         "listenOnly": listen_only,
     });
diff --git a/src/openhuman/agent_meetings/in_call.rs b/src/openhuman/agent_meetings/in_call.rs
new file mode 100644
index 000000000..452b35f12
--- /dev/null
+++ b/src/openhuman/agent_meetings/in_call.rs
@@ -0,0 +1,1050 @@
+//! In-call agency (PR-6, issue #3512).
+//!
+//! Handles `BackendMeetInCallRequest` events — wake-phrase commands the
+//! backend Recall bot detected mid-call ("Hey Tiny, schedule a follow-up")
+//! — by routing them through the FULL orchestrator agent (the same brain
+//! the in-app chat uses: memory tree, connected integrations, MCP, tools)
+//! and speaking the reply back into the call via the outbound `bot:speak`
+//! Socket.IO event.
+//!
+//! Latency design:
+//! - One orchestrator `Agent` is built per meeting (keyed by correlation
+//!   id) and cached for the meeting's lifetime, so only the first command
+//!   pays the cold build; later turns reuse in-memory history.
+//! - If the orchestrator takes longer than [`ACK_AFTER_SECS`], a short
+//!   spoken ack ("On it — one moment.") bridges the silence so the
+//!   participant knows the bot heard them.
+//!
+//! Gated by either the per-meeting active-mode toggle (`listen_only = false`
+//! at join, tracked in [`ACTIVE_MEETINGS`]) or the global
+//! `config.meet.enable_in_call_agency` master override (default `false`).
+
+use std::collections::{HashMap, HashSet};
+use std::sync::{Arc, OnceLock};
+use std::time::Duration;
+
+use serde_json::json;
+use tokio::sync::{mpsc, Mutex as TokioMutex, Notify};
+
+use crate::core::event_bus::BackendMeetTurn;
+use crate::openhuman::agent::harness::session::Agent;
+use crate::openhuman::agent::progress::AgentProgress;
+use crate::openhuman::approval::{
+    parse_approval_reply, ApprovalChatContext, ApprovalDecision, ApprovalGate,
+    InCallApprovalContext, APPROVAL_CHAT_CONTEXT, APPROVAL_IN_CALL_CONTEXT,
+};
+use crate::openhuman::meet_agent::brain::strip_for_speech;
+use crate::openhuman::socket::global_socket_manager;
+
+const LOG_PREFIX: &str = "[agent_meetings::in_call]";
+
+/// Wall-clock ceiling on one orchestrator turn. Slow Composio
+/// integrations can take 60-80s, and a turn may additionally park up to
+/// 120s inside the approval gate waiting for a voice/card decision
+/// (issue #3513) — the ceiling must outlive park + execution, otherwise
+/// the timeout would cancel a still-pending approval.
+const IN_CALL_TURN_TIMEOUT_SECS: u64 = 180;
+
+/// If the orchestrator hasn't replied within this window, speak a short
+/// ack so the participant isn't left wondering whether the bot heard.
+const ACK_AFTER_SECS: u64 = 3;
+
+/// Spoken when the turn outlives [`ACK_AFTER_SECS`].
+const ACK_PHRASE: &str = "On it — one moment.";
+
+/// Spoken when the turn fails or times out. Generic on purpose: error
+/// details go to logs, not into the call.
+const FAILURE_PHRASE: &str = "Sorry, I couldn't finish that. I'll note it in the meeting thread.";
+
+/// How many trailing transcript turns are included as meeting context.
+const RECENT_TRANSCRIPT_WINDOW: usize = 20;
+
+/// Voice directive baked into the per-meeting orchestrator's system
+/// prompt suffix. The reply is read aloud by TTS into a live call.
+const IN_CALL_VOICE_DIRECTIVE: &str = "\
+You are attending a live meeting as a spoken voice assistant. A \
+participant has addressed you by your wake phrase. Your reply will be \
+synthesized to speech and played into the call, so: answer in one or two \
+short conversational sentences; never use markdown, bullet lists, code, \
+URLs, or emoji; round numbers to something speakable; if the request \
+needs a tool or integration you have access to, use it rather than \
+guessing. If you genuinely need clarification, ask one short question. \
+Stay strictly on the participant's request — do not volunteer summaries \
+or commentary on the rest of the meeting.";
+
+/// Per-meeting orchestrator cache keyed by correlation id. Same pattern
+/// as `meet_agent::brain`: the Agent's in-memory history accumulates
+/// across turns so follow-up commands can reference earlier ones, and
+/// later turns skip the 5-10s cold build.
+static AGENT_CACHE: OnceLock<TokioMutex<HashMap<String, Arc<TokioMutex<Agent>>>>> = OnceLock::new();
+
+fn agent_cache() -> &'static TokioMutex<HashMap<String, Arc<TokioMutex<Agent>>>> {
+    AGENT_CACHE.get_or_init(|| TokioMutex::new(HashMap::new()))
+}
+
+/// Per-meeting thread id cache so each exchange doesn't re-hit the
+/// session store (and so meetings without a session row still reuse the
+/// thread created for their first exchange).
+static THREAD_CACHE: OnceLock<TokioMutex<HashMap<String, String>>> = OnceLock::new();
+
+fn thread_cache() -> &'static TokioMutex<HashMap<String, String>> {
+    THREAD_CACHE.get_or_init(|| TokioMutex::new(HashMap::new()))
+}
+
+/// Meetings explicitly joined in active mode (`listen_only = false`, set via
+/// the "respond when addressed" toggle in the join modal). A meeting in this
+/// set dispatches in-call commands even when the global
+/// `config.meet.enable_in_call_agency` default is off — the per-meeting toggle
+/// is the source of truth, with the global flag acting as an always-on master
+/// override. Populated by `handle_join`, cleared on `BackendMeetLeft`.
+static ACTIVE_MEETINGS: OnceLock<TokioMutex<HashSet<String>>> = OnceLock::new();
+
+fn active_meetings() -> &'static TokioMutex<HashSet<String>> {
+    ACTIVE_MEETINGS.get_or_init(|| TokioMutex::new(HashSet::new()))
+}
+
+/// Mark a meeting as active-mode so its in-call commands are dispatched
+/// regardless of the global agency default. Idempotent.
+pub(super) async fn mark_meeting_active(correlation_id: Option<&str>) {
+    let key = cache_key(correlation_id);
+    if active_meetings().lock().await.insert(key.clone()) {
+        tracing::info!("{LOG_PREFIX} meeting marked active (in-call agency enabled) meeting={key}");
+    }
+}
+
+/// True when the meeting was joined in active mode (`listen_only = false`).
+pub(super) async fn is_meeting_active(correlation_id: Option<&str>) -> bool {
+    let key = cache_key(correlation_id);
+    active_meetings().lock().await.contains(&key)
+}
+
+/// Drop the cached orchestrator + thread id for a finished meeting.
+/// Called from the bus on `BackendMeetLeft` so a long-lived process
+/// doesn't accumulate one Agent per meeting forever.
+pub async fn clear_meeting_agent(correlation_id: Option<&str>) {
+    let key = cache_key(correlation_id);
+    if agent_cache().lock().await.remove(&key).is_some() {
+        tracing::info!("{LOG_PREFIX} dropped cached agent for meeting={key}");
+    }
+    thread_cache().lock().await.remove(&key);
+    active_meetings().lock().await.remove(&key);
+}
+
+/// Pre-build the per-meeting orchestrator when the bot joins, so the first
+/// wake-phrase command doesn't pay the 5-10s cold build. Best-effort: a
+/// failure just means the first turn falls back to building it lazily. Safe
+/// to race with the first request — `get_or_build_agent` is idempotent
+/// (whoever inserts last wins; an orphaned build is simply dropped).
+pub(super) async fn prewarm_agent(correlation_id: Option<&str>) {
+    let key = cache_key(correlation_id);
+    if agent_cache().lock().await.contains_key(&key) {
+        return; // already built (e.g. a fast first command beat us to it)
+    }
+    match get_or_build_agent(correlation_id).await {
+        Ok(_) => tracing::info!("{LOG_PREFIX} pre-warmed orchestrator for meeting={key}"),
+        Err(e) => tracing::warn!("{LOG_PREFIX} pre-warm failed for meeting={key}: {e}"),
+    }
+}
+
+fn cache_key(correlation_id: Option<&str>) -> String {
+    correlation_id
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .unwrap_or("default")
+        .to_string()
+}
+
+/// Entry point, called from `bus.rs` (spawned — must not block the bus).
+pub async fn handle_in_call_request(
+    correlation_id: Option<String>,
+    speaker: String,
+    command_text: String,
+    recent_transcript: Vec<BackendMeetTurn>,
+    timestamp_ms: u64,
+) {
+    let command = command_text.trim();
+    if command.is_empty() {
+        tracing::debug!("{LOG_PREFIX} empty command_text — ignoring");
+        return;
+    }
+
+    let cfg = crate::openhuman::config::Config::load_or_init().await.ok();
+    let global_agency = cfg
+        .as_ref()
+        .map(|c| c.meet.enable_in_call_agency)
+        .unwrap_or(false);
+    // The per-meeting "respond when addressed" toggle (listen_only = false)
+    // enables agency for just this call; the global flag is an always-on
+    // master override. Either path lets the command through.
+    let enabled = global_agency || is_meeting_active(correlation_id.as_deref()).await;
+    if !enabled {
+        tracing::info!(
+            "{LOG_PREFIX} in-call request dropped (listen-only meeting and \
+             config.meet.enable_in_call_agency = false) speaker={speaker} cmd_len={}",
+            command.len()
+        );
+        return;
+    }
+    // Stream the reply sentence-by-sentence as the LLM generates it (default)
+    // so the bot starts speaking on sentence one, vs one buffered emit.
+    let streaming = cfg
+        .as_ref()
+        .map(|c| c.meet.in_call_streaming)
+        .unwrap_or(true);
+
+    // Voice approval channel (issue #3513): when an approval is parked on
+    // this meeting and the wake-phrase command parses as a yes/no, route
+    // it as the decision instead of dispatching a fresh orchestrator turn.
+    // Anything that isn't a clear yes/no falls through as a new command —
+    // the parked approval stays parked (card / later voice can decide it).
+    if try_voice_approval_decision(correlation_id.as_deref(), command).await {
+        return;
+    }
+
+    tracing::info!(
+        correlation_id = ?correlation_id,
+        speaker = %speaker,
+        cmd_len = command.len(),
+        transcript_turns = recent_transcript.len(),
+        timestamp_ms = timestamp_ms,
+        "{LOG_PREFIX} dispatching in-call command to orchestrator"
+    );
+
+    // Speculative ack: if the orchestrator outlives ACK_AFTER_SECS without
+    // speaking, a short filler bridges the silence so the participant knows
+    // the bot heard. Cancelled by the first spoken chunk (streaming) or by
+    // the turn completing.
+    let ack_cancel = Arc::new(Notify::new());
+    let ack_cid = correlation_id.clone();
+    let ack_cancel_task = ack_cancel.clone();
+    let ack_task = tokio::spawn(async move {
+        tokio::select! {
+            _ = tokio::time::sleep(Duration::from_secs(ACK_AFTER_SECS)) => {
+                if let Err(e) = emit_bot_speak(ACK_PHRASE, ack_cid.as_deref()).await {
+                    tracing::debug!("[agent_meetings::in_call] ack emit failed: {e}");
+                }
+            }
+            _ = ack_cancel_task.notified() => {}
+        }
+    });
+
+    let reply = run_orchestrator_turn(
+        correlation_id.as_deref(),
+        &speaker,
+        command,
+        &recent_transcript,
+        streaming,
+        ack_cancel.clone(),
+    )
+    .await;
+
+    // Turn finished — stop the ack from firing late.
+    ack_cancel.notify_one();
+    ack_task.abort();
+
+    match reply {
+        Ok(text) if !text.trim().is_empty() => {
+            tracing::info!(
+                correlation_id = ?correlation_id,
+                reply_chars = text.chars().count(),
+                streaming,
+                "{LOG_PREFIX} orchestrator replied"
+            );
+            // In streaming mode the reply was already spoken sentence-by-
+            // sentence during the turn; only the buffered path emits here.
+            if !streaming {
+                if let Err(e) = emit_bot_speak(&text, correlation_id.as_deref()).await {
+                    tracing::warn!("{LOG_PREFIX} bot:speak emit failed: {e}");
+                }
+            }
+            post_exchange_to_thread(correlation_id.as_deref(), &speaker, command, &text).await;
+        }
+        Ok(_) => {
+            tracing::info!("{LOG_PREFIX} orchestrator returned empty reply — staying silent");
+        }
+        Err(e) => {
+            tracing::warn!("{LOG_PREFIX} in-call turn failed: {e}");
+            if let Err(e2) = emit_bot_speak(FAILURE_PHRASE, correlation_id.as_deref()).await {
+                tracing::debug!("{LOG_PREFIX} failure phrase emit failed: {e2}");
+            }
+            // The failure phrase promises a note in the thread — keep it.
+            post_exchange_to_thread(
+                correlation_id.as_deref(),
+                &speaker,
+                command,
+                &format!("(request failed: {e})"),
+            )
+            .await;
+        }
+    }
+}
+
+/// Route a spoken yes/no to a parked in-call approval. Returns `true`
+/// when the command was consumed as an approval decision (the caller
+/// must not dispatch it as a fresh turn).
+async fn try_voice_approval_decision(correlation_id: Option<&str>, command: &str) -> bool {
+    let Some(gate) = ApprovalGate::try_global() else {
+        return false;
+    };
+    let key = cache_key(correlation_id);
+    let Some(request_id) = gate.pending_for_meeting(&key) else {
+        return false;
+    };
+    let Some(decision) = parse_voice_approval(command) else {
+        tracing::info!(
+            request_id = %request_id,
+            "{LOG_PREFIX} approval parked but command is not a yes/no — treating as new command"
+        );
+        return false;
+    };
+
+    match gate.decide(&request_id, decision) {
+        Ok(Some(row)) => {
+            tracing::info!(
+                request_id = %request_id,
+                tool = %row.tool_name,
+                decision = decision.as_str(),
+                "{LOG_PREFIX} voice decision routed to parked approval"
+            );
+            let confirmation = if decision.is_approve() {
+                "Okay, going ahead."
+            } else {
+                "Okay, I won't do that."
+            };
+            if let Err(e) = emit_bot_speak(confirmation, correlation_id).await {
+                tracing::debug!("{LOG_PREFIX} confirmation emit failed: {e}");
+            }
+            true
+        }
+        Ok(None) => {
+            // Row already decided or expired between the lookup and now.
+            tracing::info!(
+                request_id = %request_id,
+                "{LOG_PREFIX} voice decision raced an already-decided approval"
+            );
+            if let Err(e) = emit_bot_speak("That request already expired.", correlation_id).await {
+                tracing::debug!("{LOG_PREFIX} expired-notice emit failed: {e}");
+            }
+            true
+        }
+        Err(e) => {
+            tracing::warn!("{LOG_PREFIX} voice decision failed: {e}");
+            true
+        }
+    }
+}
+
+/// Voice-tolerant approval parsing: the strict web-chat set first, then
+/// spoken synonyms. Trailing punctuation is stripped because ASR often
+/// appends it ("Approve." / "go ahead!").
+fn parse_voice_approval(command: &str) -> Option<ApprovalDecision> {
+    let norm = command
+        .trim()
+        .trim_end_matches(['.', '!', '?', ','])
+        .trim()
+        .to_ascii_lowercase();
+    if let Some(d) = parse_approval_reply(&norm) {
+        return Some(d);
+    }
+    match norm.as_str() {
+        "go ahead" | "go for it" | "do it" | "please do" | "sure" | "confirm" | "confirmed"
+        | "yes please" | "sounds good" => Some(ApprovalDecision::ApproveOnce),
+        "cancel" | "stop" | "don't" | "do not" | "don't do it" | "never mind" | "nevermind"
+        | "no thanks" => Some(ApprovalDecision::Deny),
+        _ => None,
+    }
+}
+
+/// Speak the approval prompt into the call. Called from the meeting bus
+/// when the gate publishes `InCallApprovalRequested`.
+pub(super) async fn speak_approval_prompt(action_summary: &str, correlation_id: Option<&str>) {
+    let prompt = format!(
+        "I'd like to {action_summary}. Say — Hey Tiny, approve — to confirm, \
+         or — Hey Tiny, deny — to cancel."
+    );
+    if let Err(e) = emit_bot_speak(&prompt, correlation_id).await {
+        tracing::warn!("{LOG_PREFIX} approval prompt emit failed: {e}");
+    }
+}
+
+/// Run one orchestrator turn for the meeting, with timeout. Returns the
+/// speech-sanitized reply text.
+async fn run_orchestrator_turn(
+    correlation_id: Option<&str>,
+    speaker: &str,
+    command: &str,
+    recent_transcript: &[BackendMeetTurn],
+    streaming: bool,
+    ack_cancel: Arc<Notify>,
+) -> Result<String, String> {
+    let agent_lock = get_or_build_agent(correlation_id).await?;
+    let mut agent = agent_lock.lock().await;
+
+    let user_message = build_turn_message(speaker, command, recent_transcript);
+
+    let now_ms = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0);
+    let key = cache_key(correlation_id);
+    // Per-turn transcript filename roll — same rationale as meet_agent:
+    // a kill mid-tool-call must not poison the next process's resume.
+    agent.set_agent_definition_name(format!("orchestrator_incall_{key}_{now_ms}"));
+
+    // Resolve the meeting thread up front so a parked approval's card
+    // lands in the same thread as the exchange trail (dual-channel:
+    // thread card + spoken prompt, issue #3513).
+    let approval_thread_id = get_or_create_meeting_thread(correlation_id, &key)
+        .await
+        .ok();
+
+    // Streaming: attach a progress sink so the reply is spoken sentence-by-
+    // sentence as it generates. The consumer reads deltas concurrently with
+    // the run; dropping the sink (set_on_progress(None)) after the run ends
+    // closes the channel so the consumer flushes its tail and exits.
+    let consumer = if streaming {
+        let (tx, rx) = mpsc::channel::<AgentProgress>(64);
+        agent.set_on_progress(Some(tx));
+        let cid_owned = correlation_id.map(String::from);
+        Some(tokio::spawn(stream_sentences(rx, cid_owned, ack_cancel)))
+    } else {
+        None
+    };
+
+    // Live-call speech is externally-sourced channel input: the approval
+    // gate routes external_effect tools through the parking path. The two
+    // task-locals make the park dual-channel: APPROVAL_CHAT_CONTEXT routes
+    // the thread card + typed yes/no; APPROVAL_IN_CALL_CONTEXT routes the
+    // spoken prompt + voice yes/no and clamps the TTL to two minutes.
+    let fut = crate::openhuman::agent::turn_origin::with_origin(
+        crate::openhuman::agent::turn_origin::AgentTurnOrigin::ExternalChannel {
+            channel: "meet".to_string(),
+            sender: None,
+            reply_target: key.clone(),
+            message_id: format!("incall-{key}-{now_ms}"),
+        },
+        agent.run_single(&user_message),
+    );
+    let fut = APPROVAL_IN_CALL_CONTEXT.scope(
+        InCallApprovalContext {
+            meeting_key: key.clone(),
+            correlation_id: correlation_id.map(String::from),
+        },
+        fut,
+    );
+
+    let timeout = Duration::from_secs(IN_CALL_TURN_TIMEOUT_SECS);
+    let run = match approval_thread_id {
+        Some(thread_id) => {
+            // client_id "system" follows the task-dispatcher precedent: the
+            // UI keys approval cards by thread_id for system-driven turns.
+            let fut = APPROVAL_CHAT_CONTEXT.scope(
+                ApprovalChatContext {
+                    thread_id,
+                    client_id: "system".to_string(),
+                },
+                fut,
+            );
+            tokio::time::timeout(timeout, fut).await
+        }
+        None => tokio::time::timeout(timeout, fut).await,
+    };
+
+    // Detach the progress sink and let the consumer drain the remaining
+    // deltas + flush its tail sentence before we return.
+    if streaming {
+        agent.set_on_progress(None);
+    }
+    if let Some(handle) = consumer {
+        let _ = handle.await;
+    }
+
+    let reply = match run {
+        Ok(Ok(text)) => text,
+        Ok(Err(e)) => return Err(format!("orchestrator run_single failed: {e}")),
+        Err(_elapsed) => {
+            return Err(format!(
+                "orchestrator turn timed out after {IN_CALL_TURN_TIMEOUT_SECS}s"
+            ));
+        }
+    };
+
+    Ok(strip_for_speech(&reply))
+}
+
+/// Minimum characters before a complete sentence is flushed for speech.
+/// Avoids choppy single-word emits and speaking abbreviations ("Mr.") as
+/// their own sentence; short leading clauses are merged into the next one.
+const MIN_SPEAK_CHARS: usize = 12;
+
+/// Consume the agent's progress stream, speaking the visible answer one
+/// sentence at a time as it arrives. `ThinkingDelta` (reasoning) is dropped
+/// so the chain-of-thought is never spoken. On the first spoken chunk the
+/// speculative ack is cancelled.
+async fn stream_sentences(
+    mut rx: mpsc::Receiver<AgentProgress>,
+    correlation_id: Option<String>,
+    ack_cancel: Arc<Notify>,
+) {
+    let mut buf = String::new();
+    let mut seq: u32 = 0;
+    let mut spoke = false;
+    while let Some(ev) = rx.recv().await {
+        if let AgentProgress::TextDelta { delta, .. } = ev {
+            buf.push_str(&delta);
+            for sentence in drain_sentences(&mut buf) {
+                speak_stream_chunk(
+                    &sentence,
+                    correlation_id.as_deref(),
+                    &mut seq,
+                    &ack_cancel,
+                    &mut spoke,
+                )
+                .await;
+            }
+        }
+        // ThinkingDelta + all other progress events: ignored. Only visible
+        // answer text is spoken.
+    }
+    // Flush the trailing partial sentence (no terminator) as the tail.
+    let tail = strip_for_speech(buf.trim());
+    if !tail.is_empty() {
+        speak_stream_chunk(
+            &tail,
+            correlation_id.as_deref(),
+            &mut seq,
+            &ack_cancel,
+            &mut spoke,
+        )
+        .await;
+    }
+}
+
+async fn speak_stream_chunk(
+    text: &str,
+    correlation_id: Option<&str>,
+    seq: &mut u32,
+    ack_cancel: &Arc<Notify>,
+    spoke: &mut bool,
+) {
+    if text.is_empty() {
+        return;
+    }
+    if !*spoke {
+        *spoke = true;
+        ack_cancel.notify_one(); // first real audio — no need for the filler ack
+    }
+    if let Err(e) = emit_bot_speak_inner(text, correlation_id, Some(*seq)).await {
+        tracing::debug!("{LOG_PREFIX} streamed chunk emit failed: {e}");
+    }
+    *seq += 1;
+}
+
+/// Pull complete, speech-sanitized sentences from `buf`, leaving the trailing
+/// partial sentence behind for the next delta. Short leading clauses are
+/// merged into the next sentence (`MIN_SPEAK_CHARS`). Everything is held back
+/// while an unclosed `<think>` tag is present so untagged reasoning from
+/// models that inline it isn't spoken.
+fn drain_sentences(buf: &mut String) -> Vec<String> {
+    // Drop any COMPLETE reasoning blocks first, so their internal sentence
+    // punctuation is never drained and spoken.
+    loop {
+        let (Some(open), Some(close)) = (buf.find("<think>"), buf.find("</think>")) else {
+            break;
+        };
+        if close < open {
+            break; // malformed ordering — leave it for strip_for_speech
+        }
+        buf.replace_range(open..close + "</think>".len(), "");
+    }
+    // A reasoning block is still open (no close yet) — hold everything back
+    // until it closes rather than risk speaking the chain-of-thought.
+    if buf.contains("<think>") {
+        return Vec::new();
+    }
+    let mut out = Vec::new();
+    loop {
+        // Find a flush point: the earliest sentence end whose prefix is long
+        // enough, merging short leading clauses into the following sentence.
+        let mut flush_at = None;
+        let mut search_from = 0;
+        while let Some(rel) = next_sentence_end(&buf[search_from..]) {
+            let abs = search_from + rel;
+            if buf[..abs].trim().chars().count() >= MIN_SPEAK_CHARS {
+                flush_at = Some(abs);
+                break;
+            }
+            search_from = abs; // too short — merge with the next sentence
+        }
+        let Some(end) = flush_at else { break };
+        let sentence: String = buf.drain(..end).collect();
+        let cleaned = strip_for_speech(sentence.trim());
+        if !cleaned.is_empty() {
+            out.push(cleaned);
+        }
+    }
+    out
+}
+
+/// Byte index just past the first sentence terminator (`.`/`!`/`?` followed
+/// by whitespace, or a newline). Returns `None` when no boundary is present
+/// yet — a terminator at the very end of the buffer waits for the next delta
+/// (so "3.14" or a mid-word "." isn't treated as a boundary).
+fn next_sentence_end(s: &str) -> Option<usize> {
+    let chars: Vec<(usize, char)> = s.char_indices().collect();
+    for (i, &(idx, ch)) in chars.iter().enumerate() {
+        if ch == '\n' {
+            return Some(idx + ch.len_utf8());
+        }
+        if ch == '.' || ch == '!' || ch == '?' {
+            match chars.get(i + 1) {
+                Some((_, next)) if next.is_whitespace() => return Some(idx + ch.len_utf8()),
+                Some(_) => {}        // e.g. "3.14" — not a boundary
+                None => return None, // terminator at end — wait for more
+            }
+        }
+    }
+    None
+}
+
+/// Compose the per-turn user message: live clock + meeting context +
+/// the command itself. The voice directive lives in the system prompt
+/// suffix (baked at agent build); only per-turn facts go here.
+fn build_turn_message(
+    speaker: &str,
+    command: &str,
+    recent_transcript: &[BackendMeetTurn],
+) -> String {
+    let now_local = chrono::Local::now();
+    let mut msg = format!(
+        "[RIGHT-NOW CONTEXT — current local time: {} ({}), tz {}. \
+         Use this directly for any time/date question; do not call a tool.]\n\n",
+        now_local.format("%Y-%m-%d %H:%M:%S"),
+        now_local.format("%A"),
+        now_local.format("%:z"),
+    );
+
+    let tail_start = recent_transcript
+        .len()
+        .saturating_sub(RECENT_TRANSCRIPT_WINDOW);
+    let tail = &recent_transcript[tail_start..];
+    if !tail.is_empty() {
+        msg.push_str("[RECENT MEETING TRANSCRIPT — context only, do not reply to it]\n");
+        for turn in tail {
+            let content = turn.content.trim();
+            if content.is_empty() {
+                continue;
+            }
+            msg.push_str(content);
+            msg.push('\n');
+        }
+        msg.push('\n');
+    }
+
+    msg.push_str(&format!(
+        "[IN-CALL REQUEST from participant \"{speaker}\"]\n{command}"
+    ));
+    msg
+}
+
+/// Get the cached per-meeting orchestrator, or build it on first call.
+async fn get_or_build_agent(
+    correlation_id: Option<&str>,
+) -> Result<Arc<TokioMutex<Agent>>, String> {
+    let key = cache_key(correlation_id);
+    {
+        let cache = agent_cache().lock().await;
+        if let Some(existing) = cache.get(&key) {
+            return Ok(existing.clone());
+        }
+    }
+
+    let config = crate::openhuman::config::ops::load_config_with_timeout().await?;
+    let mut agent = Agent::from_config_for_agent_with_profile(
+        &config,
+        "orchestrator",
+        None,
+        Some(IN_CALL_VOICE_DIRECTIVE.to_string()),
+        // No thread-selected agent profile applies to an in-call orchestrator.
+        None,
+    )
+    .map_err(|e| format!("{LOG_PREFIX} orchestrator build failed: {e}"))?;
+
+    agent.set_event_context(format!("incall_{key}"), "agent_meetings");
+    agent.set_agent_definition_name(format!("orchestrator_incall_{key}"));
+
+    tracing::info!("{LOG_PREFIX} orchestrator built + cached for meeting={key}");
+
+    let arc = Arc::new(TokioMutex::new(agent));
+    agent_cache().lock().await.insert(key, arc.clone());
+    Ok(arc)
+}
+
+/// Record the in-call exchange (command + spoken reply) in the meeting's
+/// thread so the user has a visual trail after the call. Best-effort:
+/// failures are logged, never propagated — the spoken reply already
+/// happened.
+async fn post_exchange_to_thread(
+    correlation_id: Option<&str>,
+    speaker: &str,
+    command: &str,
+    reply: &str,
+) {
+    use crate::openhuman::memory::{AppendConversationMessageRequest, ConversationMessageRecord};
+    use crate::openhuman::threads::ops;
+
+    let key = cache_key(correlation_id);
+    let thread_id = match get_or_create_meeting_thread(correlation_id, &key).await {
+        Ok(id) => id,
+        Err(e) => {
+            tracing::warn!("{LOG_PREFIX} thread lookup/create failed: {e}");
+            return;
+        }
+    };
+
+    let body = format!("🎙️ **{speaker}** (in-call): {command}\n\n**Tiny**: {reply}");
+    let msg = ConversationMessageRecord {
+        id: uuid::Uuid::new_v4().to_string(),
+        content: body,
+        message_type: "text".to_string(),
+        extra_metadata: serde_json::Value::Null,
+        sender: "system".to_string(),
+        created_at: chrono::Utc::now().to_rfc3339(),
+    };
+    let append_req = AppendConversationMessageRequest {
+        thread_id: thread_id.clone(),
+        message: msg,
+    };
+    if let Err(e) = ops::message_append(append_req).await {
+        tracing::warn!(
+            thread_id = %thread_id,
+            "{LOG_PREFIX} failed to append in-call exchange: {e}"
+        );
+    } else {
+        tracing::info!(
+            thread_id = %thread_id,
+            "{LOG_PREFIX} in-call exchange posted to meeting thread"
+        );
+    }
+}
+
+/// Resolve the meeting's thread id: in-memory cache → session store →
+/// create a fresh "Meetings"-labelled thread (and remember it for both).
+async fn get_or_create_meeting_thread(
+    correlation_id: Option<&str>,
+    key: &str,
+) -> Result<String, String> {
+    use crate::openhuman::memory::CreateConversationThreadRequest;
+    use crate::openhuman::threads::ops;
+
+    if let Some(existing) = thread_cache().lock().await.get(key) {
+        return Ok(existing.clone());
+    }
+
+    let config = crate::openhuman::config::ops::load_config_with_timeout().await?;
+
+    // A calendar- or API-initiated meeting has a MeetingSession row that
+    // may already carry the thread created by the transcript flow.
+    if let Some(cid) = correlation_id {
+        if let Ok(Some(session)) = super::store::get_session(&config, cid) {
+            if let Some(tid) = session.thread_id.filter(|t| !t.is_empty()) {
+                thread_cache()
+                    .lock()
+                    .await
+                    .insert(key.to_string(), tid.clone());
+                return Ok(tid);
+            }
+        }
+    }
+
+    let create_req = CreateConversationThreadRequest {
+        labels: Some(vec!["Meetings".to_string()]),
+        personality_id: None,
+    };
+    let outcome = ops::thread_create_new(create_req)
+        .await
+        .map_err(|e| format!("thread creation failed: {e}"))?;
+    let thread_id = outcome
+        .value
+        .data
+        .as_ref()
+        .ok_or_else(|| "thread creation returned no data".to_string())?
+        .id
+        .clone();
+
+    // Link the thread back to the session row so the post-call transcript
+    // flow appends to the same thread instead of opening a second one.
+    if let Some(cid) = correlation_id {
+        let now_ms = chrono::Utc::now().timestamp_millis().max(0) as u64;
+        if let Err(e) = super::store::set_session_thread_id(&config, cid, &thread_id, now_ms) {
+            tracing::debug!("{LOG_PREFIX} set_session_thread_id failed (no session row?): {e}");
+        }
+    }
+
+    thread_cache()
+        .lock()
+        .await
+        .insert(key.to_string(), thread_id.clone());
+    tracing::info!(
+        thread_id = %thread_id,
+        meeting = %key,
+        "{LOG_PREFIX} created meeting thread for in-call exchanges"
+    );
+    Ok(thread_id)
+}
+
+/// Emit `bot:speak` to the backend over the persistent Socket.IO link.
+/// The backend's SpeakOrchestrator handles streaming TTS + the audio
+/// politeness gate from there.
+async fn emit_bot_speak(text: &str, correlation_id: Option<&str>) -> Result<(), String> {
+    emit_bot_speak_inner(text, correlation_id, None).await
+}
+
+/// As [`emit_bot_speak`], plus an optional `seq` so the backend can order
+/// the per-sentence chunks of a streamed reply (additive; older backends
+/// ignore it).
+async fn emit_bot_speak_inner(
+    text: &str,
+    correlation_id: Option<&str>,
+    seq: Option<u32>,
+) -> Result<(), String> {
+    let mgr = global_socket_manager()
+        .ok_or_else(|| format!("{LOG_PREFIX} socket manager not initialized"))?;
+    if !mgr.is_connected() {
+        return Err(format!("{LOG_PREFIX} socket not connected to backend"));
+    }
+
+    let mut payload = json!({ "text": text });
+    if let Some(map) = payload.as_object_mut() {
+        if let Some(cid) = correlation_id {
+            map.insert("correlationId".to_string(), json!(cid));
+        }
+        if let Some(s) = seq {
+            map.insert("seq".to_string(), json!(s));
+        }
+    }
+
+    tracing::info!(
+        text_len = text.len(),
+        correlation_id = ?correlation_id,
+        "{LOG_PREFIX} emitting bot:speak"
+    );
+    mgr.emit("bot:speak", payload)
+        .await
+        .map_err(|e| format!("{LOG_PREFIX} emit failed: {e}"))?;
+
+    // Observability: mirror the emit on the event bus so dashboards and
+    // the tracing subscriber see when the bot speaks into a call.
+    crate::core::event_bus::publish_global(crate::core::event_bus::DomainEvent::BackendMeetSpeak {
+        text: text.to_string(),
+        correlation_id: correlation_id.map(String::from),
+    });
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn turn(role: &str, content: &str) -> BackendMeetTurn {
+        BackendMeetTurn {
+            role: role.to_string(),
+            content: content.to_string(),
+        }
+    }
+
+    #[test]
+    fn next_sentence_end_finds_terminator_before_whitespace() {
+        assert_eq!(next_sentence_end("Hello there. More"), Some(12));
+        assert_eq!(next_sentence_end("Done!\nNext"), Some(5));
+        assert_eq!(next_sentence_end("Question? Yes"), Some(9));
+    }
+
+    #[test]
+    fn next_sentence_end_waits_on_trailing_or_mid_word_dot() {
+        assert_eq!(next_sentence_end("It is pi 3.14"), None); // mid-number, no boundary
+        assert_eq!(next_sentence_end("No boundary yet"), None);
+        assert_eq!(next_sentence_end("Trailing terminator."), None); // wait for next delta
+    }
+
+    #[test]
+    fn drain_sentences_flushes_complete_sentences_and_keeps_the_tail() {
+        let mut buf = String::from("The meeting is at three. We can start the");
+        let out = drain_sentences(&mut buf);
+        assert_eq!(out, vec!["The meeting is at three.".to_string()]);
+        assert_eq!(buf, " We can start the"); // partial tail retained
+    }
+
+    #[test]
+    fn drain_sentences_merges_a_short_leading_clause_into_the_next() {
+        // "Yes." alone is under MIN_SPEAK_CHARS, so it merges forward.
+        let mut buf = String::from("Yes. The follow-up is booked for tomorrow. ");
+        let out = drain_sentences(&mut buf);
+        assert_eq!(
+            out,
+            vec!["Yes. The follow-up is booked for tomorrow.".to_string()]
+        );
+    }
+
+    #[test]
+    fn drain_sentences_holds_back_unclosed_reasoning() {
+        let mut buf = String::from("<think>the user wants the time. let me check.");
+        assert!(drain_sentences(&mut buf).is_empty());
+        // Once the tag closes, normal flushing resumes.
+        buf.push_str("</think> It is three o'clock now. ");
+        let out = drain_sentences(&mut buf);
+        assert_eq!(out, vec!["It is three o'clock now.".to_string()]);
+    }
+
+    #[test]
+    fn cache_key_falls_back_to_default() {
+        assert_eq!(cache_key(None), "default");
+        assert_eq!(cache_key(Some("")), "default");
+        assert_eq!(cache_key(Some("   ")), "default");
+        assert_eq!(cache_key(Some("meet-123")), "meet-123");
+    }
+
+    #[test]
+    fn turn_message_includes_speaker_and_command() {
+        let msg = build_turn_message("Alice", "schedule a follow-up tomorrow", &[]);
+        assert!(msg.contains("participant \"Alice\""));
+        assert!(msg.contains("schedule a follow-up tomorrow"));
+        assert!(msg.contains("RIGHT-NOW CONTEXT"));
+        // No transcript section when there are no turns.
+        assert!(!msg.contains("RECENT MEETING TRANSCRIPT"));
+    }
+
+    #[test]
+    fn turn_message_includes_transcript_tail() {
+        let transcript = vec![
+            turn("user", "[00:01] [Alice] welcome everyone"),
+            turn("user", "[00:05] [Bob] thanks for joining"),
+        ];
+        let msg = build_turn_message("Alice", "what did Bob say", &transcript);
+        assert!(msg.contains("RECENT MEETING TRANSCRIPT"));
+        assert!(msg.contains("welcome everyone"));
+        assert!(msg.contains("thanks for joining"));
+    }
+
+    #[test]
+    fn turn_message_caps_transcript_window() {
+        let transcript: Vec<BackendMeetTurn> = (0..50)
+            .map(|i| turn("user", &format!("[00:{i:02}] [Alice] line number {i}")))
+            .collect();
+        let msg = build_turn_message("Alice", "summarize", &transcript);
+        // Only the last RECENT_TRANSCRIPT_WINDOW turns are included.
+        assert!(!msg.contains("line number 29"));
+        assert!(msg.contains("line number 30"));
+        assert!(msg.contains("line number 49"));
+    }
+
+    #[test]
+    fn turn_message_skips_empty_transcript_lines() {
+        let transcript = vec![turn("user", "   "), turn("user", "[00:01] [Alice] hello")];
+        let msg = build_turn_message("Alice", "hi", &transcript);
+        assert!(msg.contains("[Alice] hello"));
+    }
+
+    #[test]
+    fn voice_approval_parses_strict_set_and_spoken_synonyms() {
+        for approve in [
+            "approve",
+            "Approve.",
+            "yes",
+            "YES",
+            "okay",
+            "go ahead",
+            "go ahead!",
+            "do it",
+            "sounds good",
+            "confirmed",
+        ] {
+            assert_eq!(
+                parse_voice_approval(approve),
+                Some(ApprovalDecision::ApproveOnce),
+                "{approve}"
+            );
+        }
+        for deny in ["no", "deny", "cancel", "never mind", "don't", "stop"] {
+            assert_eq!(
+                parse_voice_approval(deny),
+                Some(ApprovalDecision::Deny),
+                "{deny}"
+            );
+        }
+        for other in [
+            "what time is it",
+            "schedule a meeting",
+            "approve the budget plan",
+        ] {
+            assert_eq!(parse_voice_approval(other), None, "{other}");
+        }
+    }
+
+    #[tokio::test]
+    async fn voice_decision_is_noop_without_global_gate_or_parked_approval() {
+        // No global gate in unit tests → must return false (treat as a
+        // normal command), never panic.
+        assert!(!try_voice_approval_decision(Some("meet-x"), "approve").await);
+    }
+
+    #[tokio::test]
+    async fn clear_meeting_agent_is_noop_for_unknown_meeting() {
+        // Must not panic or deadlock when nothing is cached.
+        clear_meeting_agent(Some("never-seen")).await;
+        clear_meeting_agent(None).await;
+    }
+
+    #[tokio::test]
+    async fn empty_command_returns_without_touching_config_or_socket() {
+        // Empty command short-circuits before the config gate and the
+        // socket — must complete instantly without panicking even in a
+        // test environment with no socket manager.
+        handle_in_call_request(
+            Some("meet-x".into()),
+            "Alice".into(),
+            "   ".into(),
+            vec![],
+            0,
+        )
+        .await;
+    }
+
+    #[tokio::test]
+    async fn flag_off_drops_request_before_any_dispatch() {
+        // enable_in_call_agency defaults to false; the request must be
+        // dropped before the orchestrator or socket are touched. The
+        // test env has no socket manager, so reaching the emit path
+        // would error loudly — completing without panic proves the
+        // early return.
+        handle_in_call_request(
+            Some("meet-flag-off".into()),
+            "Alice".into(),
+            "what time is it".into(),
+            vec![],
+            0,
+        )
+        .await;
+        // No agent should have been built for the meeting.
+        assert!(
+            !agent_cache().lock().await.contains_key("meet-flag-off"),
+            "agent must not be built when the flag is off"
+        );
+    }
+
+    #[tokio::test]
+    async fn mark_and_clear_active_meeting_toggles_membership() {
+        // The per-meeting active set is what lets a listen_only=false join
+        // dispatch in-call commands even with the global flag off.
+        assert!(!is_meeting_active(Some("meet-active-1")).await);
+        mark_meeting_active(Some("meet-active-1")).await;
+        assert!(is_meeting_active(Some("meet-active-1")).await);
+        // mark is idempotent.
+        mark_meeting_active(Some("meet-active-1")).await;
+        assert!(is_meeting_active(Some("meet-active-1")).await);
+        // clear_meeting_agent must also drop the active marker so a later
+        // meeting reusing the same correlation id starts passive.
+        clear_meeting_agent(Some("meet-active-1")).await;
+        assert!(!is_meeting_active(Some("meet-active-1")).await);
+    }
+}
diff --git a/src/openhuman/agent_meetings/mod.rs b/src/openhuman/agent_meetings/mod.rs
index da73772de..99e2f7c6c 100644
--- a/src/openhuman/agent_meetings/mod.rs
+++ b/src/openhuman/agent_meetings/mod.rs
@@ -12,9 +12,11 @@
 //! - [`ops`]     — RPC handlers that emit Socket.IO events
 //! - [`schemas`] — controller schema + registered handler wrappers
 //! - [`store`]   — SQLite persistence for meeting sessions
+//! - [`in_call`] — Phase 2 in-call agency: wake-phrase command → orchestrator → `bot:speak`
 
 pub mod bus;
 pub mod calendar;
+pub mod in_call;
 pub mod ops;
 pub mod schemas;
 pub mod store;
diff --git a/src/openhuman/agent_meetings/ops.rs b/src/openhuman/agent_meetings/ops.rs
index e982f71df..8b08c03d8 100644
--- a/src/openhuman/agent_meetings/ops.rs
+++ b/src/openhuman/agent_meetings/ops.rs
@@ -15,7 +15,7 @@ use crate::rpc::RpcOutcome;
 
 use super::types::{
     BackendMeetHarnessResponseRequest, BackendMeetJoinRequest, BackendMeetJoinResponse,
-    BackendMeetLeaveRequest, BackendMeetSpeakRequest,
+    BackendMeetLeaveRequest, BackendMeetSpeakRequest, MeetingSessionStatus,
 };
 
 const ALLOWED_HOSTS: &[(&str, &str)] = &[
@@ -48,7 +48,7 @@ fn transcript_turns_to_chat_batch(
             continue;
         }
         let author = if turn.role.eq_ignore_ascii_case("assistant") {
-            "OpenHuman"
+            "Tiny"
         } else {
             "Meeting participant"
         };
@@ -293,7 +293,7 @@ pub async fn handle_join(params: Map<String, Value>) -> Result<Value, String> {
 
     let display_name = match &req.display_name {
         Some(name) => validate_display_name(name).map_err(|e| format!("[agent_meetings] {e}"))?,
-        None => "OpenHuman".to_string(),
+        None => "Tiny".to_string(),
     };
 
     let inferred = infer_platform(&normalized_url);
@@ -327,6 +327,14 @@ pub async fn handle_join(params: Map<String, Value>) -> Result<Value, String> {
         .await
         .map_err(|e| format!("[agent_meetings] emit failed: {e}"))?;
 
+    // Active mode (listen_only = false, the modal's "respond when addressed"
+    // toggle) enables in-call agency for just this meeting, so the toggle
+    // "just works" without flipping the global config. Passive joins leave
+    // the meeting unmarked (default: listen-only / transcribe-only).
+    if req.listen_only == Some(false) {
+        super::in_call::mark_meeting_active(req.correlation_id.as_deref()).await;
+    }
+
     let response = BackendMeetJoinResponse {
         ok: true,
         meet_url: normalized_url.to_string(),
@@ -429,6 +437,119 @@ pub async fn handle_speak(params: Map<String, Value>) -> Result<Value, String> {
     outcome.into_cli_compatible_json()
 }
 
+/// Handle `openhuman.agent_meetings_notification_action` — a click on one
+/// of the calendar auto-join notification buttons (issue #3507).
+///
+/// Actions:
+/// - `join_listen`  → join muted (transcript-only).
+/// - `join_active`  → join in reply mode with the "Hey Tiny" wake phrase.
+/// - `skip`         → mark the meeting session Ended; no join.
+/// - `always_join`  → persist `auto_join_policy = Always`, then join with
+///   the configured `listen_only_default`.
+///
+/// `payload` carries `{ meetingId, meetUrl, title }` from the notification
+/// plus an optional user-edited `displayName`.
+pub async fn handle_notification_action(params: Map<String, Value>) -> Result<Value, String> {
+    let action_id = params
+        .get("action_id")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    if action_id.is_empty() {
+        return Err("[agent_meetings] action_id is required".to_string());
+    }
+    let payload = params.get("payload").cloned().unwrap_or(Value::Null);
+    let meeting_id = payload
+        .get("meetingId")
+        .and_then(|v| v.as_str())
+        .map(String::from);
+    let meet_url = payload
+        .get("meetUrl")
+        .and_then(|v| v.as_str())
+        .map(String::from);
+    let display_name = payload
+        .get("displayName")
+        .and_then(|v| v.as_str())
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .map(String::from);
+
+    tracing::info!(
+        action_id = %action_id,
+        meeting_id = ?meeting_id,
+        has_meet_url = meet_url.is_some(),
+        "[agent_meetings] notification action received"
+    );
+
+    match action_id.as_str() {
+        "skip" => {
+            if let Some(id) = &meeting_id {
+                match crate::openhuman::config::ops::load_config_with_timeout().await {
+                    Ok(config) => {
+                        let now_ms = chrono::Utc::now().timestamp_millis().max(0) as u64;
+                        if let Err(e) = super::store::update_session_status(
+                            &config,
+                            id,
+                            MeetingSessionStatus::Ended,
+                            now_ms,
+                        ) {
+                            tracing::debug!("[agent_meetings] skip: session update failed: {e}");
+                        }
+                    }
+                    Err(e) => {
+                        tracing::debug!("[agent_meetings] skip: config load failed: {e}");
+                    }
+                }
+            }
+            let outcome = RpcOutcome::new(json!({ "ok": true }), vec![]);
+            outcome.into_cli_compatible_json()
+        }
+        "join_listen" | "join_active" | "always_join" => {
+            let meet_url = meet_url
+                .ok_or_else(|| "[agent_meetings] payload.meetUrl is required".to_string())?;
+            let config = crate::openhuman::config::ops::load_config_with_timeout().await?;
+
+            if action_id == "always_join" {
+                let mut cfg = config.clone();
+                cfg.meet.auto_join_policy =
+                    crate::openhuman::config::schema::AutoJoinPolicy::Always;
+                if let Err(e) = cfg.save().await {
+                    // Join anyway — the policy flip failing must not block
+                    // the join the user just asked for.
+                    tracing::warn!("[agent_meetings] persisting always-join policy failed: {e}");
+                }
+            }
+
+            let listen_only = match action_id.as_str() {
+                "join_listen" => true,
+                "join_active" => false,
+                _ => config.meet.listen_only_default,
+            };
+
+            let mut join = Map::new();
+            join.insert("meet_url".to_string(), json!(meet_url));
+            join.insert(
+                "correlation_id".to_string(),
+                json!(meeting_id
+                    .clone()
+                    .unwrap_or_else(|| uuid::Uuid::new_v4().to_string())),
+            );
+            join.insert("listen_only".to_string(), json!(listen_only));
+            if let Some(name) = display_name {
+                join.insert("display_name".to_string(), json!(name));
+            }
+            if !listen_only {
+                // Reply mode: the participant addresses the bot as "Hey Tiny";
+                // the wake phrase is always required (no implicit address).
+                join.insert("wake_phrase".to_string(), json!("Hey Tiny"));
+            }
+
+            handle_join(join).await
+        }
+        other => Err(format!("[agent_meetings] unknown action_id: {other}")),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -460,6 +581,39 @@ mod tests {
         assert!(validate_meeting_url("https://example.com/meeting").is_err());
     }
 
+    #[tokio::test]
+    async fn notification_action_requires_action_id() {
+        let err = handle_notification_action(Map::new()).await.unwrap_err();
+        assert!(err.contains("action_id"));
+    }
+
+    #[tokio::test]
+    async fn notification_action_rejects_unknown_action() {
+        let mut params = Map::new();
+        params.insert("action_id".to_string(), json!("explode"));
+        let err = handle_notification_action(params).await.unwrap_err();
+        assert!(err.contains("unknown action_id"));
+    }
+
+    #[tokio::test]
+    async fn notification_action_join_requires_meet_url() {
+        let mut params = Map::new();
+        params.insert("action_id".to_string(), json!("join_listen"));
+        params.insert("payload".to_string(), json!({ "meetingId": "m-1" }));
+        let err = handle_notification_action(params).await.unwrap_err();
+        assert!(err.contains("meetUrl"));
+    }
+
+    #[tokio::test]
+    async fn notification_action_skip_without_meeting_id_is_ok() {
+        // No meetingId → nothing to update; must succeed without touching
+        // config or the session store.
+        let mut params = Map::new();
+        params.insert("action_id".to_string(), json!("skip"));
+        let value = handle_notification_action(params).await.unwrap();
+        assert_eq!(value.get("ok"), Some(&json!(true)));
+    }
+
     #[test]
     fn infers_platform_from_host() {
         let url = url::Url::parse("https://meet.google.com/abc-defg-hij").unwrap();
@@ -498,7 +652,7 @@ mod tests {
         assert_eq!(batch.platform, "backend_meet");
         assert_eq!(batch.messages.len(), 2);
         assert_eq!(batch.messages[0].author, "Meeting participant");
-        assert_eq!(batch.messages[1].author, "OpenHuman");
+        assert_eq!(batch.messages[1].author, "Tiny");
         assert!(batch.messages[0].text.contains("summarize"));
     }
 
diff --git a/src/openhuman/agent_meetings/schemas.rs b/src/openhuman/agent_meetings/schemas.rs
index ec51e2285..1ee4f891c 100644
--- a/src/openhuman/agent_meetings/schemas.rs
+++ b/src/openhuman/agent_meetings/schemas.rs
@@ -36,6 +36,11 @@ const DEFS: &[BackendMeetControllerDef] = &[
         schema: schema_speak,
         handler: handle_speak_wrap,
     },
+    BackendMeetControllerDef {
+        function: "notification_action",
+        schema: schema_notification_action,
+        handler: handle_notification_action_wrap,
+    },
 ];
 
 pub fn all_controller_schemas() -> Vec<ControllerSchema> {
@@ -238,6 +243,42 @@ fn handle_speak_wrap(params: Map<String, Value>) -> ControllerFuture {
     Box::pin(async move { super::ops::handle_speak(params).await })
 }
 
+fn schema_notification_action() -> ControllerSchema {
+    ControllerSchema {
+        namespace: "agent_meetings",
+        function: "notification_action",
+        description: "Handle a click on a calendar auto-join notification button. \
+                      Actions: join_listen (muted), join_active (reply mode with the \
+                      'Hey Tiny' wake phrase), skip (dismiss this meeting), always_join \
+                      (persist auto_join_policy=always, then join).",
+        inputs: vec![
+            FieldSchema {
+                name: "action_id",
+                ty: TypeSchema::String,
+                comment: "One of: join_listen, join_active, skip, always_join.",
+                required: true,
+            },
+            FieldSchema {
+                name: "payload",
+                ty: TypeSchema::Json,
+                comment: "The notification action payload: { meetingId, meetUrl, title } \
+                          plus an optional user-edited displayName for the bot.",
+                required: false,
+            },
+        ],
+        outputs: vec![FieldSchema {
+            name: "ok",
+            ty: TypeSchema::Bool,
+            comment: "True when the action was handled (join emitted or session updated).",
+            required: true,
+        }],
+    }
+}
+
+fn handle_notification_action_wrap(params: Map<String, Value>) -> ControllerFuture {
+    Box::pin(async move { super::ops::handle_notification_action(params).await })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -255,7 +296,13 @@ mod tests {
         assert_eq!(schema_fns, handler_fns);
         assert_eq!(
             schema_fns,
-            vec!["join", "leave", "harness_response", "speak"]
+            vec![
+                "join",
+                "leave",
+                "harness_response",
+                "speak",
+                "notification_action"
+            ]
         );
     }
 
diff --git a/src/openhuman/approval/gate.rs b/src/openhuman/approval/gate.rs
index a3657a3a9..56ef5c2b7 100644
--- a/src/openhuman/approval/gate.rs
+++ b/src/openhuman/approval/gate.rs
@@ -50,6 +50,11 @@ use super::types::{ApprovalDecision, ExecutionOutcome, GateOutcome, PendingAppro
 /// written into the persisted row.
 const DEFAULT_APPROVAL_TTL: Duration = Duration::from_secs(60 * 10);
 
+/// Shorter park window for approvals raised mid-call (issue #3513): a
+/// live meeting can't idle on a parked tool for the default ten
+/// minutes — if nobody approves within two, deny and move on.
+const IN_CALL_APPROVAL_TTL: Duration = Duration::from_secs(120);
+
 /// Per-turn chat context for routing a parked approval's yes/no reply back to
 /// the originating thread. The web channel scopes this task-local around the
 /// agent run (`channels::providers::web`); because the `run_turn` handler, the
@@ -67,6 +72,26 @@ tokio::task_local! {
     pub static APPROVAL_CHAT_CONTEXT: ApprovalChatContext;
 }
 
+/// In-call meeting context (issue #3513) — set by `agent_meetings::in_call`
+/// around the orchestrator turn for a live meeting. When present, a parked
+/// approval additionally:
+/// - publishes [`DomainEvent::InCallApprovalRequested`] so the meeting bus
+///   can speak the approval prompt into the call (`bot:speak`),
+/// - registers a meeting → request mapping so a spoken
+///   "Hey Tiny, approve" can be routed to [`ApprovalGate::decide`], and
+/// - clamps the park window to [`IN_CALL_APPROVAL_TTL`].
+#[derive(Clone, Debug)]
+pub struct InCallApprovalContext {
+    /// Stable per-meeting key (the correlation id, or `"default"`).
+    pub meeting_key: String,
+    /// Original correlation id, echoed on spoken prompts.
+    pub correlation_id: Option<String>,
+}
+
+tokio::task_local! {
+    pub static APPROVAL_IN_CALL_CONTEXT: InCallApprovalContext;
+}
+
 /// Parse a chat reply to a parked approval into a binary decision (v1). Only an
 /// explicit yes/no answer maps to a decision; anything else returns `None` — the
 /// web channel treats `None` as "not an answer", cancels the parked turn, and
@@ -138,6 +163,11 @@ pub struct ApprovalGate {
     /// In-memory only (session-scoped — a parked approval doesn't survive a
     /// restart, and the oneshot waiter is in-memory anyway).
     thread_to_request: Mutex<HashMap<String, String>>,
+    /// meeting_key → request_id for the approval currently parked on a live
+    /// meeting, so a spoken "Hey Tiny, approve" can be routed to a decision
+    /// (issue #3513). Same in-memory/session-scoped semantics as
+    /// `thread_to_request`.
+    meeting_to_request: Mutex<HashMap<String, String>>,
 }
 
 impl ApprovalGate {
@@ -185,6 +215,7 @@ impl ApprovalGate {
             ttl,
             waiters: Mutex::new(HashMap::new()),
             thread_to_request: Mutex::new(HashMap::new()),
+            meeting_to_request: Mutex::new(HashMap::new()),
         }
     }
 
@@ -268,6 +299,11 @@ impl ApprovalGate {
         let chat_thread_id = chat_ctx.as_ref().map(|c| c.thread_id.clone());
         let chat_client_id = chat_ctx.as_ref().map(|c| c.client_id.clone());
 
+        // In-call meeting context — set by agent_meetings::in_call around a
+        // live-meeting orchestrator turn. Enables the spoken approval
+        // channel alongside the thread card (issue #3513).
+        let in_call_ctx = APPROVAL_IN_CALL_CONTEXT.try_with(|c| c.clone()).ok();
+
         // Branch by origin. Web chat parks for an in-app approval; external
         // channel persists an audit row and TTL-denies (no routable approval
         // surface yet); trusted automation (cron, internal-only subconscious)
@@ -291,14 +327,16 @@ impl ApprovalGate {
                     sender = %sender.as_deref().unwrap_or("<unknown>"),
                     reply_target = %reply_target,
                     message_id = %message_id,
-                    "[approval::gate] external channel turn — persisting audit row and parking \
-                     (will TTL-deny until a routable channel approval surface ships)"
+                    in_call = in_call_ctx.is_some(),
+                    "[approval::gate] external channel turn — persisting audit row and parking"
                 );
                 // Fall through to the parking flow: a `pending_approvals` row
-                // is persisted (audit trail) and the future TTL-denies. We do
-                // NOT short-circuit to Allow here — remote inputs are
-                // untrusted, and there is no UI surface to route a yes/no on
-                // a non-web channel right now.
+                // is persisted (audit trail) and the future parks. We do NOT
+                // short-circuit to Allow here — remote inputs are untrusted.
+                // Without a routable surface the park TTL-denies; with the
+                // in-call context set (live meeting, issue #3513) a decision
+                // can arrive via the spoken channel (`pending_for_meeting` →
+                // `decide`) or the thread card before the (clamped) TTL.
             }
             AgentTurnOrigin::TrustedAutomation {
                 source: TrustedAutomationSource::Cron,
@@ -398,6 +436,13 @@ impl ApprovalGate {
                 .lock()
                 .insert(thread_id.clone(), request_id.clone());
         }
+        // Record the meeting → request mapping so a spoken approval reply
+        // ("Hey Tiny, approve") can be routed to a decision.
+        if let Some(ic) = in_call_ctx.as_ref() {
+            self.meeting_to_request
+                .lock()
+                .insert(ic.meeting_key.clone(), request_id.clone());
+        }
 
         if let Err(err) = store::insert_pending(&self.config, &pending, &self.session_id) {
             self.evict_waiter(&request_id);
@@ -434,13 +479,31 @@ impl ApprovalGate {
             client_id: chat_client_id.clone(),
         });
 
+        // Voice channel (issue #3513): tell the meeting bus to speak the
+        // approval prompt into the call.
+        if let Some(ic) = in_call_ctx.as_ref() {
+            publish_global(DomainEvent::InCallApprovalRequested {
+                request_id: request_id.clone(),
+                tool_name: tool_name.to_string(),
+                action_summary: action_summary.to_string(),
+                correlation_id: ic.correlation_id.clone(),
+            });
+        }
+
         tracing::info!(
             request_id = %request_id,
             tool = tool_name,
             "[approval::gate] tool call parked, waiting for decision"
         );
 
-        let outcome = match tokio::time::timeout(self.ttl, rx).await {
+        // Live meetings get a clamped park window — see IN_CALL_APPROVAL_TTL.
+        let effective_ttl = if in_call_ctx.is_some() {
+            IN_CALL_APPROVAL_TTL.min(self.ttl)
+        } else {
+            self.ttl
+        };
+
+        let outcome = match tokio::time::timeout(effective_ttl, rx).await {
             Ok(Ok(decision)) => {
                 tracing::info!(
                     request_id = %request_id,
@@ -503,7 +566,7 @@ impl ApprovalGate {
                     tracing::info!(
                         request_id = %request_id,
                         tool = tool_name,
-                        ttl_secs = self.ttl.as_secs(),
+                        ttl_secs = effective_ttl.as_secs(),
                         "[approval::gate] timeout race: persisted decision was Approve, honoring approval"
                     );
                     // Fall through (no early return) so `clear_thread` below runs
@@ -515,7 +578,7 @@ impl ApprovalGate {
                     tracing::warn!(
                         request_id = %request_id,
                         tool = tool_name,
-                        ttl_secs = self.ttl.as_secs(),
+                        ttl_secs = effective_ttl.as_secs(),
                         "[approval::gate] approval timed out, denying"
                     );
                     (
@@ -524,7 +587,7 @@ impl ApprovalGate {
                                 "{POLICY_DENIED_MARKER} Approval for '{tool_name}' timed out after \
                                  {}s. Do not re-request the same call this turn; take a different \
                                  approach or stop.",
-                                self.ttl.as_secs()
+                                effective_ttl.as_secs()
                             ),
                         },
                         None,
@@ -532,9 +595,10 @@ impl ApprovalGate {
                 }
             }
         };
-        // The thread routing mapping is only needed while parked; clear it on
+        // The routing mappings are only needed while parked; clear them on
         // every exit (decision, channel drop, or timeout).
         self.clear_thread(&chat_thread_id);
+        self.clear_meeting(&in_call_ctx);
         outcome
     }
 
@@ -634,12 +698,26 @@ impl ApprovalGate {
         self.thread_to_request.lock().get(thread_id).cloned()
     }
 
+    /// The request_id of the approval currently parked on a live meeting, if
+    /// any. Used by `agent_meetings::in_call` to route a spoken
+    /// "Hey Tiny, approve" to a decision (issue #3513).
+    pub fn pending_for_meeting(&self, meeting_key: &str) -> Option<String> {
+        self.meeting_to_request.lock().get(meeting_key).cloned()
+    }
+
     /// Drop the thread → request mapping (best-effort; no-op when absent).
     fn clear_thread(&self, thread_id: &Option<String>) {
         if let Some(t) = thread_id {
             self.thread_to_request.lock().remove(t);
         }
     }
+
+    /// Drop the meeting → request mapping (best-effort; no-op when absent).
+    fn clear_meeting(&self, ctx: &Option<InCallApprovalContext>) {
+        if let Some(ic) = ctx {
+            self.meeting_to_request.lock().remove(&ic.meeting_key);
+        }
+    }
 }
 
 #[cfg(test)]
@@ -687,6 +765,127 @@ mod tests {
         }
     }
 
+    /// An external-channel (live meeting) origin for the in-call fixtures.
+    fn meet_origin() -> AgentTurnOrigin {
+        AgentTurnOrigin::ExternalChannel {
+            channel: "meet".into(),
+            sender: None,
+            reply_target: "meet-1".into(),
+            message_id: "m-1".into(),
+        }
+    }
+
+    fn in_call_ctx() -> InCallApprovalContext {
+        InCallApprovalContext {
+            meeting_key: "meet-1".into(),
+            correlation_id: Some("meet-1".into()),
+        }
+    }
+
+    #[tokio::test]
+    async fn in_call_voice_approve_resolves_parked_external_channel_approval() {
+        let (gate, _dir) = test_gate();
+        let gate = Arc::new(gate);
+
+        let g = gate.clone();
+        let handle = tokio::spawn(async move {
+            turn_origin::with_origin(
+                meet_origin(),
+                APPROVAL_IN_CALL_CONTEXT.scope(
+                    in_call_ctx(),
+                    g.intercept("composio", "create calendar event", serde_json::json!({})),
+                ),
+            )
+            .await
+        });
+
+        // The meeting → request mapping is the voice channel's lookup key.
+        let mut tries = 0;
+        let request_id = loop {
+            if let Some(r) = gate.pending_for_meeting("meet-1") {
+                break r;
+            }
+            tries += 1;
+            assert!(tries < 50, "meeting mapping never appeared");
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        };
+
+        gate.decide(&request_id, ApprovalDecision::ApproveOnce)
+            .unwrap();
+
+        let outcome = handle.await.unwrap();
+        assert!(matches!(outcome, GateOutcome::Allow));
+        assert!(
+            gate.pending_for_meeting("meet-1").is_none(),
+            "meeting mapping must be cleared once the park resolves"
+        );
+    }
+
+    #[tokio::test]
+    async fn in_call_voice_deny_resolves_parked_approval_with_deny() {
+        let (gate, _dir) = test_gate();
+        let gate = Arc::new(gate);
+
+        let g = gate.clone();
+        let handle = tokio::spawn(async move {
+            turn_origin::with_origin(
+                meet_origin(),
+                APPROVAL_IN_CALL_CONTEXT.scope(
+                    in_call_ctx(),
+                    g.intercept("composio", "send email", serde_json::json!({})),
+                ),
+            )
+            .await
+        });
+
+        let request_id = loop {
+            if let Some(r) = gate.pending_for_meeting("meet-1") {
+                break r;
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        };
+
+        gate.decide(&request_id, ApprovalDecision::Deny).unwrap();
+
+        let outcome = handle.await.unwrap();
+        match outcome {
+            GateOutcome::Deny { reason } => assert!(reason.contains("composio")),
+            other => panic!("expected deny, got {other:?}"),
+        }
+        assert!(gate.pending_for_meeting("meet-1").is_none());
+    }
+
+    #[tokio::test]
+    async fn external_channel_without_in_call_ctx_has_no_meeting_mapping() {
+        // Plain external-channel turns (telegram, discord) must not gain a
+        // voice surface: no in-call context → no meeting mapping. Uses the
+        // 2s test TTL so the parked future deny-resolves quickly.
+        let (gate, _dir) = test_gate();
+        let gate = Arc::new(gate);
+
+        let g = gate.clone();
+        let handle = tokio::spawn(async move {
+            turn_origin::with_origin(
+                meet_origin(),
+                g.intercept("composio", "send email", serde_json::json!({})),
+            )
+            .await
+        });
+
+        // Wait for the row to park, then confirm no meeting mapping exists.
+        loop {
+            if !gate.list_pending().unwrap().is_empty() {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+        assert!(gate.pending_for_meeting("meet-1").is_none());
+
+        // TTL-deny is the expected terminal state.
+        let outcome = handle.await.unwrap();
+        assert!(matches!(outcome, GateOutcome::Deny { .. }));
+    }
+
     #[tokio::test]
     async fn approve_once_returns_allow() {
         let (gate, _dir) = test_gate();
diff --git a/src/openhuman/approval/mod.rs b/src/openhuman/approval/mod.rs
index 0eac1c435..55472a34f 100644
--- a/src/openhuman/approval/mod.rs
+++ b/src/openhuman/approval/mod.rs
@@ -20,7 +20,10 @@ pub mod schemas;
 pub mod store;
 pub mod types;
 
-pub use gate::{parse_approval_reply, ApprovalChatContext, ApprovalGate, APPROVAL_CHAT_CONTEXT};
+pub use gate::{
+    parse_approval_reply, ApprovalChatContext, ApprovalGate, InCallApprovalContext,
+    APPROVAL_CHAT_CONTEXT, APPROVAL_IN_CALL_CONTEXT,
+};
 pub use redact::{redact_args, summarize_action};
 pub use schemas::all_controller_schemas as all_approval_controller_schemas;
 pub use schemas::all_registered_controllers as all_approval_registered_controllers;
diff --git a/src/openhuman/config/schema/meet.rs b/src/openhuman/config/schema/meet.rs
index a6b4af65f..834fbb8f7 100644
--- a/src/openhuman/config/schema/meet.rs
+++ b/src/openhuman/config/schema/meet.rs
@@ -70,6 +70,20 @@ pub struct MeetConfig {
     /// When `true`, the bot joins in listen-only mode (mic muted).
     #[serde(default = "default_listen_only")]
     pub listen_only_default: bool,
+
+    /// Phase 2 in-call agency (epic #3505, PR-6): when `true`, wake-phrase
+    /// commands detected mid-call (`bot:in_call_request`) are routed
+    /// through the orchestrator and the reply is spoken back into the
+    /// call (`bot:speak`). Off by default.
+    #[serde(default = "default_enable_in_call_agency")]
+    pub enable_in_call_agency: bool,
+
+    /// When `true` (default), the in-call reply is streamed back as
+    /// per-sentence `bot:speak` chunks as the LLM generates them, so the
+    /// bot starts speaking on the first sentence instead of after the whole
+    /// reply. Set `false` to fall back to a single buffered `bot:speak`.
+    #[serde(default = "default_in_call_streaming")]
+    pub in_call_streaming: bool,
 }
 
 fn default_auto_orchestrator_handoff() -> bool {
@@ -84,6 +98,14 @@ fn default_listen_only() -> bool {
     true
 }
 
+fn default_enable_in_call_agency() -> bool {
+    false
+}
+
+fn default_in_call_streaming() -> bool {
+    true
+}
+
 impl Default for MeetConfig {
     fn default() -> Self {
         Self {
@@ -92,6 +114,8 @@ impl Default for MeetConfig {
             auto_join_policy: AutoJoinPolicy::default(),
             auto_summarize_policy: AutoSummarizePolicy::default(),
             listen_only_default: true,
+            enable_in_call_agency: false,
+            in_call_streaming: true,
         }
     }
 }
@@ -131,6 +155,21 @@ mod tests {
         assert!(cfg.listen_only_default);
     }
 
+    #[test]
+    fn default_in_call_agency_is_off() {
+        let cfg = MeetConfig::default();
+        assert!(!cfg.enable_in_call_agency);
+    }
+
+    #[test]
+    fn default_in_call_streaming_is_on() {
+        let cfg = MeetConfig::default();
+        assert!(cfg.in_call_streaming);
+        // And a config that predates the field still defaults it on.
+        let parsed: MeetConfig = serde_json::from_value(json!({})).unwrap();
+        assert!(parsed.in_call_streaming);
+    }
+
     #[test]
     fn deserialize_missing_fields_uses_defaults() {
         let cfg: MeetConfig = serde_json::from_value(json!({})).unwrap();
@@ -139,6 +178,7 @@ mod tests {
         assert_eq!(cfg.auto_join_policy, AutoJoinPolicy::AskEachTime);
         assert_eq!(cfg.auto_summarize_policy, AutoSummarizePolicy::Ask);
         assert!(cfg.listen_only_default);
+        assert!(!cfg.enable_in_call_agency);
     }
 
     #[test]
@@ -162,6 +202,8 @@ mod tests {
             auto_join_policy: AutoJoinPolicy::Never,
             auto_summarize_policy: AutoSummarizePolicy::Always,
             listen_only_default: false,
+            enable_in_call_agency: true,
+            in_call_streaming: false,
         };
         let s = serde_json::to_string(&original).unwrap();
         let back: MeetConfig = serde_json::from_str(&s).unwrap();
@@ -170,5 +212,6 @@ mod tests {
         assert_eq!(back.auto_join_policy, AutoJoinPolicy::Never);
         assert_eq!(back.auto_summarize_policy, AutoSummarizePolicy::Always);
         assert!(!back.listen_only_default);
+        assert!(back.enable_in_call_agency);
     }
 }
diff --git a/src/openhuman/meet_agent/brain/mod.rs b/src/openhuman/meet_agent/brain/mod.rs
index acb7516e3..f32d627b6 100644
--- a/src/openhuman/meet_agent/brain/mod.rs
+++ b/src/openhuman/meet_agent/brain/mod.rs
@@ -43,6 +43,11 @@ mod turns;
 pub use access::{run_grant_turn, run_soft_deny_turn};
 pub use turns::{run_caption_turn, run_turn};
 
+// Speech sanitizer shared with `agent_meetings::in_call` — both paths
+// feed orchestrator replies into TTS and need the same markdown /
+// reasoning-trace stripping.
+pub(crate) use text::strip_for_speech;
+
 use constants::agent_cache;
 
 /// Drop the cached orchestrator for a meet session. Called from
@@ -66,7 +71,7 @@ pub(crate) use access::{
 #[cfg(test)]
 pub(crate) use llm::extract_chat_completion_text;
 #[cfg(test)]
-pub(crate) use text::{recent_dialog_history, strip_for_speech};
+pub(crate) use text::recent_dialog_history;
 
 #[cfg(test)]
 #[path = "../brain_tests.rs"]