@vellumai/assistant 0.12.2-dev.202609172115.0b9be8f → 0.12.2-dev.202609172313.5ad9c4b

package/docs/live-voice-task-outcomes.md

@@ -0,0 +1,83 @@
+# Background task outcomes in live voice
+
+The conversation's active live-voice session owns delivery of subagent updates
+while the call is open. `injectMessageIntoParent` offers updates carrying
+`subagentNotification` metadata to the existing `LiveVoiceSessionManager` before
+enqueuing a generic parent turn. The manager only routes to its session with the
+matching conversation ID. A closing session holds incoming updates for its
+teardown handoff. Other conversations and fully closed calls retain the ordinary
+parent delivery path.
+
+The session keeps pending updates per subagent. A newer update from the same
+subagent replaces its pending update; independent subagents keep separate entries.
+Success, failure, abort and mid-run updates all follow this route. Silent/advisor
+instructions remain in the update so the assistant can use findings internally.
+
+Announcements use the shared voice floor check: user speech, an active response,
+and queued audio playback delay delivery. A hidden, tool-capable voice turn
+processes the update with current conversation context and produces speech through
+the normal TTS pipeline. The original notification metadata and cron attribution
+travel with the turn. No synthetic user bubble is echoed. The assistant can read
+additional output or resolve a blocker without starting a competing text turn.
+
+The assistant decides whether an update adds useful information. It speaks the
+new outcome before optional visual-summary tools, or outputs the internal
+`[TASK_UPDATE:SILENT]` marker for routine progress or findings already heard.
+The marker is stripped from speech, captions, and persisted assistant text; a
+completed silent decision acknowledges the update without audio.
+
+Spoken results require forwarded reply audio and remain pending through the
+estimated playback tail. Progress narration alone, empty speech synthesis, and
+failed speech synthesis leave them pending. A barge-in preserves the interrupted outcome without
+creating another worker. A failed launch or an
+explicit stop defers retry until the next user turn or task update. Hang-up returns
+undelivered updates to the ordinary conversation path after pending voice starts
+and the voice turn's teardown settle, since its abort clears the parent queue.
+The handoff bypasses voice routing so a replacement call cannot reclaim it during
+teardown. All parent deliveries enqueue even when idle and trigger the existing
+queue drain after turn finalization, so simultaneous outcomes share its processing
+lock and retry behavior.
+
+PCM is framed into at most 100ms chunks, with the first available samples emitted
+immediately. Socket emission runs roughly 500ms ahead of estimated playback,
+keeping prefetched synthesis from flooding the relay queue. Pacing waits stay
+outside the shared outbound-frame queue and abort with the turn, so cancellation
+and control frames are not delayed. Assistant audio recordings contain only
+frames successfully sent to the transport. Hands-free clients reconnect on retryable
+relay closes, including legacy backpressure code 4013.
+
+The pending queue is session-local; this does not add a durable notification ledger
+or client playback acknowledgements. Task records and worker output retain their
+existing persistence. Automatic announcements follow the current exchange rather
+than merging task updates into an already-running response.
+
+## macOS companion QA
+
+Start a fresh conversation from the companion and use a new investigation topic
+so an earlier report cannot satisfy the request. Ask explicitly for a background
+agent. Use ordinary conversational pauses; timed silence is not required.
+Continuous Flux input and the diagnostics described in
+[voice input diagnostics](voice-input-diagnostics.md) apply to these calls.
+
+1. **Ordinary completion.** Ask for a small background investigation and wait.
+   Confirm the task actually starts, the assistant acknowledges the request, and
+   useful findings are spoken without asking for them. A completion-only notice
+   or visual summary without an audible explanation is not sufficient.
+2. **Keep talking.** Start another investigation, then ask an unrelated question.
+   Include a natural pause partway through the question. The question should stay
+   together, the work should survive, and its results should wait for the current
+   exchange to finish before being announced.
+3. **Interrupt the announcement.** Speak while findings are being announced.
+   The assistant should yield, answer the interruption, and retain the unheard
+   result for appropriate delivery. Interrupting an announcement should not spawn
+   another copy of the investigation.
+4. **Two tasks.** Request two independent investigations. Keep chatting while
+   they run, then leave an opening. Both useful outcomes should arrive without
+   overlapping audio, repetitive status announcements, or a disconnect.
+5. **Hang up before delivery.** End the call with work still running or a result
+   waiting to be heard. Confirm the outcome reaches the conversation afterward.
+
+Record approximate times for requests, interruptions, missing results, and any
+disconnect. Export support logs after the call. Distinguish the request being
+acknowledged, the worker starting, and the result being heard; they exercise
+different parts of the flow.

package/docs/voice-input-diagnostics.md

@@ -0,0 +1,46 @@
+# Voice input diagnostics
+
+Hands-free voice records signal measurements in the ordinary support log export. This includes calls started from the macOS companion. These diagnostics do not change capture constraints, speech thresholds, interruption timing, or task cancellation. They add no PCM recordings, transcript text, microphone labels, or device identifiers.
+
+## Collect a reproduction
+
+Use the same microphone, output device, volume, and companion surface as the failing call. Note whether output is through headphones or speakers.
+
+1. Start a companion voice call. Stay quiet for about 20 seconds to capture the room baseline.
+2. Ask for an explanation long enough to produce sustained speech. Stay quiet while it answers; note the time of any unexpected cutoff.
+3. Ask it to start a background investigation. Stay quiet during startup; note missing acknowledgements or cancelled starts.
+4. Deliberately interrupt an answer with a short spoken question. This provides a real interruption to compare against the unexplained cutoffs.
+5. End the call and export logs through the existing feedback log export.
+
+Keep the initial reproduction on the original audio setup. A second call using headphones, or using the built-in microphone instead of a headset, can isolate a route-dependent problem after the first capture.
+
+## Client records
+
+`[live-voice-input]` entries are serialized JSON in `electron-main-logs.txt`. Electron collects them from every renderer, so export does not depend on which window hosts the companion call. The same events appear as `voice_input` in the web diagnostics lifecycle ring.
+
+- `capture_started` and `input_switched` report applied echo cancellation, noise suppression, gain control, channel count, and track/context/output sample rates. `null` means the browser did not report a setting. An explicit device selection reports whether it matched, without logging either device identifier.
+- `capture_mute`, `capture_unmute`, `capture_ended`, and `capture_statechange` expose track and audio-context transitions. Listeners retire with the old stream on a device switch or stop.
+- `session_ready` links the client `captureId` to the server `sessionId`. Capture can open before the server is ready, so earlier entries have a null session ID. `entry` identifies the launch surface when supplied.
+- `speech_started`, `turn_cancelled`, and `utterance_discarded` report whether playback was active, held, or actually resumed after an unusable utterance.
+
+## Server records
+
+Search the assistant log for `Live voice input diagnostics` or `voice_input_`. All records include session, input-turn, assistant-turn, and speech-generation identifiers where available, plus the effective threshold, room floor, echo configuration, playback estimate, and foreground-task state.
+
+- `voice_input_window` summarizes each approximately five-second arrival window: received audio duration, zero-signal duration, duration-weighted mean amplitude, minimum/maximum chunk mean amplitude, classified speech/silence/echo duration, and maximum arrival gap. Window emission requires incoming audio; `voice_input_closed` flushes a partial window.
+- The same window includes `sttSubmittedChunks`, `sttSubmittedAudioMs`, and `sttMaxSubmissionGapMs`. These measure handoff to the transcription adapter, not provider receipt. A probe can buffer audio before submission, and the final chunk of an arrival window can be submitted in the next window. Compare sustained windows to identify input that arrives normally but stops reaching transcription.
+- `voice_input_provider_turn_start` and `voice_input_provider_turn_end` record provider boundaries alongside local VAD state. End records include confidence, the provider's `trigger` (`model`, `timeout`, or `manual`), decoded audio position in seconds from stream start, and elapsed time since locally detected speech. Missing provider fields are null. These records describe received decisions, including ones ignored as stale or after fallback; correlate with the turn metrics to identify the boundary that committed the request.
+- `voice_input_barge_in_armed`, `voice_input_barge_in_fired`, and `voice_input_barge_in_expired` distinguish a candidate from an accepted or expired interruption. Fired events include accumulated speech duration, guard resets, and a bounded trace of the preceding two seconds (at most 40 input chunks).
+- Each trace entry captures the amplitude and gate/echo state before classification, and classified durations, remaining probe buffer, and correlation result after classification. The classifier can hold a probe and release multiple older chunks together, so a row's classified duration can differ from its received duration. A null correlation means no comparison ran, not a measured zero correlation.
+- `voice_input_speech_routed` binds the speech generation to the input turn that actually receives its audio. At onset, the prior spent cycle may still be installed, so use this routing record for correlation rather than assuming the onset's `inputTurnId` is the new utterance.
+- `voice_input_transcript` reports committed character count and provider, never words. `voice_input_utterance_discarded` reports the discard reason and remaining transcript/partial state.
+
+Amplitude uses the classifier's PCM16 mean-absolute scale, not the client's normalized UI meter. Playback timing is the server's estimate, not proof that sound was heard. An empty transcript is evidence of no usable transcription; it does not establish that the person was silent or that the detector was wrong.
+
+These are local diagnostic logs, not new analytics events or voice protocol fields. Existing log retention and export apply.
+
+## Flux pause handling
+
+When Flux owns turn detection, it receives microphone audio through idle periods and pauses, including quiet speech below the local VAD gate. Confirmed playback echo is replaced by silence of the same duration so it advances the provider's audio clock without transcribing the assistant's voice. Echo probes can briefly buffer that audio. Local VAD still owns barge-in; its thresholds and guard are independent of this continuous transcription feed. Idle audio is not accumulated into request recordings.
+
+For a focused reproduction, say an unfinished question such as "Did they help invent", pause briefly, then complete it with "ChatGPT". Repeat with a shorter and a longer pause, plus a complete short question. Note when the assistant starts answering and export the logs. Check that STT submissions continue during the pause, then use the provider end event's time, confidence, and trigger to distinguish model endpointing from a timeout. Tests verify audio delivery and event handling; they do not establish how Flux will segment real speech.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609172115.0b9be8f",
+  "version": "0.12.2-dev.202609172313.5ad9c4b",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -22,8 +22,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
       });
       return { queued: true };
     },
-    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-    runAgentLoop: async () => {},
+    kickDrainQueue: async () => {},
   }),
 }));
 

package/src/__tests__/subagent-manager-notify.test.ts

@@ -27,8 +27,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
       });
       return { queued: true };
     },
-    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-    runAgentLoop: async () => {},
+    kickDrainQueue: async () => {},
   }),
 }));
 

package/src/__tests__/subagent-notify-parent.test.ts

@@ -41,18 +41,12 @@ const capturedMessages: string[] = [];
 /** Parent conversation ids that a notification was routed to (findConversation). */
 const capturedParentIds: string[] = [];
 
-/**
- * Cron attribution seen by each delivery path. The queued path hands it to
- * `enqueueMessage` (the drain applies it later); the immediate path hands it
- * straight to `runAgentLoop`.
- */
 const capturedEnqueueCronRunIds: (string | null | undefined)[] = [];
-const capturedLoopCronRunIds: (string | null | undefined)[] = [];
-
-/**
- * Whether the stub parent accepts an enqueue. `false` sends
- * `injectMessageIntoParent` down its immediate persist-and-run path.
- */
+const capturedQueueOptions: {
+  queueWhenIdle: boolean;
+  metadata?: Record<string, unknown>;
+}[] = [];
+const drainedParents: string[] = [];
 let parentAcceptsEnqueue = true;
 
 // Live subagent conversations, keyed by conversationId. notifyParentFromChild
@@ -74,19 +68,17 @@ mock.module("../daemon/conversation-registry.js", () => ({
       hasInFlightWork: () => false,
       enqueueMessage: (options: {
         content: string;
+        queueWhenIdle: boolean;
+        metadata?: Record<string, unknown>;
         cronRunId?: string | null;
       }) => {
         capturedMessages.push(options.content);
+        capturedQueueOptions.push(options);
         capturedEnqueueCronRunIds.push(options.cronRunId);
         return { queued: parentAcceptsEnqueue };
       },
-      persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-      runAgentLoop: async (
-        _message: string,
-        _messageId: string,
-        options?: { cronRunId?: string | null },
-      ) => {
-        capturedLoopCronRunIds.push(options?.cronRunId);
+      kickDrainQueue: async () => {
+        drainedParents.push(id);
       },
     };
   },
@@ -111,11 +103,15 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 
 import type { Conversation } from "../daemon/conversation.js";
 import { isToolActiveForContext } from "../daemon/conversation-tool-setup.js";
+import { beginTurnFinalization } from "../daemon/turn-finalization.js";
+import { setLiveVoiceSessionManagerForTesting } from "../live-voice/live-voice-manager.js";
+import { LiveVoiceSessionManager } from "../live-voice/live-voice-session-manager.js";
 import type { SubagentRecord } from "../persistence/subagent-store.js";
 import {
   injectMessageIntoParent,
   notifyParentFromChild,
 } from "../subagent/notify.js";
+import type { SubagentParentNotification } from "../subagent/parent-notification.js";
 import {
   executeSubagentNotifyParent,
   notifyParentTool,
@@ -183,12 +179,108 @@ function lastCapturedMessage(): string {
 function clearCaptured(): void {
   capturedMessages.length = 0;
   capturedEnqueueCronRunIds.length = 0;
-  capturedLoopCronRunIds.length = 0;
+  capturedQueueOptions.length = 0;
+  drainedParents.length = 0;
   parentAcceptsEnqueue = true;
 }
 
 // ── Tool definition ────────────────────────────────────────────────
 
+describe("voice parent notification routing", () => {
+  test("only the matching active call claims task updates, without starting a generic parent turn", async () => {
+    clearCaptured();
+    const received: SubagentParentNotification[] = [];
+    let finishClose: (() => void) | undefined;
+    const manager = new LiveVoiceSessionManager({
+      createSession: (context) => ({
+        start: async () => {
+          await context.sendFrame({
+            type: "ready",
+            sessionId: context.sessionId,
+            conversationId: "parent-voice",
+          });
+        },
+        handleClientFrame: () => {},
+        handleBinaryAudio: () => {},
+        close: () =>
+          new Promise<void>((resolve) => {
+            finishClose = resolve;
+          }),
+        receiveSubagentNotification: (notification) => {
+          received.push(notification);
+          return true;
+        },
+      }),
+    });
+    setLiveVoiceSessionManagerForTesting(manager);
+    const metadata = {
+      subagentNotification: {
+        subagentId: "task-1",
+        status: "completed",
+        conversationId: "child-1",
+      },
+    };
+    try {
+      await manager.startSession(
+        {
+          type: "start",
+          audio: { mimeType: "audio/pcm", sampleRate: 24_000, channels: 1 },
+        },
+        { sendFrame: () => {} },
+      );
+      injectMessageIntoParent("parent-voice", "Task completed", metadata, {
+        cronRunId: "run-123",
+      });
+      expect(received).toEqual([
+        {
+          taskId: "child-1",
+          message: "Task completed",
+          metadata,
+          cronRunId: "run-123",
+        },
+      ]);
+      expect(capturedMessages).toEqual([]);
+      expect(drainedParents).toEqual([]);
+
+      injectMessageIntoParent("parent-other", "Other task completed", metadata);
+      injectMessageIntoParent("parent-voice", "Generic event");
+      injectMessageIntoParent("parent-voice", "Hang-up fallback", metadata, {
+        bypassLiveVoice: true,
+        cronRunId: "run-123",
+      });
+      expect(received).toHaveLength(1);
+      expect(capturedMessages).toEqual([
+        "Other task completed",
+        "Generic event",
+        "Hang-up fallback",
+      ]);
+      expect(capturedEnqueueCronRunIds.at(-1)).toBe("run-123");
+
+      const closing = manager.endActiveSession("manager_shutdown");
+      injectMessageIntoParent(
+        "parent-voice",
+        "Finished during hang-up",
+        metadata,
+      );
+      expect(received.at(-1)?.message).toBe("Finished during hang-up");
+      expect(capturedMessages).not.toContain("Finished during hang-up");
+      finishClose?.();
+      await closing;
+      injectMessageIntoParent(
+        "parent-voice",
+        "Finished after hang-up",
+        metadata,
+      );
+      expect(capturedMessages.at(-1)).toBe("Finished after hang-up");
+    } finally {
+      finishClose?.();
+      await manager.endActiveSession("manager_shutdown");
+      setLiveVoiceSessionManagerForTesting(null);
+      clearCaptured();
+    }
+  });
+});
+
 describe("notify_parent tool definition", () => {
   test("has correct core tool definition", () => {
     const def = notifyParentTool;
@@ -443,31 +535,46 @@ describe("injectMessageIntoParent cron attribution", () => {
     expect(capturedEnqueueCronRunIds).toEqual(["cron-run-7"]);
   });
 
-  test("the immediate delivery path carries the firing's run id", async () => {
+  test("queues simultaneous idle-parent deliveries until turn finalization", async () => {
     clearCaptured();
-    // A parent that is not processing rejects the enqueue, so the injection
-    // persists and runs the turn itself.
-    parentAcceptsEnqueue = false;
-
-    injectMessageIntoParent("parent-cron", "notification", undefined, {
-      cronRunId: "cron-run-7",
-    });
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(capturedLoopCronRunIds).toEqual(["cron-run-7"]);
+    const finalize = beginTurnFinalization("parent-handoff");
+    try {
+      injectMessageIntoParent("parent-handoff", "first result", undefined, {
+        bypassLiveVoice: true,
+      });
+      injectMessageIntoParent("parent-handoff", "second result", undefined, {
+        bypassLiveVoice: true,
+      });
+      expect(capturedMessages).toEqual(["first result", "second result"]);
+      expect(capturedQueueOptions).toEqual([
+        expect.objectContaining({
+          queueWhenIdle: true,
+          metadata: { scripted: true },
+        }),
+        expect.objectContaining({
+          queueWhenIdle: true,
+          metadata: { scripted: true },
+        }),
+      ]);
+      expect(drainedParents).toEqual([]);
+    } finally {
+      finalize();
+    }
+    await Promise.resolve();
+    expect(drainedParents).toEqual(["parent-handoff", "parent-handoff"]);
   });
 
-  test("an unscheduled notification carries no run id on either path", async () => {
+  test("does not start an unqueued turn when the parent queue rejects delivery", () => {
     clearCaptured();
-
-    injectMessageIntoParent("parent-plain", "notification");
     parentAcceptsEnqueue = false;
-    injectMessageIntoParent("parent-plain", "notification");
-    await new Promise((resolve) => setTimeout(resolve, 0));
+    injectMessageIntoParent("parent-full", "notification");
+    expect(drainedParents).toEqual([]);
+  });
 
-    // Not merely falsy: the option is absent, so nothing downstream reads an
-    // attribution no firing produced.
-    expect(capturedEnqueueCronRunIds).toEqual([undefined, undefined]);
-    expect(capturedLoopCronRunIds).toEqual([undefined]);
+  test("an unscheduled notification carries no run id", () => {
+    clearCaptured();
+    injectMessageIntoParent("parent-plain", "notification");
+    expect(capturedEnqueueCronRunIds).toEqual([undefined]);
+    expect(drainedParents).toEqual(["parent-plain"]);
   });
 });

package/src/__tests__/subagent-notify-stale-rebuild.test.ts

@@ -22,8 +22,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
         delivered.push(options.content);
         return { queued: true };
       },
-      persistUserMessage: async () => ({ id: "mock-msg" }),
-      runAgentLoop: async () => {},
+      kickDrainQueue: async () => {},
     };
   },
 }));
@@ -36,8 +35,7 @@ mock.module("../daemon/conversation-store.js", () => ({
         delivered.push(`rebuilt:${options.content}`);
         return { queued: true };
       },
-      persistUserMessage: async () => ({ id: "rebuilt-msg" }),
-      runAgentLoop: async () => {},
+      kickDrainQueue: async () => {},
     };
   },
 }));

package/src/calls/__tests__/voice-control-protocol.test.ts

@@ -10,6 +10,7 @@ import {
   type SessionControlRequest,
   stripInternalSpeechMarkers,
   TASK_STOP_MARKER,
+  TASK_UPDATE_SILENT_MARKER,
   terminalControlMarkerLength,
 } from "../voice-control-protocol.js";
 
@@ -227,3 +228,17 @@ describe("session control markers", () => {
     expect(terminalControlMarkerLength("The array [-1] sorts")).toBe(0);
   });
 });
+
+test("silent task-update marker is held across every split and removed from the transcript", () => {
+  for (let split = 1; split < TASK_UPDATE_SILENT_MARKER.length; split += 1) {
+    const emitted: string[] = [];
+    const flush = createControlMarkerHoldback((text) => emitted.push(text));
+    flush(TASK_UPDATE_SILENT_MARKER.slice(0, split));
+    flush(TASK_UPDATE_SILENT_MARKER, { force: true });
+    expect(emitted.join("")).toBe("");
+  }
+  expect(terminalControlMarkerLength(TASK_UPDATE_SILENT_MARKER)).toBe(
+    TASK_UPDATE_SILENT_MARKER.length,
+  );
+  expect(parseTerminalSessionControl(TASK_UPDATE_SILENT_MARKER)).toBeNull();
+});

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -724,6 +724,44 @@ describe("startVoiceTurn camera-frame attachments", () => {
 });
 
 describe("startVoiceTurn hiddenSyntheticPrompt", () => {
+  test("task announcements retain metadata and cron attribution without a user echo", async () => {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+    const loopOptions: unknown[] = [];
+    fake.conversation.runAgentLoop = async (...args: unknown[]) => {
+      loopOptions.push(args[2]);
+    };
+    const metadata = {
+      subagentNotification: {
+        subagentId: "task-1",
+        label: "Compare options",
+        status: "completed",
+      },
+    };
+    const echoes = await collectUserMessageEchoes(async () => {
+      await startVoiceTurn({
+        ...makeTurnOptions(),
+        content: "Comparison completed",
+        hiddenSyntheticPrompt: true,
+        subagentNotification: {
+          taskId: "task-1",
+          message: "Comparison completed",
+          metadata,
+          cronRunId: "run-123",
+        },
+      });
+    });
+    expect(fake.lastPersistOpts()?.metadata).toMatchObject({
+      ...metadata,
+      hidden: true,
+      scripted: true,
+      voiceSessionTurn: true,
+    });
+    expect(loopOptions).toEqual([
+      expect.objectContaining({ cronRunId: "run-123" }),
+    ]);
+    expect(echoes).toEqual([]);
+  });
   // A caller whose internal instruction is composed per call carries no
   // sentinel for the content comparisons to recognize, so it declares itself.
   const SYNTHETIC_CONTENT =

package/src/calls/voice-control-protocol.ts

@@ -14,6 +14,7 @@ export const CALL_OPENING_ACK_MARKER = "[CALL_OPENING_ACK]";
 export const CALL_VERIFICATION_COMPLETE_MARKER = "[CALL_VERIFICATION_COMPLETE]";
 export const END_CALL_MARKER = "[END_CALL]";
 export const TASK_STOP_MARKER = "[TASK:STOP]";
+export const TASK_UPDATE_SILENT_MARKER = "[TASK_UPDATE:SILENT]";
 
 /**
  * Verdict tokens for the fast "front-door" model (triage-and-escalate voice
@@ -220,6 +221,7 @@ export function stripInternalSpeechMarkers(text: string): string {
     .replace(CALL_OPENING_ACK_MARKER_REGEX, "")
     .replace(END_CALL_MARKER_REGEX, "")
     .replace(TASK_STOP_MARKER_REGEX, "")
+    .replaceAll(TASK_UPDATE_SILENT_MARKER, "")
     .replace(HOLD_VERDICT_TOKEN_REGEX, "")
     .replace(ESCALATE_VERDICT_TOKEN_REGEX, "")
     .replace(MINIMIZE_ROOM_MARKER_REGEX, "")
@@ -249,6 +251,7 @@ const CONTROL_MARKER_STRINGS = [
   "[CALL_OPENING_ACK]",
   "[END_CALL]",
   TASK_STOP_MARKER,
+  TASK_UPDATE_SILENT_MARKER,
   "[0]",
   "[1]",
   "[-1]",
@@ -435,6 +438,9 @@ export function parseTerminalSessionControl(
  */
 export function terminalControlMarkerLength(text: string): number {
   const trimmed = text.trimEnd();
+  if (trimmed.endsWith(TASK_UPDATE_SILENT_MARKER)) {
+    return TASK_UPDATE_SILENT_MARKER.length;
+  }
   if (trimmed.endsWith(MINIMIZE_ROOM_MARKER)) {
     return MINIMIZE_ROOM_MARKER.length;
   }

package/src/calls/voice-session-bridge.ts

@@ -57,6 +57,7 @@ import { getCurrentSeq } from "../runtime/assistant-stream-state.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { sttCatalogKeyForRole } from "../stt/roles.js";
+import type { SubagentParentNotification } from "../subagent/parent-notification.js";
 import { getAllTools } from "../tools/registry.js";
 import { sensitiveToolReach } from "../tools/tool-approval-handler.js";
 import { createAbortReason } from "../util/abort-reasons.js";
@@ -389,6 +390,8 @@ export interface VoiceTurnCallbacks {
 }
 
 export interface VoiceTurnOptions {
+  /** Internal task update delivered through the call, with its original attribution. */
+  subagentNotification?: SubagentParentNotification;
   /** The conversation ID for this voice call's session. */
   conversationId: string;
   /** Voice session ID for scoped grant matching. Defaults to callSessionId. */
@@ -1219,6 +1222,7 @@ export async function startVoiceTurn(
       ...(turnAttachments.length > 0 ? { attachments: turnAttachments } : {}),
       requestId,
       metadata: {
+        ...opts.subagentNotification?.metadata,
         // Durable "this turn came from an open voice session" marker; see
         // `isVoiceSessionUserMessage` for why the channel fields cannot carry it.
         voiceSessionTurn: true,
@@ -2056,6 +2060,9 @@ export async function startVoiceTurn(
         );
       }
       await conversation.runAgentLoop(persistedContent, messageId, {
+        ...(opts.subagentNotification?.cronRunId
+          ? { cronRunId: opts.subagentNotification.cronRunId }
+          : {}),
         onEvent: (msg: AssistantEvent) => {
           if (msg.type === "assistant_turn_start") {
             reservedAssistantRowId = msg.messageId;