@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/daemon/__tests__/install-assistant-command.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Tests for the `assistant` command installer.
+ *
+ * The two layouts that matter are the compiled desktop bundle (a binary beside
+ * the daemon) and the npm-installed runtime the desktop app actually ships (a
+ * bun entry under `node_modules`, which needs a wrapper that pins bun). A repo
+ * checkout must install nothing: developers own their PATH.
+ */
+
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  installCommandAt,
+  resolveAssistantCommandTarget,
+} from "../install-assistant-command.js";
+
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "assistant-command-"));
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+/** Build `<root>/<prefix>/node_modules/@vellumai/assistant/src/daemon`. */
+function seedInstalledLayout(options: { withBin: boolean }): string {
+  const nodeModules = join(root, "cli", "latest", "node_modules");
+  const moduleDir = join(
+    nodeModules,
+    "@vellumai",
+    "assistant",
+    "src",
+    "daemon",
+  );
+  mkdirSync(moduleDir, { recursive: true });
+  writeFileSync(join(moduleDir, "..", "index.ts"), "#!/usr/bin/env bun\n");
+
+  if (options.withBin) {
+    mkdirSync(join(nodeModules, ".bin"), { recursive: true });
+    writeFileSync(
+      join(nodeModules, ".bin", "assistant"),
+      "#!/usr/bin/env bun\n",
+    );
+  }
+  return moduleDir;
+}
+
+describe("resolveAssistantCommandTarget", () => {
+  test("npm install resolves the .bin/assistant shim under a pinned bun", () => {
+    const moduleDir = seedInstalledLayout({ withBin: true });
+
+    const target = resolveAssistantCommandTarget({
+      execPath: "/Applications/Vellum.app/Contents/Resources/bun",
+      moduleDir,
+    });
+
+    expect(target).toEqual({
+      kind: "bun-entry",
+      bun: "/Applications/Vellum.app/Contents/Resources/bun",
+      entry: join(root, "cli", "latest", "node_modules", ".bin", "assistant"),
+    });
+  });
+
+  test("npm install without the meta package falls back to the CLI entry", () => {
+    const moduleDir = seedInstalledLayout({ withBin: false });
+
+    const target = resolveAssistantCommandTarget({
+      execPath: "/usr/local/bin/bun",
+      moduleDir,
+    });
+
+    expect(target).toEqual({
+      kind: "bun-entry",
+      bun: "/usr/local/bin/bun",
+      entry: join(
+        root,
+        "cli",
+        "latest",
+        "node_modules",
+        "@vellumai",
+        "assistant",
+        "src",
+        "index.ts",
+      ),
+    });
+  });
+
+  test("repo checkout installs nothing", () => {
+    const moduleDir = join(root, "repo", "assistant", "src", "daemon");
+    mkdirSync(moduleDir, { recursive: true });
+    writeFileSync(join(moduleDir, "..", "index.ts"), "#!/usr/bin/env bun\n");
+
+    expect(
+      resolveAssistantCommandTarget({
+        execPath: "/usr/local/bin/bun",
+        moduleDir,
+      }),
+    ).toBeNull();
+  });
+
+  test("compiled bundle resolves the sibling binary", () => {
+    const macosDir = join(root, "Vellum.app", "Contents", "MacOS");
+    mkdirSync(macosDir, { recursive: true });
+    writeFileSync(join(macosDir, "vellum-assistant"), "");
+
+    const target = resolveAssistantCommandTarget({
+      execPath: join(macosDir, "vellum-daemon"),
+      moduleDir: join(root, "irrelevant"),
+    });
+
+    expect(target).toEqual({
+      kind: "binary",
+      binary: join(macosDir, "vellum-assistant"),
+    });
+  });
+
+  test("a compiled runtime outside a bundle installs nothing", () => {
+    const moduleDir = seedInstalledLayout({ withBin: true });
+
+    expect(
+      resolveAssistantCommandTarget({
+        execPath: "/opt/vellum/vellum-daemon",
+        moduleDir,
+      }),
+    ).toBeNull();
+  });
+});
+
+describe("installCommandAt", () => {
+  const target = {
+    kind: "bun-entry" as const,
+    bun: "/Applications/Vellum Staging.app/Contents/Resources/bun",
+    entry:
+      "/Users/x/Library/Application Support/@vellumai/macos/.bin/assistant",
+  };
+
+  test("writes an executable wrapper that quotes paths with spaces", () => {
+    const commandPath = join(root, "bin", "assistant");
+
+    expect(installCommandAt(commandPath, target)).toBe(true);
+
+    const content = readFileSync(commandPath, "utf-8");
+    expect(content.startsWith("#!/bin/sh\n")).toBe(true);
+    expect(content).toContain(
+      `exec '/Applications/Vellum Staging.app/Contents/Resources/bun' ` +
+        `'/Users/x/Library/Application Support/@vellumai/macos/.bin/assistant' "$@"`,
+    );
+    expect(lstatSync(commandPath).mode & 0o111).toBeGreaterThan(0);
+  });
+
+  test("running the wrapper forwards arguments to the pinned interpreter", () => {
+    const interpreter = join(root, "fake bun");
+    writeFileSync(interpreter, '#!/bin/sh\necho "$@"\n');
+    chmodSync(interpreter, 0o755);
+
+    const commandPath = join(root, "assistant");
+    installCommandAt(commandPath, {
+      kind: "bun-entry",
+      bun: interpreter,
+      entry: join(root, "entry with space.ts"),
+    });
+
+    const proc = Bun.spawnSync({ cmd: [commandPath, "browser", "status"] });
+    expect(proc.exitCode).toBe(0);
+    expect(proc.stdout.toString().trim()).toBe(
+      `${join(root, "entry with space.ts")} browser status`,
+    );
+  });
+
+  test("is idempotent and rewrites a stale wrapper", () => {
+    const commandPath = join(root, "assistant");
+
+    expect(installCommandAt(commandPath, target)).toBe(true);
+    const first = readFileSync(commandPath, "utf-8");
+    expect(installCommandAt(commandPath, target)).toBe(true);
+    expect(readFileSync(commandPath, "utf-8")).toBe(first);
+
+    const moved = { ...target, bun: "/opt/homebrew/bin/bun" };
+    expect(installCommandAt(commandPath, moved)).toBe(true);
+    expect(readFileSync(commandPath, "utf-8")).toContain(
+      "/opt/homebrew/bin/bun",
+    );
+  });
+
+  test("replaces a stale symlink", () => {
+    const commandPath = join(root, "assistant");
+    symlinkSync("/nonexistent/old-target", commandPath);
+
+    expect(installCommandAt(commandPath, target)).toBe(true);
+    expect(lstatSync(commandPath).isFile()).toBe(true);
+  });
+
+  test("never clobbers a file it does not own", () => {
+    const commandPath = join(root, "assistant");
+    writeFileSync(commandPath, "#!/bin/sh\n# a developer's own build\n");
+
+    expect(installCommandAt(commandPath, target)).toBe(false);
+    expect(readFileSync(commandPath, "utf-8")).toContain("developer's own");
+  });
+
+  test("reports failure instead of throwing on an unusable path", () => {
+    const commandPath = join(root, "assistant");
+    mkdirSync(commandPath);
+
+    expect(installCommandAt(commandPath, target)).toBe(false);
+    expect(existsSync(commandPath)).toBe(true);
+  });
+
+  test("symlinks a compiled binary target", () => {
+    const binary = join(root, "vellum-assistant");
+    writeFileSync(binary, "");
+    const commandPath = join(root, "bin", "assistant");
+
+    expect(installCommandAt(commandPath, { kind: "binary", binary })).toBe(
+      true,
+    );
+    expect(lstatSync(commandPath).isSymbolicLink()).toBe(true);
+  });
+});

package/src/daemon/__tests__/turn-tail-assistant-reply-notify.test.ts

@@ -7,7 +7,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
 import { setConfig } from "../../__tests__/helpers/set-config.js";
-import type { InflightContentWriter } from "../inflight-message-content.js";
 
 // The finalize module's import graph reaches the memory indexer; keep it inert
 // so no embedding backend is touched.
@@ -78,17 +77,16 @@ async function runTail(overrides: {
   replyDeliveredInAppOnly?: boolean;
 }): Promise<void> {
   await runDeferredTurnTail({
-    ctx: { conversationId: CONVERSATION_ID, messages: [] },
+    conversationId: CONVERSATION_ID,
     state: {
       deferredFinalizeEffects: overrides.deferredFinalizeEffects ?? [],
       lastAssistantMessageId:
         "lastAssistantMessageId" in overrides
           ? overrides.lastAssistantMessageId
           : ASSISTANT_MESSAGE_ID,
-      inflightWriters: new Map<string, InflightContentWriter>(),
     },
     rlog,
-    generationCompletedAt: Date.now(),
+    criticalSectionMs: 0,
     turnCompleted: overrides.turnCompleted,
     userMessageId:
       "userMessageId" in overrides ? overrides.userMessageId : USER_MESSAGE_ID,

package/src/daemon/__tests__/turn-tail-deleted-conversation.test.ts

@@ -1,9 +1,9 @@
 /**
- * `runDeferredTurnTail` runs after the terminal SSE, so the user can delete the
- * conversation while its awaited bookkeeping is still draining. These tests pin
- * that the tail's two filesystem steps (tool-result spooling and the JSONL disk
- * mirror) read the conversation fresh and skip once it is gone, rather than
- * rebuilding a deleted conversation's directory from in-memory history.
+ * `settleTurnContent` runs after the terminal SSE, so the user can delete the
+ * conversation before its content-settling steps run. These tests pin that the
+ * two filesystem steps (tool-result spooling and the JSONL disk mirror) read the
+ * conversation fresh and skip once it is gone, rather than rebuilding a deleted
+ * conversation's directory from in-memory history.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -19,10 +19,9 @@ setConfig("memory", { enabled: false, v2: { enabled: false } });
 
 const CONVERSATION_ID = "conv-tail-delete-1";
 const ASSISTANT_MESSAGE_ID = "msg-assistant-1";
-const USER_MESSAGE_ID = "msg-user-1";
 const CONVERSATION_DIR = "/tmp/vellum-test/conv-tail-delete-1";
 
-/** Flipped by a deferred finalize effect to model a mid-tail deletion. */
+/** Flipped by a test to model a deletion that landed before the settle ran. */
 let conversationDeleted = false;
 let getConversationCalls = 0;
 const resolvedDirCalls: string[] = [];
@@ -56,6 +55,7 @@ function makeConversation(): ConversationRow {
     originInterface: null,
     forkParentConversationId: null,
     forkParentMessageId: null,
+    forkStrategy: null,
     isAutoTitle: 0,
     scheduleJobId: null,
     lastMessageAt: null,
@@ -115,29 +115,22 @@ mock.module("../../persistence/conversation-disk-view.js", () => ({
   },
 }));
 
-const { runDeferredTurnTail } =
-  await import("../conversation-turn-finalize.js");
+const { settleTurnContent } = await import("../conversation-turn-finalize.js");
 
 const rlog = makeMockLogger() as Parameters<
-  typeof runDeferredTurnTail
+  typeof settleTurnContent
 >[0]["rlog"];
 
-/** Runs the tail with one deferred effect standing in for the turn's bookkeeping. */
-async function runTail(
-  deferredEffect: () => Promise<void>,
-): Promise<Message[]> {
+/** Settles one turn's content and hands back the history it left behind. */
+async function runSettle(): Promise<Message[]> {
   const ctx = { conversationId: CONVERSATION_ID, messages: [] as Message[] };
-  await runDeferredTurnTail({
+  await settleTurnContent({
     ctx,
     state: {
-      deferredFinalizeEffects: [deferredEffect],
       lastAssistantMessageId: ASSISTANT_MESSAGE_ID,
       inflightWriters: new Map<string, InflightContentWriter>(),
     },
     rlog,
-    generationCompletedAt: Date.now(),
-    turnCompleted: true,
-    userMessageId: USER_MESSAGE_ID,
   });
   return ctx.messages;
 }
@@ -150,11 +143,11 @@ beforeEach(() => {
   diskSyncCalls.length = 0;
 });
 
-describe("runDeferredTurnTail conversation deleted mid-tail", () => {
+describe("settleTurnContent conversation deleted after the terminal SSE", () => {
   test("skips the filesystem steps when the conversation is gone", async () => {
-    const messages = await runTail(async () => {
-      conversationDeleted = true;
-    });
+    conversationDeleted = true;
+
+    const messages = await runSettle();
 
     expect(resolvedDirCalls).toEqual([]);
     expect(truncateCalls).toEqual([]);
@@ -162,16 +155,14 @@ describe("runDeferredTurnTail conversation deleted mid-tail", () => {
     expect(messages).toEqual([]);
   });
 
-  test("reads the conversation once more before the filesystem steps", async () => {
-    await runTail(async () => {
-      conversationDeleted = true;
-    });
+  test("reads the conversation itself rather than trusting an earlier read", async () => {
+    await runSettle();
 
-    expect(getConversationCalls).toBe(2);
+    expect(getConversationCalls).toBe(1);
   });
 
   test("runs the filesystem steps when the conversation survives", async () => {
-    const messages = await runTail(async () => {});
+    const messages = await runSettle();
 
     expect(resolvedDirCalls).toEqual([CONVERSATION_ID]);
     expect(truncateCalls).toEqual([CONVERSATION_DIR]);

package/src/daemon/channel-ui-capability.ts

@@ -1,9 +1,9 @@
 /**
  * Minimal capability view {@link conversationSupportsDynamicUi} reads. The live
- * `Conversation` (whose fields are the richer `ChannelCapabilities`), the tool
- * executor's `ToolSetupContext`, and partial test doubles all satisfy it
- * structurally, so the helper stays a dependency-free leaf callable from any
- * layer without importing `Conversation`.
+ * `Conversation` (whose fields are the richer `ChannelCapabilities`) and
+ * partial test doubles both satisfy it structurally, so the helper stays a
+ * dependency-free leaf callable from any layer without importing
+ * `Conversation`.
  */
 export interface DynamicUiCapabilityView {
   readonly currentTurnChannelCapabilities?: {

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

@@ -11,6 +11,7 @@ import type pino from "pino";
 import { v4 as uuid } from "uuid";
 
 import type { AgentEvent } from "../agent/loop.js";
+import type { AnsweredQuestion } from "../api/events/question-answered.js";
 import type { AssistantEvent } from "../api/index.js";
 import type {
   TurnChannelContext,
@@ -334,6 +335,12 @@ export interface EventHandlerState {
    * tools (in handleToolResult) and native server tools (server_tool_complete).
    */
   readonly toolActivityMetadata: Map<string, ToolActivityMetadata>;
+  /**
+   * Answered `ask_question` records keyed by tool_use_id, captured when the
+   * result lands so the questions and the user's answers are persisted on the
+   * tool's content block and the answered card survives a history reopen.
+   */
+  readonly toolAnsweredQuestions: Map<string, AnsweredQuestion>;
   /** tool_use_ids emitted in the current turn (populated in handleToolUse, cleared after annotation). */
   currentTurnToolUseIds: string[];
   /** Wall-clock time (ms since epoch) when the agent loop turn started, used as the display timestamp for assistant messages. */
@@ -602,6 +609,7 @@ export function createEventHandlerState(): EventHandlerState {
     toolConfirmationOutcomes: new Map(),
     toolRiskOutcomes: new Map(),
     toolActivityMetadata: new Map(),
+    toolAnsweredQuestions: new Map(),
     currentTurnToolUseIds: [],
     turnStartedAt: Date.now(),
     serverToolStartedAt: new Map(),
@@ -837,6 +845,12 @@ export function buildPersistedAssistantContent(
       display: surface.display,
       ...(surface.persistent ? { persistent: true } : {}),
       ...(surface.toolCallId ? { toolCallId: surface.toolCallId } : {}),
+      // A surface answered before this write lands owns no persisted block for
+      // `markSurfaceCompleted` to patch, so its completion rides the snapshot.
+      ...(surface.completed ? { completed: true } : {}),
+      ...(surface.completionSummary
+        ? { completionSummary: surface.completionSummary }
+        : {}),
     } as unknown as ContentBlock);
   }
   return withSurfaces.map((block) => {
@@ -2005,7 +2019,7 @@ export async function finalizePendingToolResultRow(
   );
   const contentJson = JSON.stringify(
     conv != null
-      ? referenceMediaBlocksForPersist(
+      ? await referenceMediaBlocksForPersist(
           conversationId,
           conv.createdAt,
           rowId,
@@ -2277,6 +2291,20 @@ export async function handleToolResult(
     state.toolActivityMetadata.set(event.toolUseId, event.activityMetadata);
   }
 
+  // Capture the answered `ask_question` record and stamp it on the durable
+  // tool_use block right away. The end-of-turn annotation re-stamps it, but
+  // that only runs once every tool in the turn has finished: a user who
+  // switches conversations while a sibling tool is still running would
+  // otherwise reload into history that has lost their answer.
+  if (event.answeredQuestion) {
+    state.toolAnsweredQuestions.set(event.toolUseId, event.answeredQuestion);
+    recordAnsweredQuestionOnPersistedMessage(
+      state,
+      event.toolUseId,
+      event.answeredQuestion,
+    );
+  }
+
   const toolName = state.toolUseIdToName.get(event.toolUseId);
   if (toolName === "file_write" || toolName === "bash") {
     deps.ctx.markWorkspaceTopLevelDirty();
@@ -2360,6 +2388,7 @@ export async function handleToolResult(
     approvalReason: event.approvalReason,
     riskThreshold: event.riskThreshold,
     activityMetadata: event.activityMetadata,
+    answeredQuestion: event.answeredQuestion,
     errorCode: event.errorCode,
     completedAt,
   });
@@ -2380,18 +2409,23 @@ export async function handleToolResult(
 }
 
 /**
- * Stamp `_startedAt` onto the in-flight tool_use block in the persisted
- * assistant message the moment the tool begins. The block is already durable
- * (message_complete precedes tool events), so without this a `/messages`
- * snapshot fetched mid-tool would carry no start time and clients could not
- * render a running elapsed-time counter until the whole turn finished. The
- * full timing + risk annotation still happens in
- * `annotatePersistedAssistantMessage` once every tool in the turn completes.
+ * Stamp vellum-internal metadata onto an in-flight tool_use block in the
+ * persisted assistant message, ahead of the turn's end-of-turn annotation. The
+ * block is already durable (message_complete precedes tool events), so without
+ * an early stamp a `/messages` snapshot fetched mid-turn carries none of it and
+ * clients render a degraded row until every tool in the turn has finished.
+ *
+ * `apply` mutates the block record and returns false when the value is already
+ * stamped, which skips the write. The write itself is best-effort:
+ * `annotatePersistedAssistantMessage` re-stamps from the same state maps once
+ * the turn's tools complete, so a transient `SQLITE_BUSY` here must not abort
+ * the turn. `what` names the field for the failure log.
  */
-function recordToolStartOnPersistedMessage(
+function stampToolUseBlockEarly(
   state: EventHandlerState,
   toolUseId: string,
-  startedAt: number,
+  what: string,
+  apply: (block: Record<string, unknown>) => boolean,
 ): void {
   const messageId = state.lastAssistantMessageId;
   if (!messageId) {
@@ -2413,19 +2447,15 @@ function recordToolStartOnPersistedMessage(
     if (rec.id !== toolUseId) {
       continue;
     }
-    if (rec._startedAt === startedAt) {
+    if (!apply(rec)) {
       return;
     }
-    rec._startedAt = startedAt;
-    // Best-effort early stamp: `annotatePersistedAssistantMessage` re-stamps
-    // once every tool in the turn completes, so a transient `SQLITE_BUSY` here
-    // must not abort the turn — the end-of-turn write recovers it.
     try {
       updateMessageContent(messageId, JSON.stringify(content));
     } catch (err) {
       log.error(
         { err, messageId },
-        "stamping tool start time failed; end-of-turn annotation will recover",
+        `stamping ${what} failed; end-of-turn annotation will recover`,
       );
     }
     return;
@@ -2433,57 +2463,73 @@ function recordToolStartOnPersistedMessage(
 }
 
 /**
- * Stamp `_previewStartedAt` (the first-byte timestamp) onto the durable
- * tool_use block, mirroring `recordToolStartOnPersistedMessage`. Called from
- * `handleToolUse` rather than `handleToolUsePreviewStart`: the block only exists
- * once message_complete has written it, which happens after the preview event
- * but before the tool event. Without this a `/messages` snapshot fetched
- * mid-tool would lose the perceived-start anchor and clients would fall back to
- * execution start — hiding the input-streaming gap the user actually waited
- * through.
+ * Stamp `_startedAt` the moment the tool begins, so a mid-tool `/messages`
+ * snapshot can render a running elapsed-time counter.
+ */
+function recordToolStartOnPersistedMessage(
+  state: EventHandlerState,
+  toolUseId: string,
+  startedAt: number,
+): void {
+  stampToolUseBlockEarly(state, toolUseId, "tool start time", (rec) => {
+    if (rec._startedAt === startedAt) {
+      return false;
+    }
+    rec._startedAt = startedAt;
+    return true;
+  });
+}
+
+/**
+ * Stamp `_previewStartedAt` (the first-byte timestamp). Called from
+ * `handleToolUse` rather than `handleToolUsePreviewStart`: the block only
+ * exists once message_complete has written it, which happens after the preview
+ * event but before the tool event. Without it a mid-tool `/messages` snapshot
+ * loses the perceived-start anchor and clients fall back to execution start,
+ * hiding the input-streaming gap the user actually waited through.
  */
 function recordToolPreviewStartOnPersistedMessage(
   state: EventHandlerState,
   toolUseId: string,
   previewStartedAt: number,
 ): void {
-  const messageId = state.lastAssistantMessageId;
-  if (!messageId) {
-    return;
-  }
-
-  const row = getMessageById(messageId);
-  if (!row) {
-    return;
-  }
-
-  const content: ContentBlock[] = row.content;
-
-  for (const block of content) {
-    if (block.type !== "tool_use") {
-      continue;
-    }
-    const rec = block as unknown as Record<string, unknown>;
-    if (rec.id !== toolUseId) {
-      continue;
-    }
+  stampToolUseBlockEarly(state, toolUseId, "tool preview-start time", (rec) => {
     if (rec._previewStartedAt === previewStartedAt) {
-      return;
+      return false;
     }
     rec._previewStartedAt = previewStartedAt;
-    // Best-effort early stamp, mirroring `recordToolStartOnPersistedMessage`:
-    // `annotatePersistedAssistantMessage` re-stamps at end of turn, so a
-    // transient `SQLITE_BUSY` here must not abort the turn.
-    try {
-      updateMessageContent(messageId, JSON.stringify(content));
-    } catch (err) {
-      log.error(
-        { err, messageId },
-        "stamping tool preview-start time failed; end-of-turn annotation will recover",
-      );
+    return true;
+  });
+}
+
+/**
+ * Stamp `_answeredQuestion` the moment an `ask_question` prompt settles, so a
+ * user who leaves the conversation while a sibling tool is still running comes
+ * back to their answer rather than to a question that lost its response.
+ */
+function recordAnsweredQuestionOnPersistedMessage(
+  state: EventHandlerState,
+  toolUseId: string,
+  answeredQuestion: AnsweredQuestion,
+): void {
+  stampToolUseBlockEarly(state, toolUseId, "answered question", (rec) => {
+    // Narrow the persisted marker rather than casting it: the row is data read
+    // back from the database, so its shape is an assumption until checked. Any
+    // value that is not a record with a string `requestId` is treated as absent
+    // and overwritten, which is the safe direction for a dedup check.
+    const existing: unknown = rec._answeredQuestion;
+    const existingRequestId =
+      typeof existing === "object" &&
+      existing !== null &&
+      typeof (existing as { requestId?: unknown }).requestId === "string"
+        ? (existing as { requestId: string }).requestId
+        : undefined;
+    if (existingRequestId === answeredQuestion.requestId) {
+      return false;
     }
-    return;
-  }
+    rec._answeredQuestion = answeredQuestion;
+    return true;
+  });
 }
 
 /**
@@ -2583,6 +2629,11 @@ function annotatePersistedAssistantMessage(
         rec._activityMetadata = activity;
         modified = true;
       }
+      const answeredQuestion = state.toolAnsweredQuestions.get(id);
+      if (answeredQuestion) {
+        rec._answeredQuestion = answeredQuestion;
+        modified = true;
+      }
     }
   }
 
@@ -2608,6 +2659,12 @@ function annotatePersistedAssistantMessage(
         ...(surface.activationMoment
           ? { activationMoment: surface.activationMoment }
           : {}),
+        // A surface answered before this write lands owns no persisted block for
+        // `markSurfaceCompleted` to patch, so its completion rides the snapshot.
+        ...(surface.completed ? { completed: true } : {}),
+        ...(surface.completionSummary
+          ? { completionSummary: surface.completionSummary }
+          : {}),
       } as unknown as ContentBlock);
     }
     modified = true;
@@ -2874,10 +2931,9 @@ export async function handleMessageComplete(
   // The row was reserved at `llm_call_started` (with channel metadata
   // stamped at that point) and `state.lastAssistantMessageId` carries its
   // id. Flush the final content via `updateContent` instead of inserting a
-  // new row. No `syncToDisk` flag here — the orchestrator separately
-  // invokes `syncMessageToDisk` on `state.lastAssistantMessageId` after
-  // the loop completes (see
-  // `conversation-agent-loop.ts::syncLastAssistantMessageToDisk`).
+  // new row. No `syncToDisk` flag here: the orchestrator separately invokes
+  // `syncMessageToDisk` on `state.lastAssistantMessageId` after the loop
+  // completes (see `conversation-turn-finalize.ts::settleTurnContent`).
   const assistantMessageId = state.lastAssistantMessageId;
   if (!assistantMessageId) {
     throw new Error(