@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.3

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

@@ -61,7 +61,7 @@ function makeStreamingSession(events: AssistantEvent[]): Conversation {
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
     setVoiceCallControlPrompt: () => {},
-    updateClient: () => {},
+    addEventObserver: () => () => {},
     ensureActorScopedHistory: async () => {},
     runAgentLoop: async (
       _content: string,
@@ -116,7 +116,7 @@ function makePersistingStreamingSession(
       turnInterfaceContext = ctx;
     },
     setVoiceCallControlPrompt: () => {},
-    updateClient: () => {},
+    addEventObserver: () => () => {},
     ensureActorScopedHistory: async () => {},
     runAgentLoop: async (
       _content: string,
@@ -254,7 +254,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));
@@ -321,6 +321,51 @@ describe("voice-session-bridge", () => {
     expect(capturedOptions?.callSite).toBe("callAgent");
   });
 
+  test("startVoiceTurn declares the turn interactive so approval prompts are raised for its observer", async () => {
+    // A caller is on the line. If the turn ran non-interactive the permission
+    // checker would deny an approval-gated tool before any prompt existed, and
+    // the bridge's approval observer (auto-resolve for a non-guardian caller, a
+    // real card for the guardian) would never get to decide. Presence is per
+    // turn, so the bridge has to say so.
+    const conversation = createConversation("voice bridge interactive test");
+    const events: AssistantEvent[] = [
+      { type: "message_complete", conversationId: conversation.id },
+    ];
+
+    let capturedOptions: Record<string, unknown> | undefined;
+    const session = {
+      ...makeStreamingSession(events),
+      runAgentLoop: async (
+        _content: string,
+        _messageId: string,
+        options?: Record<string, unknown>,
+      ) => {
+        capturedOptions = options;
+        const onEvent =
+          (options as { onEvent?: (msg: AssistantEvent) => void })?.onEvent ??
+          (() => {});
+        for (const event of events) {
+          onEvent(event);
+        }
+      },
+    } as unknown as Conversation;
+
+    injectDeps(() => session);
+
+    await startVoiceTurn({
+      conversationId: conversation.id,
+      content: "Hello",
+      isInbound: true,
+      onTextDelta: () => {},
+      onComplete: () => {},
+      onError: () => {},
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(capturedOptions?.isInteractive).toBe(true);
+  });
+
   test("external AbortSignal triggers turn abort", async () => {
     const conversation = createConversation("voice bridge signal test");
     let abortCalled = false;
@@ -339,7 +384,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));
@@ -704,13 +749,14 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
-        // Simulate the prompter emitting a confirmation_request via the
-        // updateClient callback (this is how the real prompter works).
+        // Simulate the conversation emitting a confirmation_request to its
+        // event observer (this is how the real conversation fans out).
         clientHandler({
           type: "confirmation_request",
           requestId: "req-voice-1",
@@ -796,8 +842,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -879,8 +926,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -946,8 +994,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1009,8 +1058,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1061,13 +1111,20 @@ describe("voice-session-bridge", () => {
   // broadcast in voice-session-bridge.ts's confirmation_request branch. The
   // fake's handleConfirmationResponse mirrors production's synchronous
   // `interaction_resolved` broadcast so the wire order is observable through
-  // the event hub, which serializes publishes in call order.
+  // the event hub, which serializes publishes in call order. Its `emit`
+  // mirrors a real conversation's: the sink (the hub) delivers first, then
+  // observers run, so the bridge's resolution lands after the request.
   function makeConfirmationOrderingSession(
     conversationId: string,
     requestId: string,
   ): Conversation {
     let clientHandler: (msg: AssistantEvent) => void = () => {};
+    const emit = (msg: AssistantEvent) => {
+      broadcastMessage(msg);
+      clientHandler(msg);
+    };
     return {
+      emit,
       isProcessing: () => false,
       persistUserMessage: async () => ({
         id: "test-msg-id",
@@ -1080,12 +1137,13 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
-        clientHandler({
+        emit({
           type: "confirmation_request",
           requestId,
           toolName: "host_bash",
@@ -1222,8 +1280,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1290,7 +1349,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -1349,7 +1408,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: recordLast("setTurnChannelContext"),
       setTurnInterfaceContext: recordLast("setTurnInterfaceContext"),
       setVoiceCallControlPrompt: recordLast("setVoiceCallControlPrompt"),
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -1391,15 +1450,12 @@ describe("voice-session-bridge", () => {
     expect(session.forcePromptSideEffects).toBe(false);
   });
 
-  test("cleanup on early persistUserMessage throw does not detach prior client sender", async () => {
+  test("cleanup on early persistUserMessage throw does not detach a prior turn's observer", async () => {
     const conversation = createConversation(
       "voice bridge sender detach guard test",
     );
 
-    const updateClientCalls: Array<{
-      callback: unknown;
-      replace: boolean | undefined;
-    }> = [];
+    const addEventObserverCalls: unknown[] = [];
 
     const session = {
       isProcessing: () => false,
@@ -1415,8 +1471,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (callback: unknown, replace?: boolean) => {
-        updateClientCalls.push({ callback, replace });
+      addEventObserver: (observer: unknown) => {
+        addEventObserverCalls.push(observer);
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
@@ -1451,10 +1508,9 @@ describe("voice-session-bridge", () => {
     expect(caught?.message).toBe(
       "persist failed before bridge installed callback",
     );
-    // The bridge never reached its `conversation.updateClient(...)` install
-    // site, so cleanup must not touch updateClient — otherwise it would
-    // detach a sender installed by a prior turn on the same conversation.
-    expect(updateClientCalls).toEqual([]);
+    // The bridge never reached its `conversation.addEventObserver(...)`
+    // install site, so no observer was registered for cleanup to detach.
+    expect(addEventObserverCalls).toEqual([]);
   });
 
   test("pre-aborted signal triggers immediate abort", async () => {
@@ -1475,7 +1531,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));

package/src/acp/session-manager.ts

@@ -1224,9 +1224,14 @@ export class AcpSessionManager {
       );
       return;
     }
+    // The notification turn streams to whoever is watching (the parent's sink is
+    // its client hub), but it is machine-injected with no human asserted to be
+    // present, so it runs non-interactive: a tool that would need approval is
+    // denied rather than left waiting on a prompt nobody may answer.
     const enqueueResult = parentConversation.enqueueMessage({
       content: message,
       metadata: { acpNotification },
+      isInteractive: false,
     });
     if (enqueueResult.queued || enqueueResult.rejected) {
       return;
@@ -1234,7 +1239,9 @@ export class AcpSessionManager {
     parentConversation
       .persistUserMessage({ content: message, metadata: { acpNotification } })
       .then(({ id: messageId }) =>
-        parentConversation.runAgentLoop(message, messageId),
+        parentConversation.runAgentLoop(message, messageId, {
+          isInteractive: false,
+        }),
       )
       .catch((err) => {
         log.error(

package/src/api/surfaces.ts

@@ -488,6 +488,11 @@ export const WorkResultItemSchema = z.object({
   status: tolerantString(),
   tone: WorkResultToneSchema.optional().catch(undefined),
   metadata: recordArray(WorkResultMetadataSchema).optional().catch(undefined),
+  /**
+   * Makes the item row a link. Clients follow an in-app path
+   * (`/assistant/skills/<skillId>?tab=history`) in place and open an http(s)
+   * URL externally; anything else renders as an unlinked row.
+   */
   href: tolerantString(),
 });
 export type WorkResultItem = z.infer<typeof WorkResultItemSchema>;

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

@@ -72,6 +72,7 @@ mock.module("../../persistence/conversation-crud.js", () => ({
 
 import { setConfig } from "../../__tests__/helpers/set-config.js";
 import { ABORT_WATCHDOG_MS } from "../../daemon/abort-watchdog.js";
+import { VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND } from "../../plugin-api/constants.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import {
   CALL_OPENING_MARKER,
@@ -125,7 +126,7 @@ interface FakeConversation {
     metadata?: Record<string, unknown>;
   }) => Promise<{ id: string }>;
   workingDir: string;
-  updateClient: (cb: unknown, reset?: boolean) => void;
+  addEventObserver: (observer: unknown) => () => void;
   handleConfirmationResponse: (
     requestId: string,
     decision: string,
@@ -191,13 +192,15 @@ function makeFakeConversation(opts: {
       opts.onPersist?.(persistCount);
       return { id: `msg-${persistCount}` };
     },
-    // The install (reset falsy) / reset (reset true) pair marks a turn
-    // taking ownership of the conversation vs a turn's cleanup releasing it.
-    updateClient: (cb, reset) => {
-      opts.events?.push(reset ? "client:reset" : "client:install");
-      if (reset !== true) {
-        clientCallback = cb as (msg: unknown) => Promise<void>;
-      }
+    // The install / reset pair marks a turn taking ownership of the
+    // conversation (observer registered) vs a turn's cleanup releasing it
+    // (the returned disposer invoked).
+    addEventObserver: (observer) => {
+      opts.events?.push("client:install");
+      clientCallback = observer as (msg: unknown) => Promise<void>;
+      return () => {
+        opts.events?.push("client:reset");
+      };
     },
     handleConfirmationResponse: (requestId, decision) => {
       confirmationDecisions.push({ requestId, decision });
@@ -213,7 +216,7 @@ function makeFakeConversation(opts: {
     conversation,
     waitForIdleCalls,
     confirmationDecisions,
-    /** Deliver an event the way the conversation would, to the installed handler. */
+    /** Deliver an event the way the conversation would, to the installed observer. */
     emitToClient: async (msg: unknown) => {
       await clientCallback?.(msg);
     },
@@ -360,6 +363,10 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
     // not merely echo-suppressed live.
     const fake = makeFakeConversation({ processing: false });
     fakeConversation = fake.conversation;
+    let runOptions: Record<string, unknown> | undefined;
+    fake.conversation.runAgentLoop = async (...args: unknown[]) => {
+      runOptions = args[2] as Record<string, unknown>;
+    };
 
     await startVoiceTurn({
       ...makeTurnOptions(),
@@ -372,7 +379,11 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
     expect(fake.lastPersistOpts()?.metadata).toEqual({
       voiceSessionTurn: true,
       hidden: true,
+      messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
     });
+    expect(runOptions?.messageKind).toBe(
+      VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+    );
   });
 
   test("the opener prompt is persisted un-hidden (unchanged)", async () => {
@@ -967,7 +978,7 @@ describe("startVoiceTurn prior-turn teardown barrier", () => {
     expect(events).toEqual(["persist", "client:install"]);
 
     // Turn 2 arrives during the teardown window: it must not persist or
-    // install its client callback until turn 1's cleanup has run.
+    // install its event observer until turn 1's cleanup has run.
     const turn2 = startVoiceTurn(
       makeTurnOptions(undefined, "conv-teardown-order"),
     );

package/src/calls/__tests__/voice-triage-escalate.test.ts

@@ -85,6 +85,14 @@ describe("front-door decision rule", () => {
     expect(rule.toLowerCase()).toContain("tool");
   });
 
+  test("escalates when an answer needs personal memory absent from context", () => {
+    expect(rule.toLowerCase()).toContain("saved personal fact");
+    expect(rule.toLowerCase()).toContain("escalate rather than guessing");
+    expect(rule.toLowerCase()).toContain(
+      "personal context that is already present is yours to use directly",
+    );
+  });
+
   test("demands a silent decision — no narrated reasoning in spoken output", () => {
     // Regression: a weak front-door model narrated its triage deliberation
     // aloud ("Context is complete — Alex paused...") before the bridge.

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

@@ -34,6 +34,7 @@ import {
   recordConversationPersistedSeq,
   updateMessageContent,
 } from "../persistence/conversation-crud.js";
+import { VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND } from "../plugin-api/constants.js";
 import { pinnedListeningLanguage } from "../providers/speech-to-text/provider-catalog.js";
 import type { ContentBlock } from "../providers/types.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
@@ -783,11 +784,13 @@ export async function startVoiceTurn(
   // model wakes, but they are not user speech and must not render as a live
   // user bubble. Their echo is suppressed below (parity with
   // `isEchoSuppressedUserMessage` on the text path).
+  const isEscalationContinuation =
+    opts.content === ESCALATION_CONTINUATION_CONTENT;
   const isSyntheticVoicePrompt =
     opts.hiddenSyntheticPrompt === true ||
     opts.content === CALL_OPENING_MARKER ||
     opts.content === CALL_VERIFICATION_COMPLETE_MARKER ||
-    opts.content === ESCALATION_CONTINUATION_CONTENT;
+    isEscalationContinuation;
 
   // The escalation-continuation prompt is a pure internal instruction ("give
   // the full answer now"), not a real utterance and not the sort of scaffolding
@@ -799,8 +802,7 @@ export async function startVoiceTurn(
   // affects client display. A caller whose prompt text is not a fixed sentinel
   // opts into the same treatment with `hiddenSyntheticPrompt`.
   const isHiddenSyntheticPrompt =
-    opts.hiddenSyntheticPrompt === true ||
-    opts.content === ESCALATION_CONTINUATION_CONTENT;
+    opts.hiddenSyntheticPrompt === true || isEscalationContinuation;
 
   // Build the call-control protocol prompt so the model knows how to emit
   // control markers (ASK_GUARDIAN, END_CALL, etc.) and recognize opener turns.
@@ -934,10 +936,10 @@ export async function startVoiceTurn(
   // failed while no concurrent turn held the lock). Paths where this turn
   // LOST the conversation to a concurrent winner must use `restoreTurnState`
   // instead — this reset-to-defaults would clobber the winner's live state.
-  // The client callback is only reset when this turn actually installed it
-  // (tracked via `clientCallbackInstalled`); otherwise cleanup would detach
-  // an active sender installed by a prior turn.
-  let clientCallbackInstalled = false;
+  // The approval observer is only detached when this turn installed it
+  // (`detachApprovalObserver` is set); otherwise cleanup would detach an
+  // observer installed by a prior turn.
+  let detachApprovalObserver: (() => void) | undefined;
   /**
    * Confirmations this voice turn left pending for the user to answer, and the
    * timers that stop them waiting forever.
@@ -976,11 +978,10 @@ export async function startVoiceTurn(
     conversation.setVoiceCallControlPrompt(null);
     conversation.callSessionId = undefined;
     conversation.forcePromptSideEffects = false;
-    if (clientCallbackInstalled) {
-      // Reset the client callback to a no-op so the stale closure doesn't
-      // intercept events from future turns on the same conversation.
-      conversation.updateClient(() => {}, true);
-    }
+    // Detach so the stale closure doesn't act on events from future turns on
+    // the same conversation.
+    detachApprovalObserver?.();
+    detachApprovalObserver = undefined;
   };
 
   const requestId = uuidv7();
@@ -994,6 +995,9 @@ export async function startVoiceTurn(
         // `isVoiceSessionUserMessage` for why the channel fields cannot carry it.
         voiceSessionTurn: true,
         ...(isHiddenSyntheticPrompt ? { hidden: true } : {}),
+        ...(isEscalationContinuation
+          ? { messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND }
+          : {}),
         ...(opts.voiceTelemetry
           ? {
               // Projected onto `TurnTelemetryEvent.client` by
@@ -1245,24 +1249,25 @@ export async function startVoiceTurn(
     publishConversationMessagesChanged(opts.conversationId);
   }
 
-  // Hook into conversation to intercept confirmation_request and secret_request events.
-  // Voice auto-denies/auto-allows/auto-resolves these since there's no interactive UI.
+  // Observe confirmation_request and secret_request events so voice can
+  // auto-deny/auto-allow/auto-resolve them (there is no interactive UI on a
+  // call). Delivery is not this observer's job: the conversation's sink has
+  // already put each event on the wire before the observer sees it, which is
+  // what keeps a resolution's `interaction_resolved` after the request it
+  // answers.
   let lastError: string | null = null;
-  conversation.updateClient(async (msg: AssistantEvent) => {
+  const handleVoiceEvent = async (msg: AssistantEvent): Promise<void> => {
     // The user (or anything else) answered: stop the fallback from firing on a
     // request that is already decided.
     if (msg.type === "interaction_resolved") {
       settleVoiceApproval(msg.requestId);
     }
     if (msg.type === "confirmation_request") {
-      // Broadcast the request BEFORE resolving it: resolution synchronously
-      // broadcasts `interaction_resolved` (handleConfirmationResponse →
-      // prompter → pending-interactions), and attached clients (e.g. the
-      // web app behind a live-voice room) clear their approval card only on
-      // that event — resolving first would put `interaction_resolved`
-      // before `confirmation_request` on the wire, leaving an orphaned card
-      // whose Allow/Deny buttons 404.
-      broadcastMessage(msg);
+      // The request is already on the wire (the sink delivered it before this
+      // observer ran), so a resolution below lands after it: attached clients
+      // (e.g. the web app behind a live-voice room) clear their approval card
+      // only on `interaction_resolved`, and the reverse order would leave an
+      // orphaned card whose Allow/Deny buttons 404.
       if (!isGuardian) {
         // Non-guardian voice callers have no interactive approval UI.
         // The pre-exec gate (tool-approval-handler.ts) handles grant
@@ -1420,9 +1425,15 @@ export async function startVoiceTurn(
       conversation.handleSecretResponse(msg.requestId, undefined, "store");
       return;
     }
-    broadcastMessage(msg);
+  };
+  detachApprovalObserver = conversation.addEventObserver((msg) => {
+    handleVoiceEvent(msg).catch((err) => {
+      log.warn(
+        { turnId, eventType: msg.type, err },
+        "Voice approval observer failed",
+      );
+    });
   });
-  clientCallbackInstalled = true;
 
   // Registered before the agent loop starts so the NEXT turn on this
   // conversation waits for this turn's `finally { cleanup() }` — not just
@@ -1709,11 +1720,19 @@ export async function startVoiceTurn(
         // ordinary call-agent resolution.
         callSite:
           opts.routingLeg === "front-door" ? "voiceFrontDoor" : "callAgent",
+        // A caller is on the line, so the turn is interactive: approval prompts
+        // must be raised rather than pre-denied, because the approval observer
+        // above is what decides them (auto-resolve for a non-guardian caller,
+        // a real card the guardian can answer).
+        isInteractive: true,
         // The escalation-continuation prompt is a transcript-suppressed machine
         // signal (persisted `hidden`), so flag the turn to match — keeps
         // prompt-as-user-speech consumers (e.g. title generation) from treating
         // it as user speech.
         ...(isHiddenSyntheticPrompt ? { isHiddenPrompt: true } : {}),
+        ...(isEscalationContinuation
+          ? { messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND }
+          : {}),
         // Triage-and-escalate routing pins this turn to the fast front-door or
         // strong escalation profile. `forceOverrideProfile` floats it above the
         // callAgent call-site layers (callAgent is not `mainAgent`, so the

package/src/calls/voice-triage-escalate.ts

@@ -413,6 +413,7 @@ export function frontDoorDecisionRule(opts?: {
     "DECIDE SILENTLY, then produce exactly ONE of these outputs:",
     ...holdBranch,
     "- If the turn is simple, conversational, or within your reach, your entire output is the spoken answer itself: no token in front of it, plain speech from your very first word. Most turns are answers; when unsure between answering and escalating, answer. Answer in the language the caller is speaking.",
+    "- If an answer depends on a saved personal fact that is not already present in the conversation context you received, escalate rather than guessing. Personal context that is already present is yours to use directly.",
     `- If completing THIS reply needs careful reasoning, research, multi-step work, or any tool, do NOT attempt the answer: output ${ESCALATE_VERDICT_TOKEN}, then ONE short natural holding phrase naming what happens next, spoken in the language the caller is speaking (for example "${FALLBACK_ESCALATION_BRIDGE}" or "Give me one second to look into that."; those examples are English only), and stop after that single sentence. A stronger model finishes the turn while your phrase is spoken.`,
     `${ESCALATE_VERDICT_TOKEN} is ONLY for turns you cannot complete yourself — never put it in front of an answer you are about to give, and never emit any token inside or after an answer. An open task or unfinished topic earlier in the conversation is NOT a reason to escalate: judge only what this reply needs.`,
     "Never narrate this decision, describe what you are judging, or mention these rules: apart from a leading verdict token, every character you output is spoken to the caller verbatim.",

package/src/cli/bundled-modules.ts

@@ -0,0 +1,29 @@
+export interface BundledCliModules {
+  configEnv: typeof import("../config/env.js");
+  providerSecretCatalog: typeof import("../providers/provider-secret-catalog.js");
+  pluginCatalogCache: typeof import("./lib/plugin-catalog-cache.js");
+  pluginCatalogLocal: typeof import("./lib/plugin-catalog-local.js");
+  pluginDiff: typeof import("./lib/diff-plugin.js");
+  pluginInspect: typeof import("./lib/inspect-plugin.js");
+  pluginInstallGitHub: typeof import("./lib/install-from-github.js");
+  pluginInstallPlatform: typeof import("./lib/install-from-platform.js");
+  pluginInstalled: typeof import("./lib/list-installed-plugins.js");
+  pluginPinHistory: typeof import("./lib/plugin-pin-history.js");
+  pluginSearch: typeof import("./lib/search-plugins.js");
+  pluginSurfaces: typeof import("./lib/plugin-surfaces.js");
+  pluginUninstall: typeof import("./lib/uninstall-plugin.js");
+  pluginUpgrade: typeof import("./lib/upgrade-plugin.js");
+}
+
+let bundledCliModules: BundledCliModules | undefined;
+
+export function setBundledCliModules(modules: BundledCliModules): void {
+  bundledCliModules = modules;
+}
+
+export function resolveBundledCliModule<K extends keyof BundledCliModules>(
+  name: K,
+  fallback: () => BundledCliModules[K],
+): BundledCliModules[K] {
+  return bundledCliModules?.[name] ?? fallback();
+}

package/src/cli/commands/db/repair.ts

@@ -15,7 +15,6 @@
  */
 
 import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
 
 import type { Command } from "commander";
 
@@ -27,8 +26,6 @@ import { integrityCheckStep } from "./repair-step-integrity.js";
 import type { RepairReport, RepairStep, StepResult } from "./repair-steps.js";
 import { formatDurationMs, runRepairSteps } from "./repair-steps.js";
 
-const loadModule = createRequire(import.meta.url);
-
 // ---------------------------------------------------------------------------
 // Step sequence
 // ---------------------------------------------------------------------------
@@ -38,10 +35,9 @@ const loadModule = createRequire(import.meta.url);
  * structural damage surfaces early. Resolved lazily because the backfill
  * step pulls the DB graph.
  */
-function repairSteps(): RepairStep[] {
-  const { conversationBackfillStep } = loadModule(
-    "./repair-step-conversation-backfill.js",
-  ) as typeof import("./repair-step-conversation-backfill.js");
+async function repairSteps(): Promise<RepairStep[]> {
+  const { conversationBackfillStep } =
+    await import("./repair-step-conversation-backfill.js");
   return [integrityCheckStep, conversationBackfillStep];
 }
 
@@ -128,7 +124,7 @@ export function registerDbRepair(parent: Command): void {
 
     const report = await runRepairSteps(
       { dbPath },
-      repairSteps(),
+      await repairSteps(),
       isJson
         ? {}
         : {

package/src/cli/commands/domain.ts

@@ -3,6 +3,7 @@ import { createRequire } from "node:module";
 import type { Command } from "commander";
 
 import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
+import { resolveBundledCliModule } from "../bundled-modules.js";
 import { applyCommandHelp, subcommand } from "../lib/cli-command-help.js";
 import { registerCommand } from "../lib/register-command.js";
 import { getCliLogger } from "../logger.js";
@@ -19,9 +20,11 @@ const log = getCliLogger("domain");
  * synchronously, so there is no place to await a module load.
  */
 function envDomains(): { apexDomain: string; baseDomain: string } {
-  const { getApexDomain, getAssistantDomain } = loadModule(
-    "../../config/env.js",
-  ) as typeof import("../../config/env.js");
+  const { getApexDomain, getAssistantDomain } = resolveBundledCliModule(
+    "configEnv",
+    () =>
+      loadModule("../../config/env.js") as typeof import("../../config/env.js"),
+  );
   return { apexDomain: getApexDomain(), baseDomain: getAssistantDomain() };
 }