@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/history-pages.test.ts

@@ -0,0 +1,619 @@
+import { test, type TestContext } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { historyPage, historyMessage, HistoryError } from "./history-pages.ts";
+import { PAGE_BYTES } from "../shared/message-window.ts";
+import { getSessionMessages, getSubagentMessages, InMemorySessionStore } from "@anthropic-ai/claude-agent-sdk";
+
+const rec = (uuid: string, parentUuid: string | null, type = "user", extra: object = {}) => ({ type, uuid, parentUuid, message: { role: type, content: uuid }, ...extra });
+type HistoryRecord = { type: string; [key: string]: unknown };
+async function fixture(t: TestContext, records: object[]) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "ide-history-"));
+  t.after(() => fs.rm(dir, { recursive: true, force: true }));
+  const file = path.join(dir, "session.jsonl");
+  await fs.writeFile(file, records.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  return file;
+}
+
+test("pages walk both ways across the summary without duplicating boundaries", async (t) => {
+  const records: object[] = [];
+  let parent: string | null = null;
+  for (let i = 0; i < 250; i++) {
+    if (i === 130) {
+      records.push(rec("compact", null, "system", { subtype: "compact_boundary", logicalParentUuid: parent })); parent = "compact";
+      records.push(rec("summary", parent, "user", { isCompactSummary: true })); parent = "summary";
+    }
+    records.push(rec(`u${i}`, parent)); parent = `u${i}`;
+  }
+  const file = await fixture(t, records);
+  const newest = await historyPage(file);
+  assert.equal(newest.items.length, 100);
+  assert.equal(newest.items.at(-1)?.uuid, "u249");
+  const middle = await historyPage(file, { cursor: newest.older });
+  const oldest = await historyPage(file, { cursor: middle.older });
+  const ids = [...oldest.items, ...middle.items, ...newest.items].map((m) => m.uuid);
+  assert.equal(ids.length, 252);
+  assert.equal(new Set(ids).size, 252);
+  assert.equal(oldest.older, undefined);
+  const forward = await historyPage(file, { cursor: oldest.newer });
+  assert.deepEqual(forward.items.map((m) => m.uuid), middle.items.map((m) => m.uuid));
+});
+
+test("branch selection and pending rewind never expose the abandoned branch", async (t) => {
+  const file = await fixture(t, [rec("root", null), rec("old", "root", "assistant"), rec("new", "root"), rec("answer", "new", "assistant")]);
+  assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), ["root", "new", "answer"]);
+  assert.deepEqual((await historyPage(file, { anchor: "root" })).items.map((m) => m.uuid), ["root"]);
+  await assert.rejects(historyMessage(file, "old"), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("preserved message rewrites retain both the summary and the earlier conversation", async (t) => {
+  const file = await fixture(t, [rec("u0", null), rec("a0", "u0", "assistant"), rec("u1", "a0"), rec("a1", "u1", "assistant"),
+    rec("boundary", null, "system", { subtype: "compact_boundary", logicalParentUuid: "a1", compactMetadata: { preservedMessages: { anchorUuid: "summary", uuids: ["u1", "a1"] } } }),
+    rec("summary", "boundary", "user", { isCompactSummary: true }), rec("u2", "summary"), rec("a2", "u2", "assistant")]);
+  const ids = (await historyPage(file)).items.map((m) => m.uuid);
+  assert.deepEqual(new Set(ids), new Set(["u0", "a0", "u1", "a1", "boundary", "summary", "u2", "a2"]));
+  assert.equal(ids.length, 8);
+});
+
+test("append indexing retries partial lines and concurrent readers share the update", async (t) => {
+  const file = await fixture(t, [rec("u0", null)]);
+  await historyPage(file);
+  const next = JSON.stringify(rec("u1", "u0"));
+  await fs.appendFile(file, next.slice(0, 25));
+  assert.equal((await historyPage(file)).items.length, 1);
+  await fs.appendFile(file, next.slice(25) + "\n");
+  const pages = await Promise.all(Array.from({ length: 4 }, () => historyPage(file)));
+  assert.ok(pages.every((p) => p.items.length === 2));
+});
+
+test("file replacement invalidates old cursors", async (t) => {
+  const file = await fixture(t, Array.from({ length: 110 }, (_, i) => rec(`u${i}`, i ? `u${i - 1}` : null)));
+  const page = await historyPage(file);
+  await fs.writeFile(file, JSON.stringify(rec("replacement", null)) + "\n");
+  await assert.rejects(historyPage(file, { cursor: page.older }), (e) => e instanceof HistoryError && e.status === 409);
+});
+
+test("oversized inline images become placeholders and can be hydrated from the original record", async (t) => {
+  const record = rec("image", null, "user", { message: { content: [{ type: "image", source: { media_type: "image/jpeg", data: "x".repeat(800_000) } }, { type: "text", text: "hello" }] } });
+  const file = await fixture(t, [record]);
+  const page = await historyPage(file);
+  assert.ok(JSON.stringify(page).length < PAGE_BYTES);
+  assert.ok(page.items[0]?._deferred);
+  assert.deepEqual((await historyMessage(file, "image")).message, record.message);
+});
+
+test("visible tools get their results even when the result falls on a different page", async (t) => {
+  const records = [rec("call", null, "assistant", { message: { content: [{ type: "tool_use", id: "t1", name: "Bash", input: { command: "pwd" } }] } })];
+  for (let i = 0; i < 110; i++) records.push(rec(`u${i}`, i ? `u${i - 1}` : "call"));
+  records.push(rec("tool-result", "u109", "user", { message: { content: [{ type: "tool_result", tool_use_id: "t1", content: "output" }] } }));
+  const file = await fixture(t, records);
+  const page = await historyPage(file, { after: "call" });
+  const previous = await historyPage(file, { cursor: page.older });
+  assert.equal((previous.items[0]?.linkedToolResults as Record<string, { content: string }>)?.t1?.content, "output");
+  assert.deepEqual(previous.items[0]?._toolResultUuids, { t1: "tool-result" });
+});
+
+test("subagent transcripts may be sidechains without being hidden", async (t) => {
+  const file = await fixture(t, [rec("u0", null, "user", { isSidechain: true }), rec("a0", "u0", "assistant", { isSidechain: true })]);
+  assert.equal((await historyPage(file, { sidechain: true })).items.length, 2);
+  assert.equal((await historyPage(file)).items.length, 0);
+  assert.equal((await historyMessage(file, "a0", undefined, true)).uuid, "a0");
+});
+
+test("rewinding to a preserved message ignores compactions written after that anchor", async (t) => {
+  const file = await fixture(t, [rec("u0", null), rec("u1", "u0"), rec("future", "u1", "assistant"),
+    rec("boundary", null, "system", { subtype: "compact_boundary", logicalParentUuid: "future", compactMetadata: { preservedMessages: { anchorUuid: "summary", uuids: ["u1", "future"] } } }),
+    rec("summary", "boundary", "user"), rec("u2", "summary")]);
+  assert.deepEqual((await historyPage(file, { anchor: "u1" })).items.map((m) => m.uuid), ["u0", "u1"]);
+});
+
+test("todo state is independent of the currently loaded history page", async (t) => {
+  const records = [rec("create", null, "assistant", { message: { content: [{ type: "tool_use", id: "create-tool", name: "TaskCreate", input: { subject: "first task" } }] } }),
+    rec("created", "create", "user", { message: { content: [{ type: "tool_result", tool_use_id: "create-tool", content: "Task #42 created successfully" }] } }),
+    rec("update", "created", "assistant", { message: { content: [{ type: "tool_use", id: "update-tool", name: "TaskUpdate", input: { taskId: "42", status: "completed" } }] } })];
+  for (let i = 0; i < 110; i++) records.push(rec(`u${i}`, i ? `u${i - 1}` : "update"));
+  const file = await fixture(t, records);
+  const page = await historyPage(file);
+  assert.equal(page.items.some((m) => m.uuid === "create"), false);
+  assert.deepEqual(page.todos, [{ id: "42", subject: "first task", status: "completed", activeForm: undefined }]);
+  assert.deepEqual((await historyPage(file, { cursor: page.older })).todos, page.todos);
+});
+
+test("assistant sibling blocks and their results match the SDK across pages and message reads (CACHE-005)", async (t) => {
+  const assistant = (uuid: string, parent: string, id: string, content: unknown[], timestamp: string) => rec(uuid, parent, "assistant", { message: { id, role: "assistant", content }, timestamp });
+  const records = [rec("root", null),
+    assistant("thinking", "root", "api-message", [{ type: "thinking", thinking: "reasoning" }], "2026-10-01T00:00:01Z"),
+    assistant("tool", "root", "api-message", [{ type: "tool_use", id: "tool-id", name: "Bash", input: { command: "pwd" } }], "2026-10-01T00:00:02Z"),
+    assistant("text", "root", "api-message", [{ type: "text", text: "answer" }], "2026-10-01T00:00:03Z"),
+    rec("result", "tool", "user", { message: { content: [{ type: "tool_result", tool_use_id: "tool-id", content: "output" }] }, timestamp: "2026-10-01T00:00:04Z" }),
+    assistant("abandoned", "root", "other-message", [{ type: "text", text: "old branch" }], "2026-10-01T00:00:05Z")];
+  for (let i = 0; i < 110; i++) records.push(rec(`u${i}`, i ? `u${i - 1}` : "text"));
+  const file = await fixture(t, records);
+  const store = new InMemorySessionStore();
+  store.load = async () => records;
+  const expected = (await getSessionMessages("12345678-1234-1234-1234-123456789abc", { dir: "/tmp", sessionStore: store })).map((m) => m.uuid);
+  const latest = await historyPage(file);
+  const older = await historyPage(file, { cursor: latest.older });
+  assert.deepEqual([...older.items, ...latest.items].map((m) => m.uuid), expected);
+  assert.deepEqual((await historyPage(file, { cursor: older.newer })).items.map((m) => m.uuid), latest.items.map((m) => m.uuid));
+  assert.equal(new Set(expected).size, expected.length);
+  for (const uuid of ["thinking", "tool", "result"]) assert.equal((await historyMessage(file, uuid)).uuid, uuid);
+  assert.equal((older.items.find((m) => m.uuid === "tool")?.linkedToolResults as Record<string, { content: string }>)["tool-id"]?.content, "output");
+  await assert.rejects(historyMessage(file, "abandoned"), (e) => e instanceof HistoryError && e.status === 404);
+  const rewind = await historyPage(file, { anchor: "text" });
+  assert.deepEqual(rewind.items.map((m) => m.uuid), ["root", "text", "thinking", "tool"]);
+  await assert.rejects(historyMessage(file, "result", "text"), (e) => e instanceof HistoryError && e.status === 404);
+  assert.deepEqual((await historyPage(file, { anchor: "root" })).items.map((m) => m.uuid), ["root"]);
+});
+
+test("off-chain tool results use SDK source and tool-id association without crossing agents (CACHE-005)", async (t) => {
+  const records = [rec("root", null),
+    rec("call", "root", "assistant", { message: { id: "api-message", content: [{ type: "tool_use", id: "tool-id", name: "Bash", input: {} }] } }),
+    rec("result", "root", "user", { sourceToolAssistantUUID: "call", message: { content: [{ type: "tool_result", tool_use_id: "tool-id", content: "done" }] } }),
+    rec("foreign-result", "root", "user", { agentId: "foreign", sourceToolAssistantUUID: "call", message: { content: [{ type: "tool_result", tool_use_id: "tool-id", content: "foreign" }] } }),
+    rec("answer", "call", "assistant", { message: { id: "answer-message", content: [{ type: "text", text: "answer" }] } })];
+  const file = await fixture(t, records);
+  const store = new InMemorySessionStore(); store.load = async () => records;
+  const expected = (await getSessionMessages("12345678-1234-1234-1234-123456789abc", { dir: "/tmp", sessionStore: store })).map((m) => m.uuid);
+  const page = await historyPage(file);
+  assert.deepEqual(page.items.map((m) => m.uuid), expected);
+  assert.equal((await historyMessage(file, "result")).uuid, "result");
+  await assert.rejects(historyMessage(file, "foreign-result"), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("LRU eviction preserves cursors for unchanged files and ordinary appends (CACHE-010)", async (t) => {
+  const file = await fixture(t, Array.from({ length: 110 }, (_, i) => rec(`u${i}`, i ? `u${i - 1}` : null)));
+  const page = await historyPage(file);
+  for (let i = 0; i < 9; i++) await historyPage(await fixture(t, [rec(`other-${i}`, null)]));
+  const older = await historyPage(file, { cursor: page.older });
+  assert.equal(older.generation, page.generation);
+  assert.equal(older.items[0]?.uuid, "u0");
+  await fs.appendFile(file, JSON.stringify(rec("appended", "u109")) + "\n");
+  for (let i = 0; i < 9; i++) await historyPage(await fixture(t, [rec(`later-${i}`, null)]));
+  const afterAppend = await historyPage(file, { cursor: page.older });
+  assert.equal(afterAppend.generation, page.generation);
+  assert.equal(afterAppend.items[0]?.uuid, "u0");
+});
+
+test("a self-evicted over-budget index can still page backwards and forwards (CACHE-010)", async (t) => {
+  const file = await fixture(t, Array.from({ length: 140_000 }, (_, i) => rec(String(i), i ? String(i - 1) : null)));
+  const page = await historyPage(file);
+  const older = await historyPage(file, { cursor: page.older });
+  const forward = await historyPage(file, { cursor: older.newer });
+  assert.equal(older.generation, page.generation);
+  assert.deepEqual(forward.items.map((m) => m.uuid), page.items.map((m) => m.uuid));
+});
+
+test("in-place rewrites after index eviction get a new generation and reject old cursors (CACHE-010)", async (t) => {
+  const records = Array.from({ length: 110 }, (_, i) => rec(`u${i}`, i ? `u${i - 1}` : null));
+  const file = await fixture(t, records);
+  const page = await historyPage(file);
+  for (let i = 0; i < 9; i++) await historyPage(await fixture(t, [rec(`other-${i}`, null)]));
+  // Preserve every UUID and the file size, so generation must detect a body rewrite.
+  const rewritten = records.map((r) => ({ ...r, message: { ...r.message, content: r.message.content.replace("u", "v") } }));
+  await fs.writeFile(file, rewritten.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  await assert.rejects(historyPage(file, { cursor: page.older }), (e) => e instanceof HistoryError && e.status === 409);
+  const fresh = await historyPage(file);
+  assert.notEqual(fresh.generation, page.generation);
+  for (let i = 0; i < 9; i++) await historyPage(await fixture(t, [rec(`later-${i}`, null)]));
+  assert.equal((await historyPage(file, { cursor: fresh.older })).generation, fresh.generation);
+  // A larger replacement must not be mistaken for an append when its prefix changed.
+  const expanded = [...records.map((r) => ({ ...r, message: { ...r.message, content: `replaced ${r.message.content}` } })), rec("new-tail", "u109")];
+  await fs.writeFile(file, expanded.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  await assert.rejects(historyPage(file, { cursor: fresh.older }), (e) => e instanceof HistoryError && e.status === 409);
+  const replaced = await historyPage(file);
+  assert.notEqual(replaced.generation, fresh.generation);
+  await fs.writeFile(file, JSON.stringify(rec("replacement", null)) + "\n");
+  const truncated = await historyPage(file);
+  assert.notEqual(truncated.generation, replaced.generation);
+});
+
+
+async function sdkMessages(records: HistoryRecord[], sidechain = false) {
+  const store = new InMemorySessionStore();
+  store.load = async () => records;
+  store.listSubkeys = async () => ["subagents/agent-test"];
+  const session = "12345678-1234-1234-1234-123456789abc";
+  return sidechain ? getSubagentMessages(session, "test", { dir: "/tmp", sessionStore: store })
+    : getSessionMessages(session, { dir: "/tmp", sessionStore: store });
+}
+
+test("fork briefing attachments cannot select or hide an abandoned branch (CACHE-014)", async (t) => {
+  const records = [rec("root", null), rec("old", "root", "assistant"), rec("new", "root"), rec("answer", "new", "assistant"),
+    rec("brief-old", "old", "attachment", { attachment: { type: "fork_briefing" } }),
+    rec("brief-current", "answer", "attachment", { attachment: { type: "fork_briefing" } })];
+  const file = await fixture(t, records);
+  const expected = (await sdkMessages(records)).map((m) => m.uuid);
+  assert.deepEqual(expected, ["root", "new", "answer"]);
+  assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), expected);
+  await assert.rejects(historyMessage(file, "old"), (e) => e instanceof HistoryError && e.status === 404);
+  assert.deepEqual((await historyPage(file, { anchor: "root" })).items.map((m) => m.uuid), ["root"]);
+});
+
+test("sibling and nested pending queues match SDK pages, hydration and rewind (CACHE-015)", async (t) => {
+  const records = [rec("root", null), rec("answer", "root", "assistant"),
+    rec("abandoned-queue", "answer", "attachment", { attachment: { type: "queued_command", prompt: "old" } }),
+    rec("abandoned-answer", "abandoned-queue", "assistant"),
+    rec("latest", "answer", "assistant")];
+  for (let i = 0; i < 105; i++) records.push(rec(`queue-${i}`, i === 104 ? "queue-103" : "latest", "attachment", {
+    timestamp: `2026-10-01T00:${String(Math.floor(i / 60)).padStart(2, "0")}:${String(i % 60).padStart(2, "0")}Z`,
+    attachment: { type: "queued_command", prompt: `prompt ${i}`, source_uuid: `source-${i}` },
+  }));
+  const file = await fixture(t, records);
+  const expected = (await sdkMessages(records)).map((m) => m.uuid);
+  assert.equal(expected.length, 108);
+  assert.equal(expected.includes("abandoned-queue"), false);
+  const latest = await historyPage(file);
+  const older = await historyPage(file, { cursor: latest.older });
+  assert.deepEqual([...older.items, ...latest.items].map((m) => m.uuid), expected);
+  assert.deepEqual((await historyPage(file, { cursor: older.newer })).items.map((m) => m.uuid), latest.items.map((m) => m.uuid));
+  assert.equal((await historyMessage(file, "source-0")).uuid, "source-0");
+  assert.equal((await historyMessage(file, "queue-104")).uuid, "source-104");
+  assert.deepEqual((await historyPage(file, { anchor: "answer" })).items.map((m) => m.uuid), ["root", "answer"]);
+  await assert.rejects(historyMessage(file, "abandoned-queue"), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("main external meta origins are visible and internal meta prompts stay hidden (CACHE-016)", async (t) => {
+  for (const kind of ["channel", "peer", "observer", "observer-activity", "slack-ping", "unknown"]) {
+    const origin = { kind, server: "probe-channel" };
+    const records = [rec("root", null), rec("meta", "root", "user", { isMeta: true, origin }),
+      rec("internal", "meta", "user", { isMeta: true }), rec("answer", "internal", "assistant"),
+      rec("queue", "answer", "attachment", { attachment: { type: "queued_command", prompt: "external", isMeta: true, origin } }),
+      rec("internal-queue", "answer", "attachment", { attachment: { type: "queued_command", prompt: "internal", isMeta: true } })];
+    const file = await fixture(t, records);
+    const expected = await sdkMessages(records);
+    const page = await historyPage(file);
+    assert.deepEqual(page.items.map((m) => m.uuid), expected.map((m) => m.uuid), kind);
+    const visible = kind !== "unknown";
+    assert.equal(page.items.some((m) => m.uuid === "meta"), visible, kind);
+    assert.equal(page.items.some((m) => m.uuid === "queue"), visible, kind);
+    assert.equal(page.items.some((m) => m.uuid === "internal" || m.uuid === "internal-queue"), false);
+    if (visible) {
+      assert.equal((await historyMessage(file, "meta")).is_meta, true);
+      assert.equal(((await historyMessage(file, "queue")).origin as { kind: string }).kind, kind);
+    } else await assert.rejects(historyMessage(file, "meta"), (e) => e instanceof HistoryError && e.status === 404);
+    await assert.rejects(historyMessage(file, "internal-queue"), (e) => e instanceof HistoryError && e.status === 404);
+  }
+});
+
+test("subagent meta prompts and delivered internal queues match SDK visibility (CACHE-016)", async (t) => {
+  const records = [rec("root", null, "user", { isMeta: true, isSidechain: true }),
+    rec("queue", "root", "attachment", { isSidechain: true, attachment: { type: "queued_command", prompt: "notification", isMeta: true } }),
+    rec("answer", "queue", "assistant", { isSidechain: true }),
+    rec("pending", "answer", "attachment", { isSidechain: true, attachment: { type: "queued_command", prompt: "pending", isMeta: true } })];
+  const file = await fixture(t, records);
+  const expected = await sdkMessages(records, true);
+  const page = await historyPage(file, { sidechain: true });
+  assert.deepEqual(page.items.map((m) => m.uuid), expected.map((m) => m.uuid));
+  assert.deepEqual(page.items.map((m) => m.uuid), ["root", "queue", "answer"]);
+  assert.equal((await historyMessage(file, "root", undefined, true)).is_meta, true);
+  await assert.rejects(historyMessage(file, "pending", undefined, true), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("many assistant groups retain SDK result association without copying global result sets (CACHE-020)", async (t) => {
+  const records = [rec("root", null)];
+  let parent = "root";
+  for (let i = 0; i < 120; i++) {
+    const call = `call-${i}`, result = `result-${i}`, tool = `tool-${i}`;
+    records.push(rec(call, parent, "assistant", { message: { id: `api-${i}`, content: [{ type: "tool_use", id: tool, name: "Bash", input: {} }] } }),
+      rec(result, call, "user", { message: { content: [{ type: "tool_result", tool_use_id: tool, content: "done" }] } }),
+      rec(`duplicate-${i}`, "root", "user", { sourceToolAssistantUUID: call, message: { content: [{ type: "tool_result", tool_use_id: tool, content: "duplicate" }] } }));
+    parent = result;
+  }
+  records.push(rec("answer", parent, "assistant"));
+  const file = await fixture(t, records);
+  const expected = (await sdkMessages(records)).map((m) => m.uuid);
+  const pages = [];
+  let page = await historyPage(file);
+  pages.unshift(...page.items);
+  while (page.older) { page = await historyPage(file, { cursor: page.older }); pages.unshift(...page.items); }
+  assert.deepEqual(pages.map((m) => m.uuid), expected);
+  assert.equal(pages.some((m) => m.uuid?.startsWith("duplicate-")), false);
+  assert.equal(expected.length, 242);
+});
+
+
+test("queued tails traverse metadata nodes and suppress delivered or duplicate source UUIDs (CACHE-015/016)", async (t) => {
+  const records = [rec("root", null), rec("sent", "root"), rec("answer", "sent", "assistant"),
+    rec("progress", "answer", "progress"),
+    rec("fork", "progress", "attachment", { attachment: { type: "fork_briefing" } }),
+    rec("delivered", "fork", "attachment", { attachment: { type: "queued_command", prompt: "already sent", source_uuid: "sent" } }),
+    rec("queue-one", "fork", "attachment", { attachment: { type: "queued_command", prompt: "first", source_uuid: "pending" } }),
+    rec("queue-two", "fork", "attachment", { attachment: { type: "queued_command", prompt: "duplicate", source_uuid: "pending" } })];
+  const expected = (await sdkMessages(records)).map((m) => m.uuid);
+  const file = await fixture(t, records);
+  assert.deepEqual(expected, ["root", "sent", "answer", "pending"]);
+  assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), expected);
+  assert.equal(((await historyMessage(file, "pending")).message as { content: string }).content, "first");
+  await assert.rejects(historyMessage(file, "delivered"), (e) => e instanceof HistoryError && e.status === 404);
+  await assert.rejects(historyMessage(file, "queue-two"), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("forwarded queue intents follow SDK validation before becoming visible prompts (CACHE-016)", async (t) => {
+  const intents = [
+    { value: { lineage: "test-lineage", source: "typed" }, hidden: true },
+    { value: { lineage: "test-lineage", source: "relay" }, hidden: true },
+    { value: { lineage: "test-lineage", source: "owner" }, hidden: true },
+    { value: { lineage: " " }, hidden: true },
+    { value: { lineage: "test-lineage", source: { unknown: true } }, hidden: true },
+    { value: { lineage: "" }, hidden: false },
+    { value: { lineage: 1 }, hidden: false },
+    { value: { source: "typed" }, hidden: false },
+    { value: null, hidden: false },
+    { value: "test-lineage", hidden: false },
+    { value: [{ lineage: "test-lineage" }], hidden: false },
+  ];
+  for (const sidechain of [false, true]) for (const { value, hidden } of intents) {
+    const records = [rec("root", null, "user", { isSidechain: sidechain }),
+      rec("queue", "root", "attachment", { isSidechain: sidechain, attachment: {
+        type: "queued_command", prompt: "forwarded content", source_uuid: "source", forwardedIntent: value,
+      } }), rec("answer", "queue", "assistant", { isSidechain: sidechain })];
+    const expected = await sdkMessages(records, sidechain);
+    assert.equal(expected.some((m) => m.uuid === "source"), !hidden);
+    const file = await fixture(t, records);
+    assert.deepEqual((await historyPage(file, { sidechain })).items.map((m) => m.uuid), expected.map((m) => m.uuid));
+    if (hidden) {
+      for (const id of ["queue", "source"]) await assert.rejects(historyMessage(file, id, undefined, sidechain), (e) => e instanceof HistoryError && e.status === 404);
+    } else {
+      assert.equal((await historyMessage(file, "queue", undefined, sidechain)).uuid, "source");
+      assert.equal((await historyMessage(file, "source", undefined, sidechain)).uuid, "source");
+    }
+  }
+});
+
+test("consecutive queued inputs before interruption match SDK pages, hydration and rewind (CACHE-015/016)", async (t) => {
+  const records = [rec("root", null)];
+  for (let i = 0; i < 105; i++) records.push(rec(`queue-${i}`, i ? `queue-${i - 1}` : "root", "attachment", {
+    attachment: { type: "queued_command", prompt: `prompt ${i}`, source_uuid: `source-${i}` },
+  }));
+  records.push(rec("interrupted", "queue-104", "user", { message: { role: "user", content: "[Request interrupted by user]" } }));
+  const expected = await sdkMessages(records);
+  assert.equal(expected.length, 107);
+  const file = await fixture(t, records);
+  const latest = await historyPage(file);
+  const older = await historyPage(file, { cursor: latest.older });
+  assert.deepEqual([...older.items, ...latest.items].map((m) => m.uuid), expected.map((m) => m.uuid));
+  assert.deepEqual((await historyPage(file, { cursor: older.newer })).items.map((m) => m.uuid), latest.items.map((m) => m.uuid));
+  for (const id of ["queue-0", "source-0", "queue-104", "source-104"]) {
+    const result = await historyMessage(file, id);
+    assert.equal(result.uuid, id.replace("queue-", "source-"));
+    assert.equal(result.isQueuedCommand, true);
+  }
+  assert.deepEqual((await historyPage(file, { anchor: "root" })).items.map((m) => m.uuid), ["root"]);
+  await assert.rejects(historyMessage(file, "source-0", "root"), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("interruption markers and genuine follow-up inputs keep different queued visibility (CACHE-016)", async (t) => {
+  const variants = [
+    { content: "[Request interrupted by user]", visible: true },
+    { content: "[Request interrupted by user for tool use] detail", visible: true },
+    { content: "[Tool call did not complete: the turn was ended to deliver the message that follows. Nothing refused it; re-run it if still needed.]", visible: true },
+    { content: "[Tool call interrupted: the session ended before this call's result was recorded, so its outcome is unknown. Check whether it took effect before relying on it or running it again.]", visible: true },
+    { content: "[Tool call result not in this copy: this session was copied from another session before that session recorded this call's result. The call may have finished there, may still be running there, or may never have run. Check whether it took effect before relying on it or running it again.]", visible: true },
+    { content: "The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.", visible: true },
+    { content: "[Tool call skipped: the turn was stopped before this call ran, by the check whose denial is on another call in this batch. Nothing refused this call and it had no effects; re-run it if still needed.]", visible: true },
+    { content: "[Tool call skipped: the turn ended to deliver the message that follows before this call ran. Nothing refused it; re-run it if still needed.]", visible: true },
+    { content: [{ type: "text", text: "[Request interrupted by user]" }], visible: true },
+    { content: [{ type: "text", text: "[Request interrupted by user]" }, { type: "text", text: "new user request" }], visible: false },
+    { content: "new user request", visible: false },
+    { content: "[Request interrupted by userish]", visible: false },
+    { content: [], visible: false },
+  ];
+  for (const sidechain of [false, true]) for (const { content, visible } of variants) {
+    const records = [rec("root", null, "user", { isSidechain: sidechain }),
+      rec("queue", "root", "attachment", { isSidechain: sidechain, attachment: { type: "queued_command", prompt: "queued", source_uuid: "source" } }),
+      rec("followup", "queue", "user", { isSidechain: sidechain, message: { role: "user", content } }),
+      rec("answer", "followup", "assistant", { isSidechain: sidechain })];
+    const expected = await sdkMessages(records, sidechain);
+    assert.equal(expected.some((m) => m.uuid === "source"), visible);
+    const file = await fixture(t, records);
+    assert.deepEqual((await historyPage(file, { sidechain })).items.map((m) => m.uuid), expected.map((m) => m.uuid));
+    if (visible) assert.equal((await historyMessage(file, "source", undefined, sidechain)).uuid, "source");
+    else await assert.rejects(historyMessage(file, "source", undefined, sidechain), (e) => e instanceof HistoryError && e.status === 404);
+  }
+});
+
+test("meta, compact summaries and forwarded queues preserve SDK delivery boundaries (CACHE-016)", async (t) => {
+  for (const marker of [{ isCompactSummary: true }, { isMeta: true }, { isMeta: true, origin: { kind: "channel", server: "probe" } }, { isMeta: true, origin: { kind: "peer" } }]) {
+    const records = [rec("root", null),
+      rec("queue", "root", "attachment", { attachment: { type: "queued_command", prompt: "queued" } }),
+      rec("marker", "queue", "user", marker), rec("answer", "marker", "assistant")];
+    const expected = await sdkMessages(records);
+    const file = await fixture(t, records);
+    assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), expected.map((m) => m.uuid));
+    assert.equal((await historyMessage(file, "queue")).uuid, "queue");
+  }
+  for (const kind of ["channel", "peer", "unknown"]) for (const forwarded of [true, false]) {
+    const records = [rec("root", null), rec("answer", "root", "assistant"),
+      rec("queue", "answer", "attachment", { attachment: { type: "queued_command", prompt: "queued", isMeta: true,
+        origin: { kind }, forwardedIntent: { lineage: forwarded ? "lineage" : "" },
+      } })];
+    const expected = await sdkMessages(records);
+    const file = await fixture(t, records);
+    assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), expected.map((m) => m.uuid));
+    const visible = kind !== "unknown" && !forwarded;
+    assert.equal(expected.some((m) => m.uuid === "queue"), visible);
+    if (visible) assert.equal((await historyMessage(file, "queue")).is_meta, true);
+    else await assert.rejects(historyMessage(file, "queue"), (e) => e instanceof HistoryError && e.status === 404);
+  }
+});
+
+test("completed local commands preserve preceding queues and annotate record/output messages like SDK (CACHE-016)", async (t) => {
+  for (const sidechain of [false, true]) for (const format of ["string", "blocks"]) {
+    const content = (text: string) => format === "string" ? text : [{ type: "text", text: "leading" }, { type: "text", text }];
+    const records = [rec("root", null, "user", { isSidechain: sidechain }),
+      rec("queue", "root", "attachment", { isSidechain: sidechain, attachment: { type: "queued_command", prompt: "queued" } }),
+      rec("caveat", "queue", "user", { isSidechain: sidechain, isMeta: true, message: { role: "user", content: content("<local-command-caveat>Ignore command output") } }),
+      rec("record", "caveat", "user", { isSidechain: sidechain, message: { role: "user", content: content("<command-name>/x</command-name>") } }),
+      rec("stdout", "record", "user", { isSidechain: sidechain, message: { role: "user", content: content("<local-command-stdout>output") } }),
+      rec("stderr", "stdout", "user", { isSidechain: sidechain, message: { role: "user", content: content("<local-command-stderr>error") } }),
+      rec("answer", "stderr", "assistant", { isSidechain: sidechain })];
+    const expected = await sdkMessages(records, sidechain);
+    const file = await fixture(t, records);
+    const page = await historyPage(file, { sidechain });
+    assert.deepEqual(page.items.map((m) => [m.uuid, m.isCompletedLocalCommand]), expected.map((m) => [m.uuid, "isCompletedLocalCommand" in m ? m.isCompletedLocalCommand : undefined]));
+    assert.equal((await historyMessage(file, "queue", undefined, sidechain)).uuid, "queue");
+    assert.equal((await historyMessage(file, "stdout", undefined, sidechain)).isCompletedLocalCommand, true);
+    // A real new user input still cuts off an unconfirmed queued command.
+    const changed = records.map((r) => r.uuid === "record" ? { ...r, promptSource: "user" } : r);
+    const changedFile = await fixture(t, changed);
+    assert.deepEqual((await historyPage(changedFile, { sidechain })).items.map((m) => m.uuid), (await sdkMessages(changed, sidechain)).map((m) => m.uuid));
+    await assert.rejects(historyMessage(changedFile, "queue", undefined, sidechain), (e) => e instanceof HistoryError && e.status === 404);
+  }
+});
+
+test("delivery confirmations match SDK and remain bounded by rewind, duplicate copies and append offsets (CACHE-015/016)", async (t) => {
+  for (const delivery of [false, true]) {
+    const attachment = { type: "queued_command", prompt: "queued", source_uuid: "source", ...(delivery ? { delivery_id: "delivery" } : {}) };
+    const records: HistoryRecord[] = [rec("root", null), rec("queue-1", "root", "attachment", { attachment }),
+      rec("queue-2", "queue-1", "attachment", { attachment }), rec("followup", "queue-2"), rec("answer", "followup", "assistant")];
+    const operation = { type: "queue-operation", operation: "remove", reason: "absorbed_mid_turn", ...(delivery ? { deliveryId: "delivery" } : { commandUuid: "source" }) };
+    records.push(operation);
+    const file = await fixture(t, records);
+    const expected = await sdkMessages(records);
+    const page = await historyPage(file);
+    assert.deepEqual(page.items.map((m) => m.uuid), expected.map((m) => m.uuid));
+    assert.equal(((await historyMessage(file, "source")).message as { content: string }).content, "queued");
+    await assert.rejects(historyMessage(file, "queue-1"), (e) => e instanceof HistoryError && e.status === 404);
+    assert.equal((await historyMessage(file, "queue-2")).uuid, "source");
+    // Reading again must not count the same operation twice.
+    assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), page.items.map((m) => m.uuid));
+    await assert.rejects(historyMessage(file, "queue-1"), (e) => e instanceof HistoryError && e.status === 404);
+    // Re-appending a known attachment UUID is an update, not a fresh copy.
+    await fs.appendFile(file, JSON.stringify(records[1]) + "\n"); records.push(records[1]!);
+    assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), (await sdkMessages(records)).map((m) => m.uuid));
+    assert.equal((await historyMessage(file, "queue-2")).uuid, "source");
+    for (let i = 0; i < 9; i++) await historyPage(await fixture(t, [rec(`evict-${i}`, null)]));
+    assert.equal((await historyMessage(file, "queue-2")).uuid, "source");
+    // A later receipt cannot leak backwards into an anchored view.
+    assert.deepEqual((await historyPage(file, { anchor: "answer" })).items.map((m) => m.uuid), ["root", "followup", "answer"]);
+    await assert.rejects(historyMessage(file, "source", "answer"), (e) => e instanceof HistoryError && e.status === 404);
+    await fs.appendFile(file, JSON.stringify(operation) + "\n"); records.push(operation);
+    assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), (await sdkMessages(records)).map((m) => m.uuid));
+    assert.equal((await historyMessage(file, "queue-1")).uuid, "source");
+    await assert.rejects(historyMessage(file, "queue-2"), (e) => e instanceof HistoryError && e.status === 404);
+  }
+});
+
+test("ambiguous legacy queue payloads ignore receipts, and unrelated operations cannot deliver a prompt (CACHE-016)", async (t) => {
+  for (const reason of ["absorbed_mid_turn", "cancelled"]) {
+    const records = [rec("root", null),
+      rec("queue-1", "root", "attachment", { attachment: { type: "queued_command", prompt: "first", source_uuid: "source" } }),
+      rec("queue-2", "queue-1", "attachment", { attachment: { type: "queued_command", prompt: "different", source_uuid: "source" } }),
+      rec("followup", "queue-2"), rec("answer", "followup", "assistant"),
+      { type: "queue-operation", operation: "remove", reason, commandUuid: "source" }];
+    const file = await fixture(t, records);
+    assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), (await sdkMessages(records)).map((m) => m.uuid));
+    await assert.rejects(historyMessage(file, "source"), (e) => e instanceof HistoryError && e.status === 404);
+  }
+  // A conflicting overwrite of the same attachment UUID must retain the earlier
+  // ambiguity classification, even though the offset map now points at its tail.
+  const records: HistoryRecord[] = [rec("root", null),
+    rec("queue", "root", "attachment", { attachment: { type: "queued_command", prompt: "first", source_uuid: "source" } }),
+    rec("followup", "queue"), rec("answer", "followup", "assistant"),
+    { type: "queue-operation", operation: "remove", reason: "absorbed_mid_turn", commandUuid: "source" }];
+  const file = await fixture(t, records);
+  assert.equal((await historyMessage(file, "source")).uuid, "source");
+  const conflicting = rec("queue", "root", "attachment", { attachment: { type: "queued_command", prompt: "changed", source_uuid: "source" } });
+  await fs.appendFile(file, JSON.stringify(conflicting) + "\n"); records.push(conflicting);
+  assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), (await sdkMessages(records)).map((m) => m.uuid));
+  await assert.rejects(historyMessage(file, "source"), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("subagent queue-operation records do not override SDK reply/prompt visibility (CACHE-016)", async (t) => {
+  const records = [rec("root", null, "user", { isSidechain: true }),
+    rec("queue", "root", "attachment", { isSidechain: true, attachment: { type: "queued_command", prompt: "queued", source_uuid: "source", delivery_id: "delivery" } }),
+    rec("followup", "queue", "user", { isSidechain: true }), rec("answer", "followup", "assistant", { isSidechain: true }),
+    { type: "queue-operation", operation: "remove", reason: "absorbed_mid_turn", deliveryId: "delivery" }];
+  const expected = await sdkMessages(records, true);
+  const file = await fixture(t, records);
+  assert.deepEqual(expected.map((m) => m.uuid), ["root", "followup", "answer"]);
+  assert.deepEqual((await historyPage(file, { sidechain: true })).items.map((m) => m.uuid), expected.map((m) => m.uuid));
+  await assert.rejects(historyMessage(file, "source", undefined, true), (e) => e instanceof HistoryError && e.status === 404);
+});
+
+test("confirmed queued copies retain rewind membership after identical UUID rewrites (CACHE-015/016)", async (t) => {
+  for (const delivery of [false, true]) {
+    const attachment = { type: "queued_command", prompt: "queued", source_uuid: "source", ...(delivery ? { delivery_id: "delivery" } : {}) };
+    const queue = rec("queue", "root", "attachment", { attachment });
+    const operation = { type: "queue-operation", operation: "remove", reason: "absorbed_mid_turn", ...(delivery ? { deliveryId: "delivery" } : { commandUuid: "source" }) };
+    const records: HistoryRecord[] = [rec("root", null), queue, operation, rec("followup", "queue"), rec("answer", "followup", "assistant")];
+    const file = await fixture(t, records);
+    const expected = ["root", "source", "followup", "answer"];
+    const anchored = async () => (await historyPage(file, { anchor: "answer" })).items.map((m) => m.uuid);
+    assert.deepEqual(await anchored(), expected);
+    await fs.appendFile(file, JSON.stringify(queue) + "\n"); records.push(queue);
+    assert.deepEqual(await anchored(), expected);
+    assert.deepEqual((await sdkMessages(records)).map((m) => m.uuid), expected);
+    for (const id of ["queue", "source"]) assert.equal((await historyMessage(file, id, "answer")).uuid, "source");
+    for (let i = 0; i < 9; i++) await historyPage(await fixture(t, [rec(`rewind-evict-${i}`, null)]));
+    assert.deepEqual(await anchored(), expected);
+    assert.equal((await historyMessage(file, "source", "answer")).uuid, "source");
+
+    // A future, genuinely new copy must not compete with the pre-anchor copy
+    // for its earlier confirmation. Neither may a future receipt enter the view.
+    const future = rec("future-copy", "answer", "attachment", { attachment });
+    await fs.appendFile(file, [future, operation].map((r) => JSON.stringify(r)).join("\n") + "\n");
+    assert.deepEqual(await anchored(), expected);
+    assert.equal((await historyMessage(file, "queue", "answer")).uuid, "source");
+    await assert.rejects(historyMessage(file, "future-copy", "answer"), (e) => e instanceof HistoryError && e.status === 404);
+
+    // A changed body under an existing UUID is no longer the earlier copy. It
+    // must not gain pre-anchor membership by borrowing that copy's first offset.
+    const changed = rec("queue", "root", "attachment", { attachment: { ...attachment, prompt: "future changed payload" } });
+    await fs.appendFile(file, JSON.stringify(changed) + "\n");
+    assert.deepEqual(await anchored(), ["root", "followup", "answer"]);
+    await assert.rejects(historyMessage(file, "source", "answer"), (e) => e instanceof HistoryError && e.status === 404);
+    const changedKey = rec("queue", "root", "attachment", { attachment: { ...attachment, source_uuid: "future-source", ...(delivery ? { delivery_id: "future-delivery" } : {}) } });
+    await fs.appendFile(file, JSON.stringify(changedKey) + "\n");
+    assert.deepEqual(await anchored(), ["root", "followup", "answer"]);
+    await assert.rejects(historyMessage(file, "future-source", "answer"), (e) => e instanceof HistoryError && e.status === 404);
+
+    // A reply-shaped successor cannot make a future conflicting body visible
+    // through the normal heuristic either, even without a new user delimiter.
+    const replyFile = await fixture(t, [rec("root", null), queue, operation, rec("reply", "queue", "assistant")]);
+    await historyPage(replyFile, { anchor: "reply" });
+    await fs.appendFile(replyFile, JSON.stringify(changed) + "\n");
+    assert.deepEqual((await historyPage(replyFile, { anchor: "reply" })).items.map((m) => m.uuid), ["root", "reply"]);
+    await assert.rejects(historyMessage(replyFile, "source", "reply"), (e) => e instanceof HistoryError && e.status === 404);
+
+    const noReceiptRecords = [rec("root", null), queue, rec("followup", "queue"), rec("answer", "followup", "assistant")];
+    const noReceiptFile = await fixture(t, noReceiptRecords);
+    await historyPage(noReceiptFile, { anchor: "answer" });
+    await fs.appendFile(noReceiptFile, [queue, operation].map((r) => JSON.stringify(r)).join("\n") + "\n");
+    assert.deepEqual((await historyPage(noReceiptFile, { anchor: "answer" })).items.map((m) => m.uuid), ["root", "followup", "answer"]);
+    await assert.rejects(historyMessage(noReceiptFile, "source", "answer"), (e) => e instanceof HistoryError && e.status === 404);
+  }
+  // UUID-less native notifications cannot have a receipt key; their delivered
+  // attachment UUID must still survive an identical rewrite under the anchor.
+  const queue = rec("queue", "root", "attachment", { attachment: { type: "queued_command", prompt: "notification" } });
+  const file = await fixture(t, [rec("root", null), queue, rec("answer", "queue", "assistant")]);
+  await historyPage(file, { anchor: "answer" });
+  await fs.appendFile(file, JSON.stringify(queue) + "\n");
+  assert.deepEqual((await historyPage(file, { anchor: "answer" })).items.map((m) => m.uuid), ["root", "queue", "answer"]);
+  assert.equal((await historyMessage(file, "queue", "answer")).uuid, "queue");
+});
+
+test("another branch's confirmed copy does not deliver the current branch's unconfirmed copy (CACHE-015/016)", async (t) => {
+  for (const delivery of [false, true]) {
+    const attachment = { type: "queued_command", prompt: "queued", source_uuid: "source", ...(delivery ? { delivery_id: "delivery" } : {}) };
+    const records: HistoryRecord[] = [rec("root", null), rec("current-queue", "root", "attachment", { attachment }), rec("followup", "current-queue"),
+      rec("old-queue", "root", "attachment", { attachment }), rec("old-answer", "old-queue", "assistant"),
+      { type: "queue-operation", operation: "remove", reason: "absorbed_mid_turn", ...(delivery ? { deliveryId: "delivery" } : { commandUuid: "source" }) },
+      rec("answer", "followup", "assistant")];
+    const file = await fixture(t, records);
+    assert.deepEqual((await historyPage(file)).items.map((m) => m.uuid), ["root", "followup", "answer"]);
+    for (const id of ["source", "current-queue", "old-queue"]) await assert.rejects(historyMessage(file, id), (e) => e instanceof HistoryError && e.status === 404);
+  }
+});
+
+test("linked deferred tool results retain their original record UUID (CACHE-024)", async (t) => {
+  const file = await fixture(t, [rec("call", null, "assistant", { message: { content: [{ type: "tool_use", id: "tool", name: "Bash", input: {} }] } }),
+    rec("result", "call", "user", { message: { content: [{ type: "tool_result", tool_use_id: "tool", content: "x".repeat(20_000) }] } })]);
+  const page = await historyPage(file);
+  const call = page.items.find((m) => m.uuid === "call")!;
+  assert.deepEqual(call._toolResultUuids, { tool: "result" });
+  assert.equal((call.linkedToolResults as Record<string, { deferredUuid: string }>).tool?.deferredUuid, "result");
+});