@vellumai/assistant 0.10.10-dev.202607171631.a0a52fd → 0.10.10-dev.202607171828.fc2f5d5

package/openapi.yaml

@@ -19152,13 +19152,6 @@ paths:
                     snapshots, emits no echo, and does not supersede pending interactions. Honored on the standard send
                     path only — slash-command content bypasses it."
                   type: boolean
-                source:
-                  description:
-                    'How the send was initiated when the message was sent on the user''s behalf by the UI rather than typed by
-                    hand. Current value: "nav_redirect" (a navigation shortcut redirected the user into chat with a
-                    pre-filled message). Persisted onto the message metadata for analytics attribution and used to steer
-                    the assistant toward a brief, concrete reply. Omit for messages the user typed.'
-                  type: string
                 onboarding:
                   type: object
                   properties:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.10-dev.202607171631.a0a52fd",
+  "version": "0.10.10-dev.202607171828.fc2f5d5",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/config/feature-flag-registry.json

@@ -16,11 +16,7 @@
       "label": "Activation Flow Experiment 2026-06-03",
       "description": "Multivariate activation-flow experiment. control = standard flow; variant-a = activation rail; personal-page = new sign-up-page variant (front-end only). Targeted via LaunchDarkly.",
       "defaultEnabled": "control",
-      "values": [
-        "control",
-        "variant-a",
-        "personal-page"
-      ]
+      "values": ["control", "variant-a", "personal-page"]
     },
     {
       "id": "local-docker-enabled",
@@ -373,19 +369,6 @@
       "label": "Chat Credential Reveal",
       "description": "Persist chat secret redactions as sentinel markers instead of the legacy HTML marker, enriched with the vault identity when the value byte-matches a credential revealed this turn. Also gates the `credentials reveal --for-chat` channel and the live-stream swap that replaces an echoed reveal plaintext with its sentinel before emission. Redaction itself is NOT gated: a route-proven reveal plaintext stays out of persisted rows in both modes. Client chip rendering is gated on daemon version, not on this flag.",
       "defaultEnabled": false
-    },
-    {
-      "id": "sidenav-gating-experiment-2026-07-16",
-      "scope": "client",
-      "key": "sidenav-gating-experiment-2026-07-16",
-      "label": "Sidenav Gating Experiment 2026-07-16",
-      "description": "First-session sidenav gating experiment (activation). none = not in cohort (default; no gating, no experiment events); control = cohort control (current experience, experiment events emit); gated = sidenav items disabled until 1/5 sent messages with avatar-bubble redirects. Cohort (new signups, 50/50 control-vs-gated) targeted via LaunchDarkly.",
-      "defaultEnabled": "none",
-      "values": [
-        "none",
-        "control",
-        "gated"
-      ]
     }
   ]
 }

package/src/daemon/conversation-agent-loop.ts

@@ -254,16 +254,6 @@ async function withAbortWatchdog<T>(
 
 // ── runAgentLoop ─────────────────────────────────────────────────────
 
-/**
- * Steering block appended to the tail user message on turns whose
- * triggering message carries `messageSource: "nav_redirect"` — a UI
- * shortcut sent the message on the user's behalf while the user was
- * exploring the interface. Without it the model treats the canned prompt
- * as a hand-typed question and answers with a capability tour.
- */
-const NAV_REDIRECT_STEERING_BLOCK =
-  "<system_reminder>\nThis message was sent by a UI shortcut while the user explored the interface, not typed by hand. Reply in a few sentences at most and end with one concrete, specific next step or question — do not enumerate capabilities or give a tour.\n</system_reminder>";
-
 export async function runAgentLoopImpl(
   ctx: Conversation,
   content: string,
@@ -280,15 +270,6 @@ export async function runAgentLoopImpl(
      * the turn.
      */
     isHiddenPrompt?: boolean;
-    /**
-     * How the triggering message was initiated when it was sent on the
-     * user's behalf by the UI rather than typed by hand (`body.source` on
-     * `POST /v1/messages`, persisted as `metadata.userMessageSource`).
-     * Current value: `"nav_redirect"`, which steers the turn toward a
-     * brief, concrete reply. Forwarded onto the user-prompt-submit hook
-     * context. Unset for hand-typed messages.
-     */
-    messageSource?: string;
     /**
      * LLM call-site identifier threaded into the per-call provider config.
      * Adapter callers (heartbeat, filing, scheduler, etc.) pass their own
@@ -1000,9 +981,6 @@ export async function runAgentLoopImpl(
       requestId: reqId,
       prompt: options?.titleText ?? content,
       isHiddenPrompt: options?.isHiddenPrompt === true,
-      ...(options?.messageSource
-        ? { messageSource: options.messageSource }
-        : {}),
       originalMessages: Object.freeze([...ctx.messages]),
       latestMessages: ctx.messages,
       modelProfileKey,
@@ -1014,29 +992,7 @@ export async function runAgentLoopImpl(
       userPromptCtx,
     );
     latencyTracker.mark("prompt_hook_end");
-    let runMessages = finalUserPromptCtx.latestMessages;
-
-    // UI-shortcut steering: appended after the hook chain so it lands below
-    // the assembled runtime injections on the tail user message, mirroring
-    // the non-interactive block's placement in `applyRuntimeInjections`.
-    // Turn-scoped nudge, deliberately not persisted for byte-exact reload
-    // rehydration — losing it on reload costs one prefix-cache anchor, not
-    // context correctness.
-    if (options?.messageSource === "nav_redirect") {
-      const userTail = runMessages[runMessages.length - 1];
-      if (userTail && userTail.role === "user") {
-        runMessages = [
-          ...runMessages.slice(0, -1),
-          {
-            ...userTail,
-            content: [
-              ...userTail.content,
-              { type: "text" as const, text: NAV_REDIRECT_STEERING_BLOCK },
-            ],
-          },
-        ];
-      }
-    }
+    const runMessages = finalUserPromptCtx.latestMessages;
 
     // Reset the manager's turn-scoped overflow-recovery ladder at the turn
     // boundary so a new turn starts the ladder fresh from the emergency rung.

package/src/daemon/conversation-process.ts

@@ -23,7 +23,6 @@ import { extractPreferences } from "../notifications/preference-extractor.js";
 import { createPreference } from "../notifications/preferences-store.js";
 import {
   addMessage,
-  getUserMessageSourceMetadata,
   isHiddenMessageMetadata,
   provenanceFromTrustContext,
   recordConversationPersistedSeq,
@@ -1050,7 +1049,6 @@ async function drainSingleMessage(
     isUserMessage?: boolean;
     titleText?: string;
     isHiddenPrompt?: boolean;
-    messageSource?: string;
   } = { isUserMessage: true };
   if (next.isInteractive !== undefined) {
     drainLoopOptions.isInteractive = next.isInteractive;
@@ -1061,10 +1059,6 @@ async function drainSingleMessage(
   if (isHiddenMessageMetadata(next.metadata)) {
     drainLoopOptions.isHiddenPrompt = true;
   }
-  const queuedMessageSource = getUserMessageSourceMetadata(next.metadata);
-  if (queuedMessageSource !== undefined) {
-    drainLoopOptions.messageSource = queuedMessageSource;
-  }
 
   conversation
     .runAgentLoop(agentLoopContent, userMessageId, {
@@ -1506,7 +1500,6 @@ async function drainBatch(
     isUserMessage?: boolean;
     titleText?: string;
     isHiddenPrompt?: boolean;
-    messageSource?: string;
   } = { isUserMessage: true };
   // Source interactive flag from the last successfully-persisted sibling so
   // a trailing failed tail doesn't flip the agent loop's interactivity.
@@ -1526,21 +1519,6 @@ async function drainBatch(
   ) {
     drainLoopOptions.isHiddenPrompt = true;
   }
-  // Same all-or-nothing rule for the send-source steering: a batch counts
-  // as UI-initiated only when every message in it carries the same source
-  // tag — one hand-typed message justifies a full answer.
-  const batchMessageSource =
-    successfulBatch.length > 0
-      ? getUserMessageSourceMetadata(successfulBatch[0].metadata)
-      : undefined;
-  if (
-    batchMessageSource !== undefined &&
-    successfulBatch.every(
-      (qm) => getUserMessageSourceMetadata(qm.metadata) === batchMessageSource,
-    )
-  ) {
-    drainLoopOptions.messageSource = batchMessageSource;
-  }
 
   // Fire-and-forget: runAgentLoop's finally block recursively calls drainQueue
   // when this run completes. Mirrors drainSingleMessage.

package/src/daemon/conversation.ts

@@ -2492,8 +2492,6 @@ export class Conversation {
       titleText?: string;
       /** See {@link runAgentLoopImpl} — hidden machine-signal turn marker. */
       isHiddenPrompt?: boolean;
-      /** See {@link runAgentLoopImpl} — UI-initiated send-source tag. */
-      messageSource?: string;
       callSite?: LLMCallSite;
       /**
        * Optional ad-hoc inference-profile override applied to every LLM call

package/src/hooks/types.ts

@@ -173,15 +173,6 @@ export interface UserPromptSubmitInputContext {
    * user speech (e.g. title generation) should skip these turns.
    */
   readonly isHiddenPrompt?: boolean;
-  /**
-   * How the triggering message was initiated when it was sent on the
-   * user's behalf by the UI rather than typed by hand (`body.source` on
-   * `POST /v1/messages`, persisted as `metadata.userMessageSource`).
-   * Current value: `"nav_redirect"` — a navigation shortcut redirected the
-   * user into chat with a pre-filled message. Unset for hand-typed
-   * messages.
-   */
-  readonly messageSource?: string;
   /**
    * The user's original message list, immutable for the hook. Plugins
    * may snapshot or compare against this but MUST NOT mutate it.

package/src/live-voice/__tests__/live-voice-vad.test.ts

@@ -660,7 +660,7 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) => {},
+      }): Promise<string> => "",
     );
     const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
       options.onAudioChunk(makeTtsChunk("assistant audio"));
@@ -699,9 +699,9 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) =>
-        new Promise<void>((resolve) => {
-          args.signal.addEventListener("abort", () => resolve(), {
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          args.signal.addEventListener("abort", () => resolve(""), {
             once: true,
           });
         }),
@@ -739,7 +739,7 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) => {},
+      }): Promise<string> => "",
     );
     const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
       options.onAudioChunk(makeTtsChunk("assistant audio"));
@@ -789,7 +789,7 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) => {},
+      }): Promise<string> => "",
     );
     const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
       options.onAudioChunk(makeTtsChunk("assistant audio"));
@@ -821,7 +821,7 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) => {},
+      }): Promise<string> => "",
     );
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
       callbacks ??= options.callbacks;
@@ -873,7 +873,7 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) => {},
+      }): Promise<string> => "",
     );
     // Hold the interrupted turn's teardown open. Its partial (completed tool
     // calls) is only in forked history once the teardown settles, so the fork
@@ -922,7 +922,7 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) => {},
+      }): Promise<string> => "",
     );
     // A teardown that never settles: the bounded wait times out, and the fork
     // must be skipped rather than snapshot history that may still be missing the
@@ -964,7 +964,7 @@ describe("LiveVoiceSession server VAD", () => {
         objective: string;
         label: string;
         signal: AbortSignal;
-      }) => {},
+      }): Promise<string> => "",
     );
     // Never resolves: the detach is parked in the teardown wait until the stop
     // aborts it.
@@ -1002,6 +1002,392 @@ describe("LiveVoiceSession server VAD", () => {
     expect(spawnBackgroundContinuation).not.toHaveBeenCalled();
   });
 
+  // A startVoiceTurn stub that keeps the first turn "thinking" (so a barge-in
+  // can land on it) but auto-completes every later turn so the single-turn lock
+  // frees for the next utterance. Records each turn's options for inspection.
+  function makeResurfaceTurnStarter(): {
+    startVoiceTurn: LiveVoiceTurnStarter;
+    calls: VoiceTurnOptions[];
+  } {
+    const calls: VoiceTurnOptions[] = [];
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      calls.push(options);
+      if (options.content !== "first question") {
+        options.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+        options.callbacks?.message_complete?.(makeMessageComplete());
+      }
+      return { turnId: `bridge-turn-${calls.length}`, abort: mock() };
+    });
+    return { startVoiceTurn, calls };
+  }
+
+  test("voice-duplex-handoff on: a completed continuation's result folds into the next turn's control prompt", async () => {
+    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+    // Control the continuation's resolution so we know exactly when its result
+    // is stashed relative to the turns we inspect.
+    let resolveContinuation: ((result: string) => void) | undefined;
+    const spawnBackgroundContinuation = mock(
+      (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          resolveContinuation = resolve;
+        }),
+    );
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+    const { frames, session } = createHarness({
+      finals: [
+        "first question",
+        "second question",
+        "third question",
+        "fourth question",
+      ],
+      startVoiceTurn,
+      streamTtsAudio,
+      spawnBackgroundContinuation,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    // Barge in during thinking: turn 1 is cancelled and its continuation spawns
+    // (but has not resolved). The barge-in follow-up turn launches meanwhile,
+    // carrying the merge note but no continuation result yet.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => resolveContinuation !== undefined);
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+    const followUp = calls.find((c) => c.content === "second question");
+    expect(followUp?.voiceControlPrompt).toContain("interrupted");
+    expect(followUp?.voiceControlPrompt).not.toContain("THE_RESULT");
+
+    // The continuation finishes; its answer is stashed for the next turn.
+    resolveContinuation?.("THE_RESULT");
+    await flushAsyncCallbacks();
+
+    // The next turn the user starts folds the continuation's answer in as
+    // context (never spoken on its own).
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const resurfaced = calls.find((c) => c.content === "third question");
+    expect(resurfaced?.voiceControlPrompt).toContain("THE_RESULT");
+    expect(resurfaced?.voiceControlPrompt).toContain("background");
+
+    // Consume-once: a later turn does not repeat it.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "fourth question"));
+    const later = calls.find((c) => c.content === "fourth question");
+    expect(later?.voiceControlPrompt).not.toContain("THE_RESULT");
+  });
+
+  test("voice-duplex-handoff on: a client interrupt drops a stashed continuation result", async () => {
+    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+    let resolveContinuation: ((result: string) => void) | undefined;
+    const spawnBackgroundContinuation = mock(
+      (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          resolveContinuation = resolve;
+        }),
+    );
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+    // The barge-in utterance transcribes to nothing, so no follow-up turn
+    // consumes the stash before the interrupt lands.
+    const { frames, session } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio,
+      spawnBackgroundContinuation,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => resolveContinuation !== undefined);
+
+    // The continuation finishes and stashes its result...
+    resolveContinuation?.("THE_RESULT");
+    await flushAsyncCallbacks();
+
+    // ...but a client interrupt is a hard stop that drops it.
+    await session.handleClientFrame({ type: "interrupt" });
+    await flushAsyncCallbacks();
+
+    // The next turn carries no resurfaced result.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const later = calls.find((c) => c.content === "third question");
+    expect(later?.voiceControlPrompt).not.toContain("THE_RESULT");
+  });
+
+  test("voice-duplex-handoff on: an empty continuation result adds no context to the next turn", async () => {
+    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+    // Continuation ends with no answer text (e.g. it stopped on a tool call):
+    // there is nothing to fold in.
+    const spawnBackgroundContinuation = mock(
+      async (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> => "",
+    );
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+    const { frames, session } = createHarness({
+      finals: ["first question", "second question", "third question"],
+      startVoiceTurn,
+      streamTtsAudio,
+      spawnBackgroundContinuation,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => spawnBackgroundContinuation.mock.calls.length === 1);
+    // Let the barge-in follow-up turn launch and complete before the next
+    // utterance, so the follow-on turn forms cleanly.
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+    await flushAsyncCallbacks();
+
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const later = calls.find((c) => c.content === "third question");
+    expect(later?.voiceControlPrompt).not.toContain("background you finished");
+  });
+
+  test("voice-duplex-handoff on: a newer continuation's result survives an older one finishing later", async () => {
+    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+    // Capture each continuation's resolver in spawn (detach) order.
+    const resolvers: Array<(result: string) => void> = [];
+    const spawnBackgroundContinuation = mock(
+      (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          resolvers.push(resolve);
+        }),
+    );
+    // Keep the first two turns "thinking" so both can be barged; auto-complete
+    // the rest so the lock frees for later utterances.
+    const calls: VoiceTurnOptions[] = [];
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      calls.push(options);
+      if (
+        options.content !== "first question" &&
+        options.content !== "second question"
+      ) {
+        options.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+        options.callbacks?.message_complete?.(makeMessageComplete());
+      }
+      return { turnId: `bridge-turn-${calls.length}`, abort: mock() };
+    });
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+    const { frames, session } = createHarness({
+      finals: [
+        "first question",
+        "second question",
+        "third question",
+        "fourth question",
+      ],
+      startVoiceTurn,
+      streamTtsAudio,
+      spawnBackgroundContinuation,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    // Barge #1 detaches the older continuation; its follow-up turn stays thinking
+    // so barge #2 can detach the newer continuation.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    await waitFor(() => resolvers.length === 2);
+
+    // The newer continuation finishes first, then the older one finishes late.
+    // The sequence guard keeps the newer result regardless of completion order.
+    resolvers[1]?.("NEWER_RESULT");
+    resolvers[0]?.("OLDER_RESULT");
+    await flushAsyncCallbacks();
+
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "fourth question"));
+    const resurfaced = calls.find((c) => c.content === "fourth question");
+    expect(resurfaced?.voiceControlPrompt).toContain("NEWER_RESULT");
+    expect(resurfaced?.voiceControlPrompt).not.toContain("OLDER_RESULT");
+  });
+
+  test("voice-duplex-handoff on: a rapid second barge-in invalidates a first continuation that finishes after it", async () => {
+    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+    const resolvers: Array<(result: string) => void> = [];
+    const spawnBackgroundContinuation = mock(
+      (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          resolvers.push(resolve);
+        }),
+    );
+    const calls: VoiceTurnOptions[] = [];
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      calls.push(options);
+      if (
+        options.content !== "first question" &&
+        options.content !== "second question"
+      ) {
+        options.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+        options.callbacks?.message_complete?.(makeMessageComplete());
+      }
+      return { turnId: `bridge-turn-${calls.length}`, abort: mock() };
+    });
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+    const { frames, session } = createHarness({
+      finals: [
+        "first question",
+        "second question",
+        "third question",
+        "fourth question",
+      ],
+      startVoiceTurn,
+      streamTtsAudio,
+      spawnBackgroundContinuation,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    // Barge #1 detaches continuation A (older); its follow-up turn stays thinking
+    // so barge #2 can land on it.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => resolvers.length === 1);
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+    // Barge #2 is a rapid second interruption: it bumps the sequence
+    // synchronously, so A is invalidated even before barge #2's own async detach
+    // runs.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    // A finishes AFTER barge #2 and must be rejected. The newer continuation is
+    // left pending so it can't mask the bug by superseding A itself.
+    resolvers[0]?.("OLDER_RESULT");
+    await flushAsyncCallbacks();
+
+    // A later turn carries no stale older result.
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "fourth question"));
+    const resurfaced = calls.find((c) => c.content === "fourth question");
+    expect(resurfaced?.voiceControlPrompt).not.toContain("OLDER_RESULT");
+    expect(resurfaced?.voiceControlPrompt).not.toContain(
+      "background you finished",
+    );
+
+    // Cleanup the still-pending newer continuation.
+    await waitFor(() => resolvers.length === 2);
+    resolvers[1]?.("");
+  });
+
+  test("voice-duplex-handoff on: a new barge-in drops an already-stashed continuation result", async () => {
+    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+    const resolvers: Array<(result: string) => void> = [];
+    const spawnBackgroundContinuation = mock(
+      (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          resolvers.push(resolve);
+        }),
+    );
+    const calls: VoiceTurnOptions[] = [];
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      calls.push(options);
+      if (
+        options.content !== "first question" &&
+        options.content !== "second question"
+      ) {
+        options.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+        options.callbacks?.message_complete?.(makeMessageComplete());
+      }
+      return { turnId: `bridge-turn-${calls.length}`, abort: mock() };
+    });
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+    const { frames, session } = createHarness({
+      finals: [
+        "first question",
+        "second question",
+        "third question",
+        "fourth question",
+      ],
+      startVoiceTurn,
+      streamTtsAudio,
+      spawnBackgroundContinuation,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    // Barge #1 detaches continuation A; it finishes and stashes while it is the
+    // latest detach.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+    await waitFor(() => resolvers.length === 1);
+    resolvers[0]?.("A_RESULT");
+    await flushAsyncCallbacks();
+
+    // Barge #2 is a fresh interruption: it must drop A's already-stashed result
+    // (and detach the newer continuation).
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    await waitFor(() => resolvers.length === 2);
+
+    // The barge #2 follow-up turn carries no stale A result.
+    const followUp = calls.find((c) => c.content === "third question");
+    expect(followUp?.voiceControlPrompt).not.toContain("A_RESULT");
+
+    // Cleanup the still-pending newer continuation.
+    resolvers[1]?.("");
+  });
+
   test("a late assistant_text_delta after a thinking barge-in never reaches the client", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const abort = mock();

package/src/live-voice/live-voice-session.ts

@@ -132,16 +132,17 @@ export type LiveVoiceTtsStreamer = (
 ) => Promise<LiveVoiceTtsResult>;
 
 // Runs an interrupted live-voice turn to completion on a background subagent
-// (true-duplex handoff, gated behind voice-duplex-handoff). The run is silent
-// (no parent notification) until the resurface flow lands, and aborts when
-// `signal` fires. Injected for testability; the factory wires the real
-// SubagentManager-backed implementation.
+// (true-duplex handoff, gated behind voice-duplex-handoff). The run stays silent
+// (no parent notification, never spoken unprompted); it RESOLVES with the
+// continuation's final answer text, which the session folds into the next turn
+// the user starts as context. Aborts when `signal` fires (rejecting). Injected
+// for testability; the factory wires the real SubagentManager-backed impl.
 export type LiveVoiceBackgroundContinuationSpawner = (args: {
   parentConversationId: string;
   objective: string;
   label: string;
   signal: AbortSignal;
-}) => Promise<void>;
+}) => Promise<string>;
 
 export interface LiveVoiceSessionArchiveAudioInput {
   messageId?: string | null;
@@ -314,6 +315,11 @@ interface ActiveAssistantTurn {
   // merges it with this turn's utterance instead of treating that utterance as
   // a fresh follow-up. Null for an ordinary (non-barge-in) turn.
   interruptedRequest: string | null;
+  // The completed background continuation's answer (voice-duplex-handoff),
+  // folded into this turn's control prompt as context so the model can deliver
+  // or reference it in reply to the user, without ever speaking it unprompted.
+  // Null when no continuation result is pending for this turn.
+  continuationResult: string | null;
   // Triage-and-escalate (Voice Mode): the front-door leg emitted [ESCALATE]
   // and the strong "escalated" leg has taken over this same turn. Guards the
   // front-door leg's trailing completion from finalizing the turn, and makes
@@ -351,6 +357,31 @@ function buildInterruptionMergeNote(interruptedRequest: string): string {
   return `The user interrupted your previous, unfinished reply. Their earlier request was: "${interruptedRequest}". Treat their current message as a continuation of that request and address both together, or stay silent if they only want you to stop.`;
 }
 
+// System-level guidance appended to the NEXT turn's control prompt after a
+// background continuation (voice-duplex-handoff) finished the reply the user
+// interrupted. Folds the completed answer in as context so the model can
+// deliver or reference it in reply to the user; it must never be spoken
+// unprompted (live-voice is non-interactive, JARVIS-1291). Reaches the model
+// only; it is not a user message and never renders as a transcript bubble.
+function buildResurfaceContextNote(continuationResult: string): string {
+  return `Earlier the user interrupted you, and in the background you finished the reply they cut off. What you worked out was: "${continuationResult}". If their current message relates to it, use it to answer; otherwise you may briefly offer it or leave it aside, and do not repeat it verbatim if it no longer fits.`;
+}
+
+// Assemble a turn's model-facing control prompt: the base live-voice rules plus
+// any pending barge-in merge context and/or completed-continuation context. A
+// turn can carry both (a barge-in follow-up that also has a continuation result
+// waiting); the notes are model-only and never render as user bubbles.
+function buildVoiceControlPrompt(turn: ActiveAssistantTurn): string {
+  let prompt = LIVE_VOICE_CONTROL_PROMPT;
+  if (turn.interruptedRequest) {
+    prompt = `${prompt}\n\n${buildInterruptionMergeNote(turn.interruptedRequest)}`;
+  }
+  if (turn.continuationResult) {
+    prompt = `${prompt}\n\n${buildResurfaceContextNote(turn.continuationResult)}`;
+  }
+  return prompt;
+}
+
 // Objective handed to the background subagent that continues a barged-in turn.
 // The subagent forks the live conversation, so it already sees the interrupted
 // turn's completed tool calls in history and resumes from there. The request
@@ -403,6 +434,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // before its async teardown; if it has changed by the time the detach would
   // spawn, a stop landed during the gap and the continuation is not started.
   private detachStopGeneration = 0;
+  // Bumped SYNCHRONOUSLY at each barge-in (in barge order), before the async
+  // detach runs. Only the latest-started detach (detachSeq === detachSequence)
+  // may populate the pending result, so once a newer barge-in starts, an older
+  // continuation completing (before OR after it) can't surface a stale answer.
+  private detachSequence = 0;
   private readonly emitMetrics: boolean;
   private readonly metrics: LiveVoiceMetricsCollector;
   private readonly createTurnId: () => string;
@@ -444,6 +480,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // Consumed (and cleared) when that turn launches; cleared if the barge-in
   // utterance is discarded, so it can never attach to a later, unrelated turn.
   private pendingInterruptedRequest: string | null = null;
+  // Set when a background continuation (voice-duplex-handoff) finishes the reply
+  // a barge-in cut off: its final answer, folded into the next turn the user
+  // starts as context. Consumed (and cleared) when that turn launches; cleared
+  // on a hard stop (abortDetachedRuns) so a stale result never surfaces later.
+  private pendingContinuationResult: string | null = null;
   private readonly maxPendingAudioBytes: number;
   // Set on VAD speech onset; consumed when the first speech chunk is routed
   // to an utterance so the metric lands on the right turn.
@@ -1104,6 +1145,17 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       .trim();
     this.pendingInterruptedRequest =
       interruptedRequest.length > 0 ? interruptedRequest : null;
+    // A fresh interruption supersedes any already-stashed continuation result:
+    // drop it synchronously here so the barge-in follow-up (or any later) turn
+    // can't consume an older answer before this barge-in's own continuation
+    // completes. Cleared even when no continuation ultimately detaches.
+    this.pendingContinuationResult = null;
+    // Order this barge-in among concurrent detaches SYNCHRONOUSLY, in barge
+    // order — the actual detach runs after an async teardown chain, and those
+    // chains can interleave, so bumping there could assign sequences out of
+    // order and let an older continuation re-stash. A higher sequence here
+    // immediately invalidates every earlier still-running continuation.
+    const detachSeq = ++this.detachSequence;
     turn.abortController.abort();
     this.metrics.markBargeIn(turn.turnId);
     // Capture the interrupted turn's teardown promise synchronously, before the
@@ -1128,7 +1180,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // Keep the interrupted turn's work alive on a background subagent
       // (voice-duplex-handoff); the detach waits for its teardown to settle the
       // partial into history before forking.
-      this.detachInterruptedTurn(turn, stopGeneration, teardownWait);
+      this.detachInterruptedTurn(turn, stopGeneration, teardownWait, detachSeq);
     })().catch(() => {});
   }
 
@@ -1144,6 +1196,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     turn: ActiveAssistantTurn,
     stopGeneration: number,
     teardownWait: Promise<void> | undefined,
+    detachSeq: number,
   ): void {
     const spawn = this.spawnBackgroundContinuation;
     if (
@@ -1204,12 +1257,28 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         if (controller.signal.aborted || this.isClosed) {
           return;
         }
-        await spawn({
+        const resultText = await spawn({
           parentConversationId: this.conversationId,
           objective: buildDuplexContinuationObjective(interruptedRequest),
           label: `voice-continue-${turn.turnId}`,
           signal: controller.signal,
         });
+        // Fold the completed continuation's answer into the next turn the user
+        // starts (never spoken unprompted). Re-check the stop guards after the
+        // await: an interrupt/close during the run must suppress it. Only the
+        // latest-started detach may populate the result, so once a newer
+        // barge-in has started, an older continuation completing (before or
+        // after it, empty or not) can't surface a stale answer. Only non-empty
+        // text is actually surfaced.
+        if (
+          !controller.signal.aborted &&
+          !this.isClosed &&
+          this.detachStopGeneration === stopGeneration &&
+          detachSeq === this.detachSequence
+        ) {
+          const answer = resultText.trim();
+          this.pendingContinuationResult = answer.length > 0 ? answer : null;
+        }
       } catch (err) {
         // A stop/interrupt aborts via the signal; that rejection is expected.
         if (!controller.signal.aborted) {
@@ -1235,6 +1304,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       controller.abort();
     }
     this.detachControllers.clear();
+    // A hard stop also drops any completed continuation's result still waiting
+    // to fold into the next turn, so it can't surface after the user reset.
+    this.pendingContinuationResult = null;
   }
 
   // VAD closed the utterance — the analog of ptt_release: emit
@@ -1747,11 +1819,16 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
-    // Consume any pending barge-in merge context for this turn (one barge-in
-    // feeds exactly the next launched turn).
+    // Consume any pending barge-in merge context and completed-continuation
+    // context for this turn (each feeds exactly the next launched turn).
     const interruptedRequest = this.pendingInterruptedRequest;
     this.pendingInterruptedRequest = null;
-    await this.launchAssistantTurn(utterance, content, { interruptedRequest });
+    const continuationResult = this.pendingContinuationResult;
+    this.pendingContinuationResult = null;
+    await this.launchAssistantTurn(utterance, content, {
+      interruptedRequest,
+      continuationResult,
+    });
   }
 
   // Build the ActiveAssistantTurn for a released utterance and drive its model
@@ -1763,6 +1840,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // Set on a barge-in follow-up turn: the interrupted request's transcript,
       // appended to the turn's control prompt so the model merges the two.
       interruptedRequest?: string | null;
+      // Set when a background continuation finished the interrupted reply: its
+      // answer, appended to the turn's control prompt as context.
+      continuationResult?: string | null;
     },
   ): Promise<void> {
     utterance.assistantTurnStarted = true;
@@ -1781,6 +1861,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       ttsAudioStarted: false,
       finalized: false,
       interruptedRequest: opts?.interruptedRequest ?? null,
+      continuationResult: opts?.continuationResult ?? null,
       escalationHandedOff: false,
       ttsBuffer: "",
       ttsSegmentEnqueued: false,
@@ -1913,11 +1994,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         assistantMessageChannel: "vellum",
         userMessageInterface: "macos",
         assistantMessageInterface: "macos",
-        voiceControlPrompt: activeTurn.interruptedRequest
-          ? `${LIVE_VOICE_CONTROL_PROMPT}\n\n${buildInterruptionMergeNote(
-              activeTurn.interruptedRequest,
-            )}`
-          : LIVE_VOICE_CONTROL_PROMPT,
+        voiceControlPrompt: buildVoiceControlPrompt(activeTurn),
         content: leg.content,
         isInbound: true,
         signal: activeTurn.abortController.signal,
@@ -2586,6 +2663,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // finalizes through finalizeAssistantTurn, not here, so this never clears a
     // request that the barge-in follow-up turn is still about to consume.
     this.pendingInterruptedRequest = null;
+    // `pendingContinuationResult` is deliberately NOT cleared here. Unlike the
+    // merge context (bound to the immediate barge-in follow-up), a completed
+    // continuation's answer targets the next REAL turn, and hands-free server-VAD
+    // routinely discards noise/empty-transcript utterances between turns; wiping
+    // it on each such discard would frequently drop a valid result before the
+    // user's next question. It is bounded instead by consume-once, the hard-stop
+    // clear (abortDetachedRuns), and the model's "use only if relevant" framing.
     utterance.completed = true;
     const turnId = utterance.turnId;
     if (!turnId) {
@@ -2914,21 +2998,22 @@ export function createLiveVoiceSession(
 // (which include the interrupted turn's completed tool calls after teardown),
 // so it resumes without repeating them. Uses spawnAndAwait (synchronous mode)
 // so the terminal parent-notification is skipped — the continuation stays
-// silent until the resurface flow lands, and this call ignores its result. The
-// `signal` aborts the child on a stop/interrupt.
+// silent (never spoken unprompted); its final answer is RETURNED so the session
+// can fold it into the next turn the user starts. The `signal` aborts the child
+// on a stop/interrupt (spawnAndAwait then rejects).
 async function defaultSpawnBackgroundContinuation(args: {
   parentConversationId: string;
   objective: string;
   label: string;
   signal: AbortSignal;
-}): Promise<void> {
+}): Promise<string> {
   const parentConversation = findConversation(args.parentConversationId);
   if (!parentConversation) {
     throw new Error(
       `Cannot detach interrupted voice turn: conversation ${args.parentConversationId} is not resident.`,
     );
   }
-  await getSubagentManager().spawnAndAwait(
+  return await getSubagentManager().spawnAndAwait(
     {
       parentConversationId: args.parentConversationId,
       label: args.label,
@@ -2938,7 +3023,8 @@ async function defaultSpawnBackgroundContinuation(args: {
       parentMessages: [...parentConversation.messages],
       parentSystemPrompt: parentConversation.getCurrentSystemPrompt(),
     },
-    // No client-facing events: the continuation is silent until resurface.
+    // No client-facing events: the continuation is silent; its result is folded
+    // into the next user turn as context, never spoken on its own.
     () => {},
     { signal: args.signal },
   );

package/src/persistence/conversation-crud.ts

@@ -236,17 +236,6 @@ export const messageMetadataSchema = z
      * treat message text as organic user input.
      */
     hidden: z.boolean().optional(),
-    /**
-     * How the send was initiated when the user message was sent on the
-     * user's behalf by the UI rather than typed by hand (`body.source` on
-     * `POST /v1/messages`). Current value: `"nav_redirect"` — a navigation
-     * shortcut redirected the user into chat with a pre-filled message.
-     * Read back by turn telemetry (`turn-events-store`) so analytics can
-     * separate UI-initiated turns from hand-typed ones, and by the queue
-     * drain to steer the turn. Kept as a plain string so new sources never
-     * fail metadata validation. Absent on hand-typed messages.
-     */
-    userMessageSource: z.string().optional(),
     /**
      * Discriminates daemon-authored rows from ordinary turns.
      * `"system_card"` marks pre-composed status cards (the /compact, /clean,
@@ -310,19 +299,6 @@ export function isHiddenMessageMetadata(
   return metadata?.hidden === true;
 }
 
-/**
- * Shared accessor for the send-source tag on user-message metadata (see the
- * `userMessageSource` field on {@link messageMetadataSchema}). Returns the
- * tag (e.g. `"nav_redirect"`) or undefined when the message was typed by
- * hand or predates the field.
- */
-export function getUserMessageSourceMetadata(
-  metadata: Record<string, unknown> | null | undefined,
-): string | undefined {
-  const source = metadata?.userMessageSource;
-  return typeof source === "string" && source.length > 0 ? source : undefined;
-}
-
 /**
  * `messageKind` value marking a daemon-authored system card — a pre-composed
  * status reply (the /compact, /clean, and summarize-up-to result cards) that

package/src/runtime/migrations/__tests__/vbundle-streaming-importer.test.ts

@@ -787,8 +787,19 @@ describe("streamCommitImport — memory ceiling", () => {
       // MB archive, RSS would spike by at least 100 MB; a streaming
       // importer's per-entry working set is bounded by ~one tar entry's
       // internal buffers (a few MB).
-      const baselineRss = process.memoryUsage().rss;
-      let peakRss = baselineRss;
+      //
+      // Bun 1.3.11 can throw `SystemError: Failed to get memory usage` from the
+      // underlying syscall; guard every sample so a spurious failure doesn't
+      // flake the run — a skipped sample just keeps the prior peak.
+      const sampleRss = (): number | null => {
+        try {
+          return process.memoryUsage().rss;
+        } catch {
+          return null;
+        }
+      };
+      const baselineRss = sampleRss();
+      let peakRss = baselineRss ?? 0;
       let progressCount = 0;
 
       const result = await streamCommitImport({
@@ -797,8 +808,8 @@ describe("streamCommitImport — memory ceiling", () => {
         workspaceDir,
         onProgress: () => {
           progressCount += 1;
-          const cur = process.memoryUsage().rss;
-          if (cur > peakRss) peakRss = cur;
+          const cur = sampleRss();
+          if (cur !== null && cur > peakRss) peakRss = cur;
         },
       });
 
@@ -810,7 +821,7 @@ describe("streamCommitImport — memory ceiling", () => {
       // The 64 MB delta bound is a rough guard proving "it doesn't buffer
       // the whole bundle" — if the importer were accumulating the 100 MB
       // archive in memory, RSS would jump well past this threshold.
-      const delta = peakRss - baselineRss;
+      const delta = peakRss - (baselineRss ?? 0);
       expect(delta).toBeLessThan(64 * 1024 * 1024);
     } finally {
       try {

package/src/runtime/routes/conversation-routes.ts

@@ -1372,11 +1372,6 @@ export async function handleSendMessage(
     // handoff to prime a proactive assistant greeting without showing the
     // triggering user message. Honored on the standard send path only.
     hidden?: boolean;
-    // How the send was initiated when it wasn't typed by hand — e.g.
-    // "nav_redirect" for UI shortcuts that send on the user's behalf.
-    // Persisted as `metadata.userMessageSource` (analytics attribution) and
-    // threaded to the agent loop as `messageSource` (per-turn steering).
-    source?: string;
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
@@ -1420,12 +1415,6 @@ export async function handleSendMessage(
       : undefined;
   const clientMessageId =
     typeof body.clientMessageId === "string" ? body.clientMessageId : undefined;
-  // Normalized send-source tag ("nav_redirect", ...). The body is not
-  // runtime-validated, so guard the type before persisting/threading it.
-  const messageSource =
-    typeof body.source === "string" && body.source.length > 0
-      ? body.source
-      : undefined;
   const requestedInferenceProfile =
     typeof body.inferenceProfile === "string"
       ? body.inferenceProfile
@@ -2085,10 +2074,6 @@ export async function handleSendMessage(
           // hidden send that lands mid-turn stays hidden when drained —
           // the drain path persists this metadata and skips the echo.
           ...(body.hidden === true ? { hidden: true } : {}),
-          // Carry the send-source tag through the queue the same way — the
-          // drain path persists this metadata and reads it back for the
-          // turn's `messageSource` steering.
-          ...(messageSource ? { userMessageSource: messageSource } : {}),
         },
         clientMetadata,
       ),
@@ -2491,11 +2476,10 @@ export async function handleSendMessage(
     attachments,
     requestId,
     metadata: withClientMetadata(
-      body.automated === true || body.hidden === true || messageSource
+      body.automated === true || body.hidden === true
         ? {
             ...(body.automated === true ? { automated: true } : {}),
             ...(body.hidden === true ? { hidden: true } : {}),
-            ...(messageSource ? { userMessageSource: messageSource } : {}),
           }
         : undefined,
       clientMetadata,
@@ -2545,7 +2529,6 @@ export async function handleSendMessage(
       isInteractive,
       isUserMessage: true,
       ...(body.hidden === true ? { isHiddenPrompt: true } : {}),
-      ...(messageSource ? { messageSource } : {}),
     })
     .catch((err) => {
       log.error(
@@ -3022,12 +3005,6 @@ export const ROUTES: RouteDefinition[] = [
         .describe(
           "When true, persist the user message but suppress it from the UI transcript (it stays in LLM-side history and still drives the turn). Used for machine signals the user never typed (proactive-greeting priming, channel-setup wizard close). Suppression covers the queued path too: a hidden send that lands mid-turn returns { queued: true, requestId } but never appears in list-messages queued snapshots, emits no echo, and does not supersede pending interactions. Honored on the standard send path only — slash-command content bypasses it.",
         ),
-      source: z
-        .string()
-        .optional()
-        .describe(
-          'How the send was initiated when the message was sent on the user\'s behalf by the UI rather than typed by hand. Current value: "nav_redirect" (a navigation shortcut redirected the user into chat with a pre-filled message). Persisted onto the message metadata for analytics attribution and used to steer the assistant toward a brief, concrete reply. Omit for messages the user typed.',
-        ),
       onboarding: z
         .object({
           tools: z.array(z.string()),

package/src/runtime/routes/identity-routes.ts

@@ -33,16 +33,37 @@ interface MemoryInfo {
   maxMb: number;
 }
 
+/**
+ * Sample this process's resident set size (RSS) in bytes, returning `null` when
+ * the reading fails.
+ *
+ * Bun 1.3.11 can throw `SystemError: Failed to get memory usage, errno: 2` from
+ * the underlying getrusage syscall. The health payload is best-effort, so a
+ * failed sample must never propagate and turn the liveness probe into a 500 —
+ * fall back to `null` and let the caller substitute an alternative source.
+ */
+function sampleProcessRssBytes(): number | null {
+  try {
+    return process.memoryUsage().rss;
+  } catch {
+    return null;
+  }
+}
+
 function getMemoryInfo(): MemoryInfo {
   const bytesToMb = (b: number) => Math.round((b / (1024 * 1024)) * 100) / 100;
   // In platform-managed mode the daemon shares its Node process with whatever
   // the container is doing as a whole; `process.memoryUsage().rss` only sees
   // this process's resident set, which understates the container footprint
   // operators care about. Read the cgroup usage file directly so /v1/health
-  // matches what the StatefulSet's memory limit is enforced against.
+  // matches what the StatefulSet's memory limit is enforced against. When RSS
+  // can't be sampled, fall back to the cgroup usage (if any) before reporting 0
+  // — the metric is best-effort and must never fail the probe.
   const currentBytes =
     (getIsPlatform() ? getContainerMemoryUsageBytes() : null) ??
-    process.memoryUsage().rss;
+    sampleProcessRssBytes() ??
+    getContainerMemoryUsageBytes() ??
+    0;
   return {
     currentMb: bytesToMb(currentBytes),
     maxMb: bytesToMb(getContainerMemoryLimitBytes() ?? totalmem()),

package/src/telemetry/turn-events-store.ts

@@ -55,21 +55,6 @@ export interface TurnEvent {
    * and should never appear on a user-message row.
    */
   channelId: string | null;
-  /**
-   * Send-source tag for messages the UI sent on the user's behalf
-   * (`"nav_redirect"` — a navigation shortcut redirected the user into
-   * chat with a pre-filled message). Sourced from
-   * `messages.metadata.userMessageSource`, stamped by `handleSendMessage`
-   * when the request body carries `source`. Null for hand-typed messages
-   * and rows predating the field. Lets activation-funnel analytics
-   * separate UI-initiated turns from organic ones.
-   *
-   * Daemon-side projection only for now: the platform's turn serializer
-   * does not yet accept a `source` wire field, so `turnSource` must not
-   * emit it until the platform serializer lands and the wire sync PR
-   * updates `telemetry-wire.generated.ts` (see `src/telemetry/AGENTS.md`).
-   */
-  source: string | null;
   /**
    * Flexible client metadata stashed under `messages.metadata.client` by
    * the HTTP header middleware. Carries optional `browserFamily`,
@@ -175,11 +160,6 @@ export function queryUnreportedTurnEvents(
       >`json_extract(${messages.metadata}, '$.userMessageChannel')`.as(
         "channel_id",
       ),
-      source: sql<
-        string | null
-      >`json_extract(${messages.metadata}, '$.userMessageSource')`.as(
-        "source",
-      ),
       clientMetadata: sql<
         string | null
       >`json_extract(${messages.metadata}, '$.client')`.as("client_metadata"),