@mycadet/assistant 0.12.9 → 0.12.10

package/src/telemetry/turn-trace-store.test.ts

@@ -1,884 +0,0 @@
-/**
- * Tests for the turn-trace assembler.
- *
- * Verifies that a turn's transcript (user message, assistant responses, and
- * tool_result rows) plus its tool invocations are gathered into a faithful,
- * window-bounded trace, that the window stops at the next REAL user turn (and
- * never at the turn's own tool-result rows), that tool inputs/results are
- * captured verbatim (no field-level redaction), that coalesced-batch turns
- * trace their natural windows (head user-only, shared response on the final
- * batched turn — no batch inference), and that the size cap omits oversized
- * traces fail-closed.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// Control the live-conversation lookup so `isTurnSettled` can be exercised
-// without a running agent loop. Returns `undefined` (no live conversation) by
-// default; tests set a fake with a chosen `isProcessing()`.
-let mockLiveConversation:
-  | {
-      isProcessing: () => boolean;
-      getCurrentSystemPrompt?: () => string;
-      getRegisteredToolDefinitions?: () => Array<{
-        name: string;
-        description: string;
-        input_schema: object;
-      }>;
-    }
-  | undefined;
-mock.module("../daemon/conversation-registry.js", () => ({
-  findConversation: () => mockLiveConversation,
-}));
-
-import { createConversation } from "../persistence/conversation-crud.js";
-import { getDb } from "../persistence/db-connection.js";
-import { initializeDb } from "../persistence/db-init.js";
-import { messages, toolInvocations } from "../persistence/schema/index.js";
-import {
-  assembleBoundedTurnTrace,
-  assembleTurnTrace,
-  isTurnSettled,
-  MAX_TRACE_SERIALIZED_BYTES,
-  type TurnTraceBoundary,
-} from "./turn-trace-store.js";
-
-await initializeDb();
-
-function purge(): void {
-  const db = getDb();
-  db.run("DELETE FROM tool_invocations");
-  db.run("DELETE FROM messages");
-  db.run("DELETE FROM conversations");
-}
-
-beforeEach(() => {
-  purge();
-  mockLiveConversation = undefined;
-});
-
-interface MessageSeed {
-  id: string;
-  role: "user" | "assistant" | "system";
-  content: unknown;
-  createdAt: number;
-  /** Persisted `messages.metadata` bag; assistant rows carry `{ model }`. */
-  metadata?: Record<string, unknown>;
-}
-
-function insertMessage(conversationId: string, seed: MessageSeed): void {
-  getDb()
-    .insert(messages)
-    .values({
-      id: seed.id,
-      conversationId,
-      role: seed.role,
-      content:
-        typeof seed.content === "string"
-          ? seed.content
-          : JSON.stringify(seed.content),
-      createdAt: seed.createdAt,
-      metadata: seed.metadata ? JSON.stringify(seed.metadata) : null,
-    })
-    .run();
-}
-
-interface ToolSeed {
-  id: string;
-  toolName: string;
-  input: string;
-  result: string;
-  decision?: string;
-  durationMs?: number;
-  createdAt: number;
-}
-
-function insertTool(conversationId: string, seed: ToolSeed): void {
-  getDb()
-    .insert(toolInvocations)
-    .values({
-      id: seed.id,
-      conversationId,
-      toolName: seed.toolName,
-      input: seed.input,
-      result: seed.result,
-      decision: seed.decision ?? "allow",
-      riskLevel: "low",
-      durationMs: seed.durationMs ?? 5,
-      createdAt: seed.createdAt,
-    })
-    .run();
-}
-
-function boundary(
-  conversationId: string,
-  userMessageId: string,
-  createdAt: number,
-): TurnTraceBoundary {
-  return { conversationId, userMessageId, userMessageCreatedAt: createdAt };
-}
-
-describe("assembleTurnTrace", () => {
-  test("gathers user message, assistant responses, tool-result rows, and tool calls for a multi-message turn", () => {
-    const conv = createConversation({ conversationType: "standard" });
-
-    // Turn 1: user asks, assistant calls a tool, tool result lands as a
-    // role="user" row, assistant replies.
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "what's on my calendar?" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-1a",
-      role: "assistant",
-      content: [
-        {
-          type: "tool_use",
-          id: "tu-1",
-          name: "calendar_list_events",
-          input: { range: "today" },
-        },
-      ],
-      createdAt: 1100,
-      metadata: { model: "claude-fable-5" },
-    });
-    insertMessage(conv.id, {
-      id: "m-toolresult-1",
-      role: "user",
-      content: [
-        { type: "tool_result", tool_use_id: "tu-1", content: "2 events" },
-      ],
-      createdAt: 1200,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-1b",
-      role: "assistant",
-      content: [{ type: "text", text: "You have 2 events today." }],
-      createdAt: 1300,
-      metadata: { model: "claude-fable-5" },
-    });
-    insertTool(conv.id, {
-      id: "ti-1",
-      toolName: "calendar_list_events",
-      input: JSON.stringify({ range: "today" }),
-      result: JSON.stringify({ events: 2 }),
-      createdAt: 1150,
-    });
-
-    // Turn 2: next real user turn — must NOT be in turn 1's trace.
-    insertMessage(conv.id, {
-      id: "m-user-2",
-      role: "user",
-      content: [{ type: "text", text: "thanks" }],
-      createdAt: 2000,
-    });
-    insertTool(conv.id, {
-      id: "ti-2",
-      toolName: "noop",
-      input: "{}",
-      result: "{}",
-      createdAt: 2100,
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-
-    expect(trace.schema_version).toBe(3);
-    // Window stops before turn 2: only turn-1 message rows, oldest-first.
-    expect(trace.messages.map((m) => m.id)).toEqual([
-      "m-user-1",
-      "m-asst-1a",
-      "m-toolresult-1",
-      "m-asst-1b",
-    ]);
-    // Model attribution is per message, from `metadata.model` (the served
-    // `response.model` persisted with the finalized content): assistant rows
-    // carry it, user and tool-result rows carry null.
-    expect(trace.messages.map((m) => [m.id, m.model])).toEqual([
-      ["m-user-1", null],
-      ["m-asst-1a", "claude-fable-5"],
-      ["m-toolresult-1", null],
-      ["m-asst-1b", "claude-fable-5"],
-    ]);
-    // The tool-result row keeps role="user" (faithful to what the model saw).
-    const toolResultMsg = trace.messages.find((m) => m.id === "m-toolresult-1");
-    expect(toolResultMsg?.role).toBe("user");
-    // Content is parsed JSON (ContentBlock[]), not a string.
-    expect(Array.isArray(toolResultMsg?.content)).toBe(true);
-
-    // Only turn-1's tool invocation is in scope.
-    expect(trace.tool_calls.map((t) => t.id)).toEqual(["ti-1"]);
-    expect(trace.tool_calls[0]).toMatchObject({
-      tool_name: "calendar_list_events",
-      decision: "allow",
-      duration_ms: 5,
-      created_at: 1150,
-    });
-    // Result is forwarded verbatim.
-    expect(trace.tool_calls[0].result).toBe(JSON.stringify({ events: 2 }));
-  });
-
-  test("attributes each assistant row to the model that served it when a hook reroutes mid-turn", () => {
-    // A pre-model-call hook reroutes the SECOND call in the turn, so the two
-    // assistant rows carry different served models — attribution stays faithful
-    // per message.
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "hello" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-1a",
-      role: "assistant",
-      content: [{ type: "tool_use", id: "tu-1", name: "noop", input: {} }],
-      createdAt: 1100,
-      metadata: { model: "claude-fable-5" },
-    });
-    insertMessage(conv.id, {
-      id: "m-toolresult-1",
-      role: "user",
-      content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
-      createdAt: 1200,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-1b",
-      role: "assistant",
-      content: [{ type: "text", text: "done" }],
-      createdAt: 1300,
-      metadata: { model: "claude-opus-4-8" },
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-
-    expect(trace.messages.map((m) => [m.id, m.model])).toEqual([
-      ["m-user-1", null],
-      ["m-asst-1a", "claude-fable-5"],
-      ["m-toolresult-1", null],
-      ["m-asst-1b", "claude-opus-4-8"],
-    ]);
-  });
-
-  test("per-message model is null for rows with no stamped model (historical / missing metadata)", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "hello" }],
-      createdAt: 1000,
-    });
-    // Assistant row with no metadata at all (historical row before stamping).
-    insertMessage(conv.id, {
-      id: "m-asst-1",
-      role: "assistant",
-      content: [{ type: "text", text: "hi" }],
-      createdAt: 1100,
-    });
-    // Assistant row whose metadata bag omits `model`.
-    insertMessage(conv.id, {
-      id: "m-asst-2",
-      role: "assistant",
-      content: [{ type: "text", text: "again" }],
-      createdAt: 1200,
-      metadata: { provenanceTrustClass: "unknown" },
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-
-    expect(trace.messages.map((m) => m.model)).toEqual([null, null, null]);
-  });
-
-  test("includes system_prompt and tool_definitions from the live conversation", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "hello" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-1",
-      role: "assistant",
-      content: [{ type: "text", text: "hi" }],
-      createdAt: 1100,
-    });
-
-    // The conversation resolves + sorts its registered tools; trace assembly
-    // just maps them into the trace, so feed it already-resolved definitions.
-    mockLiveConversation = {
-      isProcessing: () => false,
-      getCurrentSystemPrompt: () => "You are a helpful assistant.",
-      getRegisteredToolDefinitions: () => [
-        { name: "file_read", description: "Read a file", input_schema: {} },
-        { name: "notify_parent", description: "", input_schema: {} },
-        { name: "web_search", description: "Search the web", input_schema: {} },
-      ],
-    };
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-
-    expect(trace.system_prompt).toBe("You are a helpful assistant.");
-    expect(trace.tool_definitions).toEqual([
-      { name: "file_read", description: "Read a file", input_schema: {} },
-      { name: "notify_parent", description: "", input_schema: {} },
-      { name: "web_search", description: "Search the web", input_schema: {} },
-    ]);
-  });
-
-  test("system_prompt is null and tool_definitions is empty when conversation is evicted", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "hello" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-1",
-      role: "assistant",
-      content: [{ type: "text", text: "hi" }],
-      createdAt: 1100,
-    });
-
-    // No mockLiveConversation set — simulates evicted conversation.
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-
-    expect(trace.system_prompt).toBeNull();
-    expect(trace.tool_definitions).toEqual([]);
-  });
-
-  test("the final turn's window runs to the end of the conversation", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "first" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-2",
-      role: "user",
-      content: [{ type: "text", text: "second (latest)" }],
-      createdAt: 2000,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-2",
-      role: "assistant",
-      content: [{ type: "text", text: "reply to second" }],
-      createdAt: 2100,
-    });
-    insertTool(conv.id, {
-      id: "ti-late",
-      toolName: "noop",
-      input: "{}",
-      result: "ok",
-      createdAt: 2200,
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-2", 2000));
-    expect(trace.messages.map((m) => m.id)).toEqual(["m-user-2", "m-asst-2"]);
-    expect(trace.tool_calls.map((t) => t.id)).toEqual(["ti-late"]);
-  });
-
-  test("two real user turns sharing created_at: the first turn's trace is not truncated and excludes the second turn", () => {
-    // Forked conversations preserve the source `created_at` with fresh ids, so
-    // two real user messages can share a millisecond. A timestamp-only upper
-    // bound would equal the current turn's own `created_at` and empty the
-    // window — the compound `(created_at, id)` bound must keep this turn's rows
-    // (which sort by id at the shared millisecond) while excluding the next.
-    const conv = createConversation({ conversationType: "standard" });
-
-    // Turn 1 (id "m-user-1") and turn 2 (id "m-user-2") share created_at=1000.
-    // Turn 1's assistant reply, tool-result row, and tool call also land at
-    // 1000 — the worst case for a timestamp-only bound.
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "first (same ms)" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-1-asst",
-      role: "assistant",
-      content: [{ type: "text", text: "reply to first" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-1-toolresult",
-      role: "user",
-      content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
-      createdAt: 1000,
-    });
-    insertTool(conv.id, {
-      id: "ti-turn1",
-      toolName: "noop",
-      input: "{}",
-      result: "r1",
-      createdAt: 1000,
-    });
-
-    // Turn 2 user message + its content, same created_at=1000 (higher id).
-    insertMessage(conv.id, {
-      id: "m-user-2",
-      role: "user",
-      content: [{ type: "text", text: "second (same ms)" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-2-asst",
-      role: "assistant",
-      content: [{ type: "text", text: "reply to second" }],
-      createdAt: 1000,
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-
-    // Turn 1's rows (ids < "m-user-2" at ms 1000) are present; the trace is
-    // NOT truncated/emptied. The second user turn and its reply are excluded.
-    expect(trace.messages.map((m) => m.id)).toEqual([
-      "m-user-1",
-      "m-user-1-asst",
-      "m-user-1-toolresult",
-    ]);
-    // Turn 1's same-millisecond tool call is retained (degenerate `<=` window).
-    expect(trace.tool_calls.map((t) => t.id)).toEqual(["ti-turn1"]);
-  });
-
-  test("the SECOND of two same-created_at turns captures its own trace to end of conversation", () => {
-    // Complement of the previous test: assembling the trace for the later of
-    // two same-millisecond user turns must include only that turn's rows.
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "first (same ms)" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-1-asst",
-      role: "assistant",
-      content: [{ type: "text", text: "reply to first" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-2",
-      role: "user",
-      content: [{ type: "text", text: "second (same ms, latest)" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-2-asst",
-      role: "assistant",
-      content: [{ type: "text", text: "reply to second" }],
-      createdAt: 1100,
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-2", 1000));
-    expect(trace.messages.map((m) => m.id)).toEqual([
-      "m-user-2",
-      "m-user-2-asst",
-    ]);
-  });
-
-  test("a tool-result role=user row does NOT truncate the turn it belongs to", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "do a thing" }],
-      createdAt: 1000,
-    });
-    // Tool-result row persisted as role="user" — must be treated as part of
-    // the turn, not as the next user turn.
-    insertMessage(conv.id, {
-      id: "m-toolresult",
-      role: "user",
-      content: [{ type: "tool_result", tool_use_id: "tu-x", content: "done" }],
-      createdAt: 1100,
-    });
-    insertMessage(conv.id, {
-      id: "m-asst-after-result",
-      role: "assistant",
-      content: [{ type: "text", text: "all done" }],
-      createdAt: 1200,
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-    // All three rows belong to the single turn — the tool-result row did not
-    // close the window early.
-    expect(trace.messages.map((m) => m.id)).toEqual([
-      "m-user-1",
-      "m-toolresult",
-      "m-asst-after-result",
-    ]);
-  });
-
-  test("captures tool inputs verbatim — no field-level redaction, even for credential-shaped keys", () => {
-    // The consented trace is full-fidelity. Keys that look sensitive
-    // (access_token, api_key) are NOT redacted — the protections are the
-    // consent gate, the PII-segregated table, and its TTL, not redaction.
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "use my token" }],
-      createdAt: 1000,
-    });
-    const rawInput = {
-      url: "https://api.example.com",
-      access_token: "super-secret-value",
-      nested: { api_key: "also-secret" },
-    };
-    insertTool(conv.id, {
-      id: "ti-secret",
-      toolName: "http_request",
-      input: JSON.stringify(rawInput),
-      result: JSON.stringify({ status: 200 }),
-      createdAt: 1100,
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-    const call = trace.tool_calls[0];
-    // Parsed input matches the raw stored input exactly — including the
-    // credential-shaped values, which are present verbatim (not redacted).
-    expect(call.input).toEqual(rawInput);
-    const input = call.input as Record<string, unknown>;
-    expect(input.access_token).toBe("super-secret-value");
-    expect((input.nested as Record<string, unknown>).api_key).toBe(
-      "also-secret",
-    );
-    expect(JSON.stringify(call.input)).not.toContain("<redacted />");
-    // Result is also forwarded verbatim.
-    expect(call.result).toBe(JSON.stringify({ status: 200 }));
-  });
-
-  test("non-JSON tool input is forwarded as a raw string", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "hi" }],
-      createdAt: 1000,
-    });
-    insertTool(conv.id, {
-      id: "ti-raw",
-      toolName: "bash",
-      input: "ls -la /tmp",
-      result: "ok",
-      createdAt: 1100,
-    });
-
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-    expect(trace.tool_calls[0].input).toBe("ls -la /tmp");
-  });
-
-  test("legacy plain-string message content is forwarded as a string", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    // A legacy row stored the content as a bare (JSON) string, not a block
-    // array. JSON.parse of a quoted string yields a string; an unquoted
-    // legacy value falls back to the raw string.
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: "plain legacy text",
-      createdAt: 1000,
-    });
-    const trace = assembleTurnTrace(boundary(conv.id, "m-user-1", 1000));
-    expect(trace.messages[0].content).toBe("plain legacy text");
-  });
-
-  test("scopes the trace to a single conversation", () => {
-    const a = createConversation({ conversationType: "standard" });
-    const b = createConversation({ conversationType: "standard" });
-    insertMessage(a.id, {
-      id: "m-a-user",
-      role: "user",
-      content: [{ type: "text", text: "in A" }],
-      createdAt: 1000,
-    });
-    insertMessage(b.id, {
-      id: "m-b-user",
-      role: "user",
-      content: [{ type: "text", text: "in B" }],
-      createdAt: 1050,
-    });
-    insertTool(b.id, {
-      id: "ti-b",
-      toolName: "noop",
-      input: "{}",
-      result: "ok",
-      createdAt: 1060,
-    });
-
-    const trace = assembleTurnTrace(boundary(a.id, "m-a-user", 1000));
-    expect(trace.messages.map((m) => m.id)).toEqual(["m-a-user"]);
-    // Tool calls from conversation B never leak into A's trace.
-    expect(trace.tool_calls).toEqual([]);
-  });
-});
-
-describe("assembleTurnTrace — coalesced-batch natural windows", () => {
-  // The daemon coalesces queued user messages: drainBatch persists every
-  // batched user row, then runs ONE shared response attributed to the LAST
-  // batched user row. On disk: [u1][u2][u3][assistant + tools][u4][assistant2].
-  // No batch inference is attempted (there is no durable batch signal in the
-  // stored messages, and a batch head is indistinguishable from a turn that
-  // failed/cancelled before responding). Each turn just traces its natural
-  // window, which is faithful.
-  function seedThreeMessageBatch(convId: string): void {
-    insertMessage(convId, {
-      id: "u1",
-      role: "user",
-      content: [{ type: "text", text: "first batched" }],
-      createdAt: 1000,
-    });
-    insertMessage(convId, {
-      id: "u2",
-      role: "user",
-      content: [{ type: "text", text: "second batched" }],
-      createdAt: 1010,
-    });
-    insertMessage(convId, {
-      id: "u3",
-      role: "user",
-      content: [{ type: "text", text: "third batched (final)" }],
-      createdAt: 1020,
-    });
-    // Shared response written AFTER the last batched user row, with a tool call.
-    insertMessage(convId, {
-      id: "a-shared",
-      role: "assistant",
-      content: [
-        { type: "tool_use", id: "tu-1", name: "calendar", input: {} },
-        { type: "text", text: "shared reply to all three" },
-      ],
-      createdAt: 1030,
-    });
-    insertMessage(convId, {
-      id: "a-shared-toolresult",
-      role: "user",
-      content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
-      createdAt: 1040,
-    });
-    insertTool(convId, {
-      id: "ti-shared",
-      toolName: "calendar",
-      input: "{}",
-      result: "ok",
-      createdAt: 1035,
-    });
-  }
-
-  test("a batched HEAD turn's trace contains only its own user row (faithful, no batch field)", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    seedThreeMessageBatch(conv.id);
-
-    const trace = assembleTurnTrace(boundary(conv.id, "u1", 1000));
-    // Natural window: just the head's own user row. Its window genuinely has no
-    // assistant response (the shared response is on the final batched turn).
-    expect(trace.messages.map((m) => m.id)).toEqual(["u1"]);
-    expect(trace.tool_calls).toEqual([]);
-    // No batch inference: the response is not duplicated onto the head, and the
-    // trace carries no `batch` field.
-    expect(JSON.stringify(trace)).not.toContain("shared reply to all three");
-    expect("batch" in trace).toBe(false);
-  });
-
-  test("a batched MIDDLE turn's trace also contains only its own user row", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    seedThreeMessageBatch(conv.id);
-
-    const trace = assembleTurnTrace(boundary(conv.id, "u2", 1010));
-    expect(trace.messages.map((m) => m.id)).toEqual(["u2"]);
-    expect(trace.tool_calls).toEqual([]);
-    expect("batch" in trace).toBe(false);
-  });
-
-  test("the FINAL batched turn's trace contains the shared assistant response + tools", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    seedThreeMessageBatch(conv.id);
-
-    // The shared response is attributed by the daemon to the last batched user
-    // row (lastUserMessageId == u3); u3's natural window includes it.
-    const trace = assembleTurnTrace(boundary(conv.id, "u3", 1020));
-    expect(trace.messages.map((m) => m.id)).toEqual([
-      "u3",
-      "a-shared",
-      "a-shared-toolresult",
-    ]);
-    expect(trace.tool_calls.map((t) => t.id)).toEqual(["ti-shared"]);
-    expect("batch" in trace).toBe(false);
-  });
-});
-
-describe("assembleBoundedTurnTrace", () => {
-  test("returns the trace when under the size cap", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "small" }],
-      createdAt: 1000,
-    });
-    const trace = assembleBoundedTurnTrace(boundary(conv.id, "m-user-1", 1000));
-    expect(trace).not.toBeNull();
-    expect(trace?.messages.map((m) => m.id)).toEqual(["m-user-1"]);
-  });
-
-  test("omits (returns null) when the serialized trace exceeds the cap", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "huge" }],
-      createdAt: 1000,
-    });
-    // A single oversized tool result pushes the trace past the cap.
-    insertTool(conv.id, {
-      id: "ti-huge",
-      toolName: "dump",
-      input: "{}",
-      result: "x".repeat(MAX_TRACE_SERIALIZED_BYTES + 1024),
-      createdAt: 1100,
-    });
-
-    const trace = assembleBoundedTurnTrace(boundary(conv.id, "m-user-1", 1000));
-    expect(trace).toBeNull();
-  });
-});
-
-describe("isTurnSettled", () => {
-  test("batched head with a later real user row is NOT settled while the conversation is processing", () => {
-    // Batched-message path: drainBatch persists the head user row AND the tail
-    // user row(s) up front, then runs ONE shared response. So the head has a
-    // later real user turn while the shared response is still in flight — it
-    // must NOT be treated as settled (the old "successor exists" shortcut would
-    // have shipped a partial trace for the head).
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "head of batch" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-2",
-      role: "user",
-      content: [{ type: "text", text: "tail of batch" }],
-      createdAt: 2000,
-    });
-    // Shared response still generating.
-    mockLiveConversation = { isProcessing: () => true };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(false);
-    // The tail (latest turn) is likewise deferred while processing.
-    expect(isTurnSettled(boundary(conv.id, "m-user-2", 2000))).toBe(false);
-  });
-
-  test("the batched head settles once the shared response completes (conversation idle)", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "head of batch" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-2",
-      role: "user",
-      content: [{ type: "text", text: "tail of batch" }],
-      createdAt: 2000,
-    });
-    // Shared response finished -> conversation idle -> both turns settle.
-    mockLiveConversation = { isProcessing: () => false };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(true);
-    expect(isTurnSettled(boundary(conv.id, "m-user-2", 2000))).toBe(true);
-  });
-
-  test("a completed earlier turn defers while a later turn's response is in flight, then settles when idle", () => {
-    // Serialized (non-batch) path: T1 finished, T2 now generating. Gating on
-    // isProcessing() defers T1 until the conversation goes idle. This is a
-    // latency cost, not data loss — T1 traces completely once T2 finishes.
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "first (done)" }],
-      createdAt: 1000,
-    });
-    insertMessage(conv.id, {
-      id: "m-user-2",
-      role: "user",
-      content: [{ type: "text", text: "second (generating)" }],
-      createdAt: 2000,
-    });
-    mockLiveConversation = { isProcessing: () => true };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(false);
-
-    // Conversation goes idle -> the earlier turn settles promptly.
-    mockLiveConversation = { isProcessing: () => false };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(true);
-  });
-
-  test("settledness follows the conversation's processing state regardless of intervening tool-result rows", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "do a thing" }],
-      createdAt: 1000,
-    });
-    // Tool-result row persisted as role="user" — part of this turn's response.
-    insertMessage(conv.id, {
-      id: "m-toolresult",
-      role: "user",
-      content: [{ type: "tool_result", tool_use_id: "tu-x", content: "done" }],
-      createdAt: 1100,
-    });
-    // Still generating -> not settled.
-    mockLiveConversation = { isProcessing: () => true };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(false);
-    // Response finished -> settled.
-    mockLiveConversation = { isProcessing: () => false };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(true);
-  });
-
-  test("NOT settled when this is the latest real user turn and the conversation is processing", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "still generating" }],
-      createdAt: 1000,
-    });
-    // Latest real turn + live conversation actively processing -> in-flight.
-    mockLiveConversation = { isProcessing: () => true };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(false);
-  });
-
-  test("settled when this is the latest real user turn but the conversation is idle (final turn)", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "final turn" }],
-      createdAt: 1000,
-    });
-    mockLiveConversation = { isProcessing: () => false };
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(true);
-  });
-
-  test("settled when the conversation is not in the live registry (evicted / not loaded)", () => {
-    const conv = createConversation({ conversationType: "standard" });
-    insertMessage(conv.id, {
-      id: "m-user-1",
-      role: "user",
-      content: [{ type: "text", text: "from an evicted conversation" }],
-      createdAt: 1000,
-    });
-    // No live conversation -> no in-flight turn -> settled.
-    mockLiveConversation = undefined;
-    expect(isTurnSettled(boundary(conv.id, "m-user-1", 1000))).toBe(true);
-  });
-});