@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/live-voice/__tests__/live-voice-agent-turn.test.ts

@@ -10,7 +10,7 @@ import type {
   StreamingTranscriber,
   SttStreamServerEvent,
 } from "../../stt/types.js";
-import { pickAckPhrase } from "../ack-phrases.js";
+import type { VoiceFrontDecider } from "../front-decision.js";
 import {
   LiveVoiceSession,
   type LiveVoiceTtsStreamer,
@@ -97,6 +97,7 @@ function createSessionHarness(
     emitMetrics?: boolean;
     streamTtsAudio?: LiveVoiceTtsStreamer;
     frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
+    frontDecider?: VoiceFrontDecider;
   } = {},
 ) {
   const transcriber =
@@ -121,6 +122,7 @@ function createSessionHarness(
     ...(options.frontModelConfig
       ? { frontModelConfig: options.frontModelConfig }
       : {}),
+    ...(options.frontDecider ? { frontDecider: options.frontDecider } : {}),
   });
 
   return { frames, session, startVoiceTurn, transcriber };
@@ -144,12 +146,80 @@ async function waitFor(
   message = "Timed out waiting for live voice assistant turn condition",
 ): Promise<void> {
   for (let attempt = 0; attempt < 40; attempt += 1) {
-    if (predicate()) return;
+    if (predicate()) {
+      return;
+    }
     await new Promise((resolve) => setTimeout(resolve, 5));
   }
   throw new Error(message);
 }
 
+function createCapturingTurnStarter(): {
+  startVoiceTurn: LiveVoiceTurnStarter;
+  getCallbacks: () => VoiceTurnCallbacks | undefined;
+} {
+  let callbacks: VoiceTurnCallbacks | undefined;
+  const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+    callbacks = options.callbacks;
+    return { turnId: "bridge-turn-1", abort: mock() };
+  });
+  return { startVoiceTurn, getCallbacks: () => callbacks };
+}
+
+function createRecordingTtsStreamer(): {
+  streamTtsAudio: LiveVoiceTtsStreamer;
+  ttsTexts: string[];
+} {
+  const ttsTexts: string[] = [];
+  const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+    ttsTexts.push(options.text);
+    return {
+      provider: "fish-audio" as const,
+      contentType: "audio/pcm",
+      sampleRate: 24_000,
+      chunks: 1,
+      bytes: Buffer.byteLength(options.text),
+    };
+  });
+  return { streamTtsAudio, ttsTexts };
+}
+
+function emitTextDelta(
+  getCallbacks: () => VoiceTurnCallbacks | undefined,
+  text: string,
+): void {
+  getCallbacks()?.assistant_text_delta?.({
+    type: "assistant_text_delta",
+    text,
+    conversationId: "conversation-123",
+  });
+}
+
+function emitMessageComplete(
+  getCallbacks: () => VoiceTurnCallbacks | undefined,
+): void {
+  getCallbacks()?.message_complete?.({
+    type: "message_complete",
+    conversationId: "conversation-123",
+    messageId: "assistant-message-123",
+  });
+}
+
+async function startReleasedTurn(
+  session: LiveVoiceSession,
+  getCallbacks: () => VoiceTurnCallbacks | undefined,
+): Promise<void> {
+  await session.start();
+  await session.handleClientFrame({ type: "ptt_release" });
+  await waitFor(() => getCallbacks() !== undefined);
+}
+
+function assistantDeltaTexts(frames: LiveVoiceServerFrame[]): string[] {
+  return frames.flatMap((frame) =>
+    frame.type === "assistant_text_delta" ? [frame.text] : [],
+  );
+}
+
 describe("LiveVoiceSession assistant turn", () => {
   test("runs final transcripts through the voice bridge and forwards ordered assistant events", async () => {
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
@@ -457,63 +527,19 @@ describe("LiveVoiceSession assistant turn", () => {
 
 describe("LiveVoiceSession tool-use spoken ack", () => {
   const ACK_TIMEOUT_MS = 40;
-  // Acks pass through the same TTS sanitizer as regular segments; each fresh
-  // session's phrase counter starts at 0.
-  const EXPECTED_TOOL_ACK = sanitizeForTts(pickAckPhrase("tool_use", 0)).trim();
-  const EXPECTED_FIRST_DELTA_ACK = sanitizeForTts(
-    pickAckPhrase("first_delta", 0),
-  ).trim();
-
-  function createCapturingTurnStarter(): {
-    startVoiceTurn: LiveVoiceTurnStarter;
-    getCallbacks: () => VoiceTurnCallbacks | undefined;
-  } {
-    let callbacks: VoiceTurnCallbacks | undefined;
-    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
-      callbacks = options.callbacks;
-      return { turnId: "bridge-turn-1", abort: mock() };
-    });
-    return { startVoiceTurn, getCallbacks: () => callbacks };
-  }
-
-  function createRecordingTtsStreamer(): {
-    streamTtsAudio: LiveVoiceTtsStreamer;
-    ttsTexts: string[];
-  } {
-    const ttsTexts: string[] = [];
-    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
-      ttsTexts.push(options.text);
-      return {
-        provider: "fish-audio" as const,
-        contentType: "audio/pcm",
-        sampleRate: 24_000,
-        chunks: 1,
-        bytes: Buffer.byteLength(options.text),
-      };
-    });
-    return { streamTtsAudio, ttsTexts };
-  }
-
-  function emitTextDelta(
-    getCallbacks: () => VoiceTurnCallbacks | undefined,
-    text: string,
-  ): void {
-    getCallbacks()?.assistant_text_delta?.({
-      type: "assistant_text_delta",
-      text,
-      conversationId: "conversation-123",
-    });
-  }
-
-  function emitMessageComplete(
-    getCallbacks: () => VoiceTurnCallbacks | undefined,
-  ): void {
-    getCallbacks()?.message_complete?.({
-      type: "message_complete",
-      conversationId: "conversation-123",
-      messageId: "assistant-message-123",
-    });
-  }
+  // Every ack is front-model-phrased; the generated text passes through the
+  // same TTS sanitizer as regular segments. The stub varies its phrasing by
+  // trigger so the two ack kinds stay distinguishable in assertions.
+  const TOOL_ACK = "Let me look that up.";
+  const FIRST_DELTA_ACK = "Sure — one moment.";
+  const EXPECTED_TOOL_ACK = sanitizeForTts(TOOL_ACK).trim();
+  const EXPECTED_FIRST_DELTA_ACK = sanitizeForTts(FIRST_DELTA_ACK).trim();
+
+  const ackDecider: VoiceFrontDecider = {
+    generateAckText: async (input) =>
+      input.toolName ? TOOL_ACK : FIRST_DELTA_ACK,
+    generateProgressText: async () => null,
+  };
 
   function createAckHarness() {
     const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
@@ -522,19 +548,11 @@ describe("LiveVoiceSession tool-use spoken ack", () => {
       startVoiceTurn,
       streamTtsAudio,
       frontModelConfig: { ackFirstDeltaTimeoutMs: ACK_TIMEOUT_MS },
+      frontDecider: ackDecider,
     });
     return { ...harness, getCallbacks, ttsTexts };
   }
 
-  async function startReleasedTurn(
-    session: LiveVoiceSession,
-    getCallbacks: () => VoiceTurnCallbacks | undefined,
-  ): Promise<void> {
-    await session.start();
-    await session.handleClientFrame({ type: "ptt_release" });
-    await waitFor(() => getCallbacks() !== undefined);
-  }
-
   test("tool_use_start before any delta speaks an immediate tool ack and cancels the timer", async () => {
     const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
 
@@ -590,3 +608,193 @@ describe("LiveVoiceSession tool-use spoken ack", () => {
     expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK, "Hello there."]);
   });
 });
+
+describe("LiveVoiceSession minimize-room marker", () => {
+  function createMarkerHarness() {
+    const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
+    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
+    const harness = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+      // Deltas are emitted immediately in these runs; a long ack budget keeps
+      // filler phrases out of the recorded TTS text.
+      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
+    });
+    return { ...harness, getCallbacks, ttsTexts };
+  }
+
+  /**
+   * Marker-command harness for the leg that can actually put something on
+   * screen: routing fronts every turn with the fast leg, so the front-door
+   * call is scripted to escalate ("[1] Working on it.") and the returned
+   * callbacks drive the ESCALATED leg — the only leg whose completion may
+   * latch `minimizeRequested`.
+   */
+  function createEscalatedMarkerHarness() {
+    let escalatedCallbacks: VoiceTurnCallbacks | undefined;
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      if (options.routingLeg === "front-door") {
+        queueMicrotask(() => {
+          options.callbacks?.assistant_text_delta?.({
+            type: "assistant_text_delta",
+            text: "[1] Working on it.",
+            conversationId: "conversation-123",
+          });
+          options.callbacks?.message_complete?.({
+            type: "message_complete",
+            conversationId: "conversation-123",
+            messageId: "front-door-message",
+          });
+        });
+        return { turnId: "bridge-turn-fd", abort: mock() };
+      }
+      escalatedCallbacks = options.callbacks;
+      return { turnId: "bridge-turn-esc", abort: mock() };
+    });
+    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
+    const harness = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
+    });
+    return {
+      ...harness,
+      getCallbacks: () => escalatedCallbacks,
+      ttsTexts,
+    };
+  }
+
+  test("strips a terminal [-1] from deltas and TTS and emits minimize_room after tts_done", async () => {
+    const { frames, session, getCallbacks, ttsTexts } =
+      createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "hello world. [-1]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "minimize_room"));
+
+    const joined = assistantDeltaTexts(frames).join("");
+    expect(joined).toContain("hello world. ");
+    expect(joined).not.toContain("[-1]");
+    expect(ttsTexts.join(" ")).not.toContain("[-1]");
+    const ttsDoneIndex = frames.findIndex((frame) => frame.type === "tts_done");
+    const minimizeIndex = frames.findIndex(
+      (frame) => frame.type === "minimize_room",
+    );
+    expect(ttsDoneIndex).toBeGreaterThanOrEqual(0);
+    expect(minimizeIndex).toBeGreaterThan(ttsDoneIndex);
+    expect(frames[minimizeIndex]).toMatchObject({
+      type: "minimize_room",
+      turnId: "live-turn-1",
+    });
+    expect(
+      frames.filter((frame) => frame.type === "minimize_room"),
+    ).toHaveLength(1);
+  });
+
+  test("holds a marker split across deltas, never leaks the partial, and still emits", async () => {
+    const { frames, session, getCallbacks, ttsTexts } =
+      createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "One sec, done. [-");
+    await flushAsyncCallbacks();
+    expect(assistantDeltaTexts(frames).join("")).toContain("One sec, done. ");
+
+    emitTextDelta(getCallbacks, "1]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "minimize_room"));
+
+    const joined = assistantDeltaTexts(frames).join("");
+    expect(joined).not.toContain("[-");
+    expect(ttsTexts.join(" ")).not.toContain("[-");
+  });
+
+  test("a mid-reply [-1] (content, not command) is stripped from speech but never minimizes", async () => {
+    const { frames, session, getCallbacks } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "The array [-1] sorts first, then the rest.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toBe(
+      "The array  sorts first, then the rest.",
+    );
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("does not emit minimize_room when the turn is interrupted before drain", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Minimizing now. [-1]");
+    await flushAsyncCallbacks();
+
+    await session.handleClientFrame({ type: "interrupt" });
+    emitMessageComplete(getCallbacks);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("a turn without the marker emits no minimize_room frame", async () => {
+    const { frames, session, getCallbacks } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Hello there.");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toBe("Hello there.");
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("strips a stray [END_CALL] from main-leg deltas and TTS", async () => {
+    const { frames, session, getCallbacks, ttsTexts } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Bye now. [END_CALL]");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toBe("Bye now. ");
+    expect(ttsTexts.join(" ")).not.toContain("[END_CALL]");
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("a held marker-like tail that never completes is emitted at completion", async () => {
+    const { frames, session, getCallbacks } = createEscalatedMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    emitTextDelta(getCallbacks, "Score was [-");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(assistantDeltaTexts(frames).join("")).toContain("Score was [-");
+    expect(frames.some((frame) => frame.type === "minimize_room")).toBe(false);
+  });
+
+  test("holds a guardian-approval marker whose JSON body contains brackets, then strips it whole", async () => {
+    const { frames, session, getCallbacks, ttsTexts } = createMarkerHarness();
+
+    await startReleasedTurn(session, getCallbacks);
+    // The JSON body carries both a "]" inside a string value and a nested
+    // array — neither may terminate the hold or mask the marker's start.
+    emitTextDelta(
+      getCallbacks,
+      'Hold on. [ASK_GUARDIAN_APPROVAL: {"question": "ok]?", "options": ["a", "b"',
+    );
+    await flushAsyncCallbacks();
+    expect(assistantDeltaTexts(frames).join("")).toBe("Hold on. ");
+
+    emitTextDelta(getCallbacks, "]}] Anything else?");
+    emitMessageComplete(getCallbacks);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    const joined = assistantDeltaTexts(frames).join("");
+    expect(joined).not.toContain("ASK_GUARDIAN_APPROVAL");
+    expect(joined).toContain("Anything else?");
+    expect(ttsTexts.join(" ")).not.toContain("ASK_GUARDIAN_APPROVAL");
+  });
+});

package/src/live-voice/__tests__/live-voice-continuation-fork-hydration.test.ts

@@ -0,0 +1,286 @@
+/**
+ * The duplex continuation's fork parent is hydrated under resolved guardian
+ * trust.
+ *
+ * `Conversation.loadFromDb` filters history by the instance's own trust class:
+ * a load with no trust context resolves the fail-closed `unknown` capability
+ * set, which drops memory blocks and forces the in-context compaction summary
+ * to null. `defaultSpawnBackgroundContinuation` snapshots the parent's messages
+ * straight into the fork, so an unstamped load would hand the continuation a
+ * lobotomized view of the very turn it is meant to finish. These tests pin the
+ * ordering (resolve trust → stamp → load) and the restore that keeps the
+ * bridge's per-turn ownership of the parent's trust intact.
+ *
+ * `mock.module` is process-global in Bun and leaks into sibling files that run
+ * later in the same `bun test` invocation, so every stub delegates to the real
+ * implementation unless this file's tests are active (`forkMocksActive`,
+ * toggled in beforeAll/afterAll). Run this file on its own.
+ */
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+import type { Conversation } from "../../daemon/conversation.js";
+import type { TrustContext } from "../../daemon/trust-context-types.js";
+import type { Message } from "../../providers/types.js";
+import type { TrustClass } from "../../runtime/trust-class.js";
+
+let forkMocksActive = false;
+
+// Snapshotted into plain objects NOW, before the stubs register — a module
+// namespace is a live view, so reading the real export after the stub installs
+// would resolve back to the stub (infinite recursion).
+const realConversationStoreModule = {
+  ...(await import("../../daemon/conversation-store.js")),
+};
+const realLocalActorIdentityModule = {
+  ...(await import("../../runtime/local-actor-identity.js")),
+};
+const realLocalPrincipalTrustModule = {
+  ...(await import("../../runtime/local-principal-trust.js")),
+};
+const realSubagentModule = { ...(await import("../../subagent/index.js")) };
+
+const PARENT_CONVERSATION_ID = "conversation-fork-parent";
+const GUARDIAN_PRINCIPAL_ID = "principal-guardian-1";
+
+function textMessage(text: string): Message {
+  return { role: "assistant", content: [{ type: "text", text }] };
+}
+
+/** What a trusted `loadFromDb` puts into the parent's in-memory history. */
+const HYDRATED_MESSAGES: Message[] = [
+  textMessage("persisted-turn"),
+  textMessage("memory-block"),
+];
+
+/**
+ * Stands in for the resident `Conversation` the spawn helper snapshots. Only
+ * the surface `defaultSpawnBackgroundContinuation` touches is modelled, mirroring
+ * the real trust-class bookkeeping: `loadFromDb` records the trust context in
+ * force at the instant it runs and remembers the class it loaded under, and
+ * `ensureActorScopedHistory` reloads only when the current class differs.
+ */
+class FakeParentConversation {
+  trustContext: TrustContext | undefined;
+  /** The instance's trust context as observed inside each `loadFromDb` call. */
+  readonly loadTrustContexts: (TrustContext | undefined)[] = [];
+  private messages: Message[];
+  private loadedHistoryTrustClass: TrustClass | undefined;
+
+  constructor(messages: Message[] = [], loadedAs?: TrustClass) {
+    this.messages = messages;
+    this.loadedHistoryTrustClass = loadedAs;
+  }
+
+  setTrustContext(ctx: TrustContext | null): void {
+    this.trustContext = ctx ?? undefined;
+  }
+
+  getMessages(): Message[] {
+    return this.messages;
+  }
+
+  getCurrentSystemPrompt(): string {
+    return "parent-system-prompt";
+  }
+
+  async ensureActorScopedHistory(): Promise<void> {
+    if (this.loadedHistoryTrustClass === this.trustContext?.trustClass) {
+      return;
+    }
+    await this.loadFromDb();
+  }
+
+  async loadFromDb(): Promise<{
+    rows: never[];
+    rowToHistoryIndex: null;
+  }> {
+    this.loadTrustContexts.push(this.trustContext);
+    this.loadedHistoryTrustClass = this.trustContext?.trustClass;
+    this.messages = [...HYDRATED_MESSAGES];
+    return { rows: [], rowToHistoryIndex: null };
+  }
+}
+
+// -- Mutable stub state -------------------------------------------------------
+
+/** The conversation `getOrCreateConversation` hands back. */
+let parentConversation: FakeParentConversation;
+/** `undefined` models an assistant with no local guardian binding. */
+let guardianPrincipalId: string | undefined;
+/** Trust class the local principal resolver returns for that guardian. */
+let resolvedTrustClass: TrustClass;
+/** Configs passed to `spawnAndAwait`, in call order. */
+let spawnConfigs: { trustContext?: TrustContext; parentMessages?: Message[] }[];
+
+mock.module("../../daemon/conversation-store.js", () => ({
+  ...realConversationStoreModule,
+  getOrCreateConversation: async (conversationId: string) =>
+    forkMocksActive
+      ? (parentConversation as unknown as Conversation)
+      : realConversationStoreModule.getOrCreateConversation(conversationId),
+}));
+
+mock.module("../../runtime/local-actor-identity.js", () => ({
+  ...realLocalActorIdentityModule,
+  findLocalGuardianPrincipalId: async () =>
+    forkMocksActive
+      ? guardianPrincipalId
+      : realLocalActorIdentityModule.findLocalGuardianPrincipalId(),
+}));
+
+mock.module("../../runtime/local-principal-trust.js", () => ({
+  ...realLocalPrincipalTrustModule,
+  resolveLocalPrincipalTrustContext: async (
+    input: Parameters<
+      typeof realLocalPrincipalTrustModule.resolveLocalPrincipalTrustContext
+    >[0],
+  ) => {
+    if (!forkMocksActive) {
+      return realLocalPrincipalTrustModule.resolveLocalPrincipalTrustContext(
+        input,
+      );
+    }
+    return {
+      sourceChannel: "vellum",
+      trustClass: resolvedTrustClass,
+      guardianPrincipalId: input.actorPrincipalId,
+    } satisfies TrustContext;
+  },
+}));
+
+mock.module("../../subagent/index.js", () => ({
+  ...realSubagentModule,
+  getSubagentManager: () =>
+    forkMocksActive
+      ? {
+          spawnAndAwait: async (config: {
+            trustContext?: TrustContext;
+            parentMessages?: Message[];
+          }) => {
+            spawnConfigs.push(config);
+            return "continuation answer";
+          },
+        }
+      : realSubagentModule.getSubagentManager(),
+}));
+
+import { defaultSpawnBackgroundContinuation } from "../live-voice-session.js";
+
+async function spawnContinuation(): Promise<string> {
+  return await defaultSpawnBackgroundContinuation({
+    parentConversationId: PARENT_CONVERSATION_ID,
+    objective: "finish the interrupted build",
+    label: "continuation",
+    signal: new AbortController().signal,
+  });
+}
+
+describe("duplex continuation fork-parent hydration", () => {
+  beforeAll(() => {
+    forkMocksActive = true;
+  });
+
+  afterAll(() => {
+    forkMocksActive = false;
+  });
+
+  beforeEach(() => {
+    parentConversation = new FakeParentConversation();
+    guardianPrincipalId = GUARDIAN_PRINCIPAL_ID;
+    resolvedTrustClass = "guardian";
+    spawnConfigs = [];
+  });
+
+  test("loads a cold parent under the resolved guardian trust", async () => {
+    await spawnContinuation();
+
+    // The trust context in force AT LOAD TIME is what `loadFromDb` filters
+    // against, so resolving trust after the hydration would not help.
+    expect(parentConversation.loadTrustContexts).toHaveLength(1);
+    expect(parentConversation.loadTrustContexts[0]).toBeDefined();
+    expect(parentConversation.loadTrustContexts[0]?.trustClass).toBe(
+      "guardian",
+    );
+    expect(spawnConfigs[0]?.parentMessages).toEqual(HYDRATED_MESSAGES);
+  });
+
+  test("restores the parent's prior trust context after the load", async () => {
+    const priorTrustContext: TrustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+      guardianPrincipalId: "principal-prior",
+    };
+    parentConversation.setTrustContext(priorTrustContext);
+
+    await spawnContinuation();
+
+    expect(parentConversation.loadTrustContexts).toHaveLength(1);
+    // The bridge owns this conversation's trust per-turn; the stamp must not
+    // outlive the load.
+    expect(parentConversation.trustContext).toBe(priorTrustContext);
+  });
+
+  test("clears the stamp when the parent had no trust context", async () => {
+    await spawnContinuation();
+
+    expect(parentConversation.trustContext).toBeUndefined();
+  });
+
+  test("reloads a parent that was hydrated with no trust context", async () => {
+    // Warm instance: `getOrCreateConversation` already loaded it, but without a
+    // trust context — so its history may be trust-filtered and cannot be forked
+    // as-is.
+    parentConversation = new FakeParentConversation([
+      textMessage("filtered-history"),
+    ]);
+
+    await spawnContinuation();
+
+    expect(parentConversation.loadTrustContexts).toHaveLength(1);
+    expect(parentConversation.loadTrustContexts[0]?.trustClass).toBe(
+      "guardian",
+    );
+    expect(spawnConfigs[0]?.parentMessages).toEqual(HYDRATED_MESSAGES);
+  });
+
+  test("leaves an already-guardian-scoped warm parent alone", async () => {
+    parentConversation = new FakeParentConversation(
+      [textMessage("warm")],
+      "guardian",
+    );
+
+    await spawnContinuation();
+
+    expect(parentConversation.loadTrustContexts).toHaveLength(0);
+    expect(spawnConfigs[0]?.parentMessages).toEqual([textMessage("warm")]);
+  });
+
+  test("hydrates unstamped when no guardian trust resolves", async () => {
+    guardianPrincipalId = undefined;
+
+    await spawnContinuation();
+
+    // Fail-closed by design: with no guardian binding there is nothing to stamp,
+    // so the continuation runs as `unknown` exactly as an unstamped turn does.
+    expect(parentConversation.loadTrustContexts).toEqual([undefined]);
+    expect(parentConversation.trustContext).toBeUndefined();
+    expect(spawnConfigs[0]?.trustContext).toBeUndefined();
+  });
+
+  test("does not stamp a non-guardian resolution", async () => {
+    resolvedTrustClass = "unknown";
+
+    await spawnContinuation();
+
+    expect(parentConversation.loadTrustContexts).toEqual([undefined]);
+    expect(spawnConfigs[0]?.trustContext).toBeUndefined();
+  });
+});