@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/daemon/trust-context.ts

@@ -44,6 +44,13 @@ export interface TrustContext {
   memberStatus?: string;
   /** Channel policy of the requester's channel (ACL). */
   memberPolicy?: string;
+  /**
+   * Prior-interaction count for the requester's member channel, sourced from
+   * the gateway trust verdict (gateway owns interaction telemetry). Undefined
+   * when the verdict carries no member telemetry (unknown sender) or when trust
+   * was resolved locally without a gateway verdict.
+   */
+  requesterInteractionCount?: number;
 }
 
 /**
@@ -75,17 +82,25 @@ export const FALLBACK_TURN_TRUST: TrustContext = {
 /**
  * Resolve the effective trust class for an actor.
  *
- * When HTTP auth is disabled (dev bypass), always returns `'guardian'`
- * so that control-plane gates don't block local development.
+ * Trust is a property of the actor, never of the deployment's auth posture.
+ * The dev/local bypass therefore fills in `'guardian'` only when NO actor was
+ * resolved: local/native turns reach the daemon without a channel-resolved
+ * trustContext, and in an auth-disabled (local) deployment that unresolved
+ * actor is the guardian. A *present* trustContext always reflects the real
+ * actor — even under `DISABLE_HTTP_AUTH`, which is the standing config in
+ * platform-managed deployments — so a resolved non-guardian channel actor is
+ * never elevated to guardian.
  *
- * When no trust context is available (e.g. desktop-only conversations that
- * don't go through channel trust resolution), defaults to `'unknown'`
- * to fail-closed.
+ * When no trust context is available and auth is enabled (e.g. a desktop-only
+ * conversation that hasn't gone through channel trust resolution), defaults to
+ * `'unknown'` to fail-closed.
  */
 export function resolveTrustClass(
   trustContext: TrustContext | undefined,
 ): TrustClass {
-  if (isHttpAuthDisabled()) return "guardian";
+  if (trustContext === undefined && isHttpAuthDisabled()) {
+    return "guardian";
+  }
   return trustContext?.trustClass ?? "unknown";
 }
 

package/src/daemon/turn-latency-tracker.test.ts

@@ -115,6 +115,99 @@ describe("TurnLatencyTracker", () => {
     expect(breakdown!.providerDurationMs).toBe(135);
   });
 
+  test("a failed first attempt is superseded by the successful retry", () => {
+    const t = new TurnLatencyTracker();
+    clock = 0;
+    t.mark("turn_start");
+    clock = 10;
+    t.mark("prompt_hook_start"); // queue = 10
+    clock = 110;
+    t.mark("prompt_hook_end"); // memory_context = 100
+    // First attempt: tools resolved and request sent, then the provider
+    // rejects (context overflow) — no first_token, no call_complete.
+    clock = 120;
+    t.mark("tools_resolved");
+    clock = 130;
+    t.mark("request_sent");
+    // Recovery runs, then the loop re-issues the call.
+    clock = 1000;
+    t.mark("tools_resolved");
+    clock = 1010;
+    t.mark("request_sent");
+    clock = 1200;
+    t.markFirstToken("text");
+    clock = 1260;
+    t.mark("call_complete");
+
+    const { breakdown } = t.serializeSince(0);
+    // ttft / provider-duration reflect ONLY the successful attempt (1010),
+    // not the failed attempt's request_sent (130).
+    expect(breakdown!.ttftMs).toBe(190);
+    expect(breakdown!.providerDurationMs).toBe(250);
+    // The failed attempt's per-call marks are gone: no duplicate phases.
+    expect(breakdown!.phases.map((p) => p.key)).toEqual([
+      "queue",
+      "memory_context",
+      "setup",
+      "request_prep",
+      "ttft",
+      "generation",
+    ]);
+    expect(phaseMap(breakdown!.phases).request_prep).toBe(10);
+  });
+
+  test("a failed retry mid tool-loop is superseded", () => {
+    const t = new TurnLatencyTracker();
+    clock = 0;
+    t.mark("turn_start");
+    clock = 10;
+    t.mark("prompt_hook_start");
+    clock = 110;
+    t.mark("prompt_hook_end");
+    clock = 120;
+    t.mark("tools_resolved");
+    clock = 130;
+    t.mark("request_sent");
+    clock = 430;
+    t.markFirstToken("thinking");
+    clock = 700;
+    t.mark("call_complete");
+    const first = t.serializeSince(0);
+
+    // Second call fails after streaming a partial token, then retries.
+    clock = 1000;
+    t.mark("tools_resolved");
+    clock = 1010;
+    t.mark("request_sent");
+    clock = 1100;
+    t.markFirstToken("text"); // partial stream before the failure
+    clock = 2000;
+    t.mark("tools_resolved");
+    clock = 2010;
+    t.mark("request_sent");
+    clock = 2200;
+    t.markFirstToken("text");
+    clock = 2260;
+    t.mark("call_complete");
+
+    const { breakdown } = t.serializeSince(first.cursor);
+    // Only the successful retry (2010) drives ttft / provider-duration; the
+    // failed attempt's request_sent (1010) and its stray first_token (1100)
+    // are dropped.
+    expect(breakdown!.ttftMs).toBe(190);
+    expect(breakdown!.providerDurationMs).toBe(250);
+    expect(breakdown!.firstTokenKind).toBe("text");
+    // No duplicate per-call phases from the failed attempt.
+    expect(breakdown!.phases.map((p) => p.key)).toEqual([
+      "setup",
+      "request_prep",
+      "ttft",
+      "generation",
+    ]);
+    expect(phaseMap(breakdown!.phases).request_prep).toBe(10);
+    expect(breakdown!.totalToFirstTokenMs).toBeUndefined();
+  });
+
   test("no marks serializes to null", () => {
     const t = new TurnLatencyTracker();
     expect(t.serializeSince(0).breakdown).toBeNull();

package/src/daemon/turn-latency-tracker.ts

@@ -56,9 +56,47 @@ export class TurnLatencyTracker {
 
   /** Stamp a point-in-time mark. Cheap (`Date.now()`); safe to over-call. */
   mark(name: LatencyMark): void {
+    // A retried provider call re-issues `request_sent`; drop the failed
+    // attempt's stale marks first so the retry's segment measures only itself.
+    if (name === "request_sent") this.supersedeFailedAttempt();
     this.marks.push({ name, at: Date.now() });
   }
 
+  /**
+   * Discard the per-call marks of a prior provider attempt that never
+   * completed. A call retried within the same turn (context-overflow recovery,
+   * post-model-call repair on a rejection) leaves a `request_sent` with no
+   * `call_complete` and no `usage` event to serialize it and advance the
+   * cursor; the next successful segment would otherwise measure ttft /
+   * provider-duration / phases from the failed attempt's marks.
+   *
+   * Detection is cursor-free: a completed call always stamps `call_complete`
+   * before its `usage` event, so a `request_sent` with none after it belongs
+   * to a call that never returned. A retry re-stamps its setup `tools_resolved`
+   * before this `request_sent`, so that trailing mark is preserved as the
+   * successful segment's setup mark.
+   */
+  private supersedeFailedAttempt(): void {
+    let failedRequestSent = -1;
+    for (let i = this.marks.length - 1; i >= 0; i--) {
+      const name = this.marks[i]!.name;
+      if (name === "call_complete") return; // prior attempt finished — nothing stale
+      if (name === "request_sent") {
+        failedRequestSent = i;
+        break;
+      }
+    }
+    if (failedRequestSent === -1) return; // no prior attempt this turn
+    // Drop from the failed attempt's paired setup mark (its `tools_resolved`,
+    // if any) through its trailing marks, keeping a retry `tools_resolved`
+    // already stamped as the last mark.
+    let start = failedRequestSent;
+    if (this.marks[start - 1]?.name === "tools_resolved") start -= 1;
+    let end = this.marks.length;
+    if (this.marks[end - 1]!.name === "tools_resolved") end -= 1;
+    this.marks.splice(start, end - start);
+  }
+
   /**
    * Stamp the first streamed token of the current call, carrying its kind on
    * the mark. The caller fires this once per call (guarded loop-side), so each

package/src/daemon/wake-conversation-ops.ts

@@ -23,6 +23,7 @@ import { backfillMessageIdOnLogs } from "../persistence/llm-request-log-store.js
 import type { Message } from "../providers/types.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
+import type { CompletedBackgroundTool } from "../tools/background-tool-registry.js";
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
 import type { ServerMessage } from "./message-protocol.js";
@@ -266,13 +267,15 @@ export async function persistWakeTailMessage(
  *
  * Mirrors {@link persistWakeTailMessage}'s channel/interface/provenance
  * metadata, but stamps `kind: "background-event"` (+ the originating `source`)
- * for identification, skips indexing (the body may carry untrusted command
- * output), and is NOT flagged hidden so the trigger shows in the transcript.
+ * for identification and skips indexing (the body may carry untrusted command
+ * output). The `backgroundEventSource` stamp lets clients hide this row from the
+ * rendered transcript — the user-facing wake card carries the status instead.
  */
 export async function persistWakeTriggerMessage(
   conversation: Conversation,
   message: Message,
   source: string,
+  completion?: CompletedBackgroundTool,
 ): Promise<void> {
   const turnChannelCtx = conversation.getTurnChannelContext();
   const turnInterfaceCtx = conversation.getTurnInterfaceContext();
@@ -287,6 +290,7 @@ export async function persistWakeTriggerMessage(
     kind: "background-event",
     backgroundEventSource: source,
     automated: true,
+    ...(completion ? { backgroundToolCompletion: completion } : {}),
   };
   const persisted = await addMessage(
     conversation.conversationId,
@@ -309,12 +313,10 @@ export async function persistWakeTriggerMessage(
       "wake trigger persist: syncMessageToDisk failed (non-fatal)",
     );
   }
-  // Tell connected clients the message list changed so they refetch and the
-  // visible trigger renders live. The normal user-send path publishes the same
-  // invalidation after persisting a user message; without it a wake that
-  // produces no assistant stream (silent no-op), or a conversation open in
-  // another client, would not show the <background_event> row until a manual
-  // reload.
+  // Tell connected clients the message list changed so they refetch. The
+  // trigger row itself is hidden from the transcript (clients drop rows carrying
+  // `backgroundEventSource`), but the refetch keeps other clients' state in sync
+  // and lets a wake that produces no assistant stream still settle cleanly.
   try {
     publishConversationMessagesChanged(conversation.conversationId);
   } catch (err) {

package/src/documents/document-comments-store.test.ts

@@ -31,12 +31,14 @@ const CONVERSATION_ID = "conv-test-123";
 function seedDocument(surfaceId: string = SURFACE_ID): void {
   const now = Date.now();
   rawRun(
+    "test:seedConversation",
     /*sql*/ `INSERT OR IGNORE INTO conversations (id, created_at, updated_at) VALUES (?, ?, ?)`,
     CONVERSATION_ID,
     now,
     now,
   );
   rawRun(
+    "test:seedDocument",
     /*sql*/ `INSERT OR IGNORE INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at)
      VALUES (?, ?, 'Test Doc', 'body', 2, ?, ?)`,
     surfaceId,
@@ -331,7 +333,11 @@ describe("cascade on document delete", () => {
     expect(listComments(SURFACE_ID)).toHaveLength(1);
 
     // Delete the document — FK cascade should remove comments.
-    rawRun(/*sql*/ `DELETE FROM documents WHERE surface_id = ?`, SURFACE_ID);
+    rawRun(
+      "test:deleteDocument",
+      /*sql*/ `DELETE FROM documents WHERE surface_id = ?`,
+      SURFACE_ID,
+    );
 
     expect(listComments(SURFACE_ID)).toHaveLength(0);
   });

package/src/documents/document-comments-store.ts

@@ -92,6 +92,7 @@ export function createComment(params: {
   const now = Date.now();
 
   rawRun(
+    "docComments:createComment",
     /*sql*/ `INSERT INTO document_comments
       (id, surface_id, conversation_id, author, content,
        anchor_start, anchor_end, anchor_text, parent_comment_id,
@@ -132,6 +133,7 @@ export function createComment(params: {
 
 export function getComment(id: string): CommentRecord | null {
   const row = rawGet<CommentRow>(
+    "docComments:getComment",
     /*sql*/ `SELECT * FROM document_comments WHERE id = ?`,
     id,
   );
@@ -162,6 +164,7 @@ export function listComments(
 
   const where = conditions.join(" AND ");
   const rows = rawAll<CommentRow>(
+    "docComments:listComments",
     /*sql*/ `SELECT * FROM document_comments WHERE ${where} ORDER BY created_at ASC`,
     ...params,
   );
@@ -172,6 +175,7 @@ export function listComments(
 export function resolveComment(id: string, resolvedBy: string): boolean {
   const now = Date.now();
   const changes = rawRun(
+    "docComments:resolveComment",
     /*sql*/ `UPDATE document_comments
       SET status = 'resolved', resolved_by = ?, resolved_at = ?, updated_at = ?
       WHERE id = ?`,
@@ -189,6 +193,7 @@ export function resolveComment(id: string, resolvedBy: string): boolean {
 export function reopenComment(id: string): boolean {
   const now = Date.now();
   const changes = rawRun(
+    "docComments:reopenComment",
     /*sql*/ `UPDATE document_comments
       SET status = 'open', resolved_by = NULL, resolved_at = NULL, updated_at = ?
       WHERE id = ?`,
@@ -204,6 +209,7 @@ export function reopenComment(id: string): boolean {
 export function updateCommentContent(id: string, content: string): boolean {
   const now = Date.now();
   const changes = rawRun(
+    "docComments:updateCommentContent",
     /*sql*/ `UPDATE document_comments SET content = ?, updated_at = ? WHERE id = ?`,
     content,
     now,
@@ -218,6 +224,7 @@ export function updateCommentContent(id: string, content: string): boolean {
 export function deleteComment(id: string): boolean {
   // Replies cascade-delete via the self-referential FK on parent_comment_id.
   const changes = rawRun(
+    "docComments:deleteComment",
     /*sql*/ `DELETE FROM document_comments WHERE id = ?`,
     id,
   );
@@ -229,6 +236,7 @@ export function deleteComment(id: string): boolean {
 
 export function getCommentCountForDocument(surfaceId: string): number {
   const row = rawGet<{ count: number }>(
+    "docComments:getCommentCount",
     /*sql*/ `SELECT COUNT(*) AS count FROM document_comments
       WHERE surface_id = ? AND status = 'open'`,
     surfaceId,

package/src/documents/document-store.ts

@@ -35,6 +35,7 @@ export function addDocumentConversation(
   conversationId: string,
 ): void {
   rawRun(
+    "documents:addDocumentConversation",
     /*sql*/ `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
     surfaceId,
     conversationId,
@@ -78,6 +79,7 @@ function mapRowToRecord(row: DocumentRow): DocumentRecord {
 export function getDocumentById(surfaceId: string): DocumentRecord | null {
   try {
     const row = rawGet<DocumentRow>(
+      "documents:getDocumentById",
       /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at
        FROM documents
        WHERE surface_id = ?`,
@@ -104,6 +106,7 @@ export function isDocumentAssociatedWithConversation(
 ): boolean {
   try {
     const row = rawGet<{ found: number }>(
+      "documents:isAssociatedWithConversation",
       /*sql*/ `
       SELECT 1 AS found
       FROM document_conversations
@@ -132,6 +135,7 @@ export function getDocumentsForConversation(
 ): Omit<DocumentRecord, "content">[] {
   try {
     const rows = rawAll<DocumentListRow>(
+      "documents:getDocumentsForConversation",
       /*sql*/ `
       SELECT d.surface_id, dc.conversation_id AS conversation_id,
              d.title, d.word_count, d.created_at, d.updated_at
@@ -175,6 +179,7 @@ export function searchDocumentsByTitle(
     const pattern = `%${escapeSqlLikePattern(query)}%`;
     const rows = options.conversationId
       ? rawAll<DocumentListRow>(
+          "documents:searchByTitle:scoped",
           /*sql*/ `
           SELECT d.surface_id, dc.conversation_id AS conversation_id,
                  d.title, d.word_count, d.created_at, d.updated_at
@@ -189,6 +194,7 @@ export function searchDocumentsByTitle(
           pattern,
         )
       : rawAll<DocumentListRow>(
+          "documents:searchByTitle:all",
           /*sql*/ `
           SELECT surface_id, conversation_id, title, word_count, created_at, updated_at
           FROM documents
@@ -234,6 +240,7 @@ export function findRecentEmptyDocumentByTitle(
   try {
     const threshold = Date.now() - withinMs;
     const row = rawGet<{ surface_id: string }>(
+      "documents:findRecentEmptyByTitle",
       /*sql*/ `SELECT surface_id FROM documents
        WHERE conversation_id = ?
          AND title = ?
@@ -262,10 +269,12 @@ export function findRecentEmptyDocumentByTitle(
 export function deleteDocument(surfaceId: string): boolean {
   try {
     const changes = rawRun(
+      "documents:deleteDocument:doc",
       /*sql*/ `DELETE FROM documents WHERE surface_id = ?`,
       surfaceId,
     );
     rawRun(
+      "documents:deleteDocument:associations",
       /*sql*/ `DELETE FROM document_conversations WHERE surface_id = ?`,
       surfaceId,
     );
@@ -310,6 +319,7 @@ export function findInDocument(
 ): FindResult | null {
   try {
     const row = rawGet<{ content: string }>(
+      "documents:findInDocument:getContent",
       /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
       surfaceId,
     );
@@ -385,6 +395,7 @@ export function saveDocument(params: {
   try {
     const now = Date.now();
     rawRun(
+      "documents:saveDocument",
       `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(surface_id) DO UPDATE SET
@@ -458,6 +469,7 @@ export function replaceInDocument(
 ): ReplaceInDocumentResult {
   try {
     const row = rawGet<{ content: string }>(
+      "documents:replaceInDocument:getContent",
       /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
       surfaceId,
     );
@@ -516,6 +528,7 @@ export function replaceInDocument(
       .split(/\s+/)
       .filter((w) => w.length > 0).length;
     rawRun(
+      "documents:replaceInDocument:update",
       /*sql*/ `UPDATE documents SET content = ?, word_count = ?, updated_at = ? WHERE surface_id = ?`,
       newContent,
       wordCount,
@@ -545,6 +558,7 @@ export function updateDocumentContent(
 ): { success: true } | { success: false; error: string } {
   try {
     const existing = rawGet<{ content: string }>(
+      "documents:updateDocumentContent:get",
       /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
       surfaceId,
     );
@@ -559,6 +573,7 @@ export function updateDocumentContent(
       .split(/\s+/)
       .filter((w) => w.length > 0).length;
     rawRun(
+      "documents:updateDocumentContent:update",
       /*sql*/ `UPDATE documents SET content = ?, word_count = ?, updated_at = ? WHERE surface_id = ?`,
       newContent,
       wordCount,

package/src/export/__tests__/transcript-formatter.test.ts

@@ -81,6 +81,17 @@ mock.module("../../persistence/conversation-crud.js", () => ({
   getMessages: (id: string) =>
     id === "child-conv-1" ? childMessages : parentMessages,
   messageMetadataSchema,
+  parseMessageMetadata: (json: string | null) => {
+    if (!json) {
+      return undefined;
+    }
+    try {
+      const parsed = messageMetadataSchema.safeParse(JSON.parse(json));
+      return parsed.success ? parsed.data : undefined;
+    } catch {
+      return undefined;
+    }
+  },
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 

package/src/export/transcript-formatter.ts

@@ -9,7 +9,7 @@ import { formatLocalTimestamp } from "../daemon/date-context.js";
 import {
   getConversation,
   getMessages,
-  messageMetadataSchema,
+  parseMessageMetadata,
 } from "../persistence/conversation-crud.js";
 import { truncate } from "../util/truncate.js";
 
@@ -29,7 +29,9 @@ function extractAnalysisText(blocks: ContentBlock[]): string {
   for (const block of blocks) {
     switch (block.type) {
       case "text":
-        if (block.text) parts.push(block.text);
+        if (block.text) {
+          parts.push(block.text);
+        }
         break;
       case "tool_use":
         parts.push(
@@ -141,6 +143,45 @@ export function formatMessageSliceForTranscript(
   return lines.join("\n");
 }
 
+/**
+ * Append the `### Subagent: …` section for `msg` when its metadata carries a
+ * terminal (completed/failed/aborted) subagent notification; a no-op otherwise.
+ *
+ * `subagentOptions` controls how the child transcript renders. Callers pass the
+ * parent's time zone but NOT its display names: a subagent conversation persists
+ * the parent assistant's objective as a `user` message (see subagent/manager.ts),
+ * so reusing the parent's names would render the assistant's tasking text under
+ * the human user's name. An empty options object keeps child transcripts on
+ * generic role labels.
+ */
+function appendSubagentSection(
+  lines: string[],
+  msg: TranscriptMessage,
+  subagentOptions: TranscriptFormatOptions = {},
+): void {
+  const notif = parseMessageMetadata(msg.metadata)?.subagentNotification;
+  if (
+    !notif ||
+    (notif.status !== "completed" &&
+      notif.status !== "failed" &&
+      notif.status !== "aborted") ||
+    !notif.conversationId
+  ) {
+    return;
+  }
+  const subMessages = getMessages(notif.conversationId);
+  lines.push(`### Subagent: ${notif.label} (${notif.status})`);
+  lines.push("");
+  lines.push(formatSubagentMessages(subMessages, subagentOptions));
+  lines.push("");
+}
+
+/**
+ * Render one message as a transcript block: a `## role (time)` header, the
+ * extracted body text, and any terminal subagent section. Role and time honor
+ * `options` (display names + time zone); the subagent child transcript inherits
+ * only the time zone — see {@link appendSubagentSection}.
+ */
 function appendMessageBlock(
   lines: string[],
   msg: TranscriptMessage,
@@ -155,35 +196,7 @@ function appendMessageBlock(
   lines.push(text);
   lines.push("");
 
-  if (msg.metadata) {
-    try {
-      const parsed = messageMetadataSchema.safeParse(JSON.parse(msg.metadata));
-      if (parsed.success && parsed.data.subagentNotification) {
-        const notif = parsed.data.subagentNotification;
-        if (
-          (notif.status === "completed" ||
-            notif.status === "failed" ||
-            notif.status === "aborted") &&
-          notif.conversationId
-        ) {
-          const subMessages = getMessages(notif.conversationId);
-          lines.push(`### Subagent: ${notif.label} (${notif.status})`);
-          lines.push("");
-          // Subagent conversations persist the parent assistant's objective
-          // as a `user` message (see subagent/manager.ts), so reusing the
-          // parent's display-name options would render the assistant's
-          // tasking text under the human user's name. Keep child transcripts
-          // on generic role labels — and only pass through the time zone.
-          lines.push(
-            formatSubagentMessages(subMessages, { timeZone: options.timeZone }),
-          );
-          lines.push("");
-        }
-      }
-    } catch {
-      // Skip unparseable metadata
-    }
-  }
+  appendSubagentSection(lines, msg, { timeZone: options.timeZone });
 }
 
 export function buildAnalysisTranscript(conversationId: string): string {
@@ -192,7 +205,6 @@ export function buildAnalysisTranscript(conversationId: string): string {
     return `# Conversation not found: ${conversationId}\n`;
   }
 
-  const allMessages = getMessages(conversationId);
   const title = conversation.title ?? "Untitled";
   const lines: string[] = [];
 
@@ -200,41 +212,11 @@ export function buildAnalysisTranscript(conversationId: string): string {
   lines.push(`Created: ${formatLocalTimestamp(conversation.createdAt)}`);
   lines.push("");
 
-  for (const msg of allMessages) {
-    const role = formatRole(msg.role);
-    const time = formatLocalTimestamp(msg.createdAt);
-    const content = parseContent(msg.content);
-    const text = extractAnalysisText(content);
-
-    lines.push(`## ${role} (${time})`);
-    lines.push(text);
-    lines.push("");
-
-    // Check for subagent notifications in metadata
-    if (msg.metadata) {
-      try {
-        const parsed = messageMetadataSchema.safeParse(
-          JSON.parse(msg.metadata),
-        );
-        if (parsed.success && parsed.data.subagentNotification) {
-          const notif = parsed.data.subagentNotification;
-          if (
-            (notif.status === "completed" ||
-              notif.status === "failed" ||
-              notif.status === "aborted") &&
-            notif.conversationId
-          ) {
-            const subMessages = getMessages(notif.conversationId);
-            lines.push(`### Subagent: ${notif.label} (${notif.status})`);
-            lines.push("");
-            lines.push(formatSubagentMessages(subMessages));
-            lines.push("");
-          }
-        }
-      } catch {
-        // Skip unparseable metadata
-      }
-    }
+  // Analyze-conversation flow renders under generic "User"/"Assistant" labels,
+  // so no options are threaded through (see `formatMessageSliceForTranscript`
+  // for the display-name variant).
+  for (const msg of getMessages(conversationId)) {
+    appendMessageBlock(lines, msg);
   }
 
   return lines.join("\n");