@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/live-session.test.ts

@@ -0,0 +1,1126 @@
+/**
+ * Unit tests for ordering and concurrency in LiveSession / SessionManager, with a scripted
+ * fake SDK query (real timing can't be forced reliably end to end).
+ * Run: npm run test:unit
+ */
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "cide-unit-"));
+process.env.CLAUDE_IDE_DATA_DIR = path.join(tmp, "data");
+process.env.CLAUDE_IDE_PASSWORD = "unit";
+process.env.CLAUDE_CONFIG_DIR = path.join(tmp, "claude"); // no real transcripts are touched
+
+type Msg = Record<string, unknown>;
+
+/** A fake Query: the test pushes SDK messages; close() ends the stream. */
+class FakeQuery {
+  closed = false;
+  backgroundCalls: (string | undefined)[] = [];
+  interruptCalls = 0;
+  constructor(readonly args: { prompt: AsyncIterable<Msg>; options: Record<string, any> }) {}
+  /** The next message our server delivered to this "CLI process". */
+  async received(): Promise<Msg> {
+    return (await this.args.prompt[Symbol.asyncIterator]().next()).value;
+  }
+  private queue: Msg[] = [];
+  private waiter?: (r: IteratorResult<Msg>) => void;
+  push(m: Msg) {
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = undefined;
+      w({ value: m, done: false });
+    } else this.queue.push(m);
+  }
+  close() {
+    this.closed = true;
+    this.waiter?.({ value: undefined, done: true });
+  }
+  async interrupt() { this.interruptCalls++; }
+  async backgroundTasks(toolUseId?: string) { this.backgroundCalls.push(toolUseId); return true; }
+  async applyFlagSettings() {
+    await new Promise((r) => setTimeout(r, 10)); // a real control round-trip takes a moment
+  }
+  async setPermissionMode() {}
+  async setModel() {}
+  async setCwd(dir: string) { this.args.options.cwd = dir; return { status: "success" }; }
+  [Symbol.asyncIterator]() {
+    return {
+      next: (): Promise<IteratorResult<Msg>> => {
+        const m = this.queue.shift();
+        if (m) return Promise.resolve({ value: m, done: false });
+        if (this.closed) return Promise.resolve({ value: undefined, done: true });
+        return new Promise((r) => (this.waiter = r));
+      },
+    };
+  }
+}
+
+let created: FakeQuery[] = [];
+let LiveSession: typeof import("./live-session.ts").LiveSession;
+let sessions: typeof import("./sessions.ts").sessions;
+
+before(async () => {
+  const mod = await import("./live-session.ts");
+  mod.setQueryImplForTests(((args: FakeQuery["args"]) => {
+    const q = new FakeQuery(args);
+    created.push(q);
+    return q;
+  }) as never);
+  LiveSession = mod.LiveSession;
+  sessions = (await import("./sessions.ts")).sessions;
+});
+
+const tick = () => new Promise((r) => setTimeout(r, 20));
+const newDir = () => fs.mkdtempSync(path.join(tmp, "proj-"));
+
+function writeTranscript(cwd: string, sessionId: string, records: Msg[]) {
+  cwd = fs.realpathSync(cwd); // SDK directory lookup canonicalizes macOS /var.
+  const dir = path.join(process.env.CLAUDE_CONFIG_DIR!, "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+  fs.mkdirSync(dir, { recursive: true });
+  let parent: string | null = null;
+  const rows = records.map((r) => {
+    const uuid = String(r.uuid ?? crypto.randomUUID());
+    const row = { sessionId, cwd, timestamp: new Date().toISOString(), isSidechain: false, ...r, uuid, parentUuid: r.parentUuid === undefined ? parent : r.parentUuid };
+    parent = uuid;
+    return JSON.stringify(row);
+  });
+  fs.writeFileSync(path.join(dir, `${sessionId}.jsonl`), rows.join("\n") + "\n");
+}
+
+test("a stop during start does not leave a CLI process behind", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const sending = s.send(crypto.randomUUID(), "hi"); // start is now in flight (awaiting session info)
+  await s.shutdown();
+  await sending;
+  await tick();
+  assert.ok(created.every((q) => q.closed), `open queries: ${created.filter((q) => !q.closed).length}`);
+});
+
+test("concurrent first sends create one query", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  await Promise.all([s.send(crypto.randomUUID(), "a"), s.send(crypto.randomUUID(), "b")]);
+  assert.equal(created.length, 1);
+  await s.shutdown();
+});
+
+test("peer delivery is bounded under concurrent sends and stays composed text", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  try {
+    const outcomes = await Promise.allSettled(Array.from({ length: 33 }, () => s.sendPeerText(crypto.randomUUID(), "/btw ordinary peer text", () => true)));
+    assert.equal(outcomes.filter((r) => r.status === "fulfilled" && r.value).length, 32);
+    assert.equal(outcomes.filter((r) => r.status === "rejected" && /队列已满/.test(String(r.reason))).length, 1);
+    assert.equal(s.queuedMessageCount, 32);
+    assert.equal(created.length, 1);
+    const delivered = await created[0]!.received();
+    assert.equal(delivered.client_composed, true);
+    assert.equal(delivered.priority, "next");
+    assert.deepEqual(delivered.message, { role: "user", content: [{ type: "text", text: "/btw ordinary peer text" }] });
+  } finally { await s.shutdown(); }
+});
+
+test("peer delivery refuses pending rewinds and rechecks after asynchronous startup", async () => {
+  const { db } = await import("./db.ts");
+  const id = crypto.randomUUID(), dir = newDir();
+  db.prepare("INSERT INTO session_view (session_id,project_path,rewind_anchor) VALUES (?,?,?)").run(id, dir, "anchor");
+  const s = new LiveSession(id, dir, () => {});
+  created = [];
+  try {
+    await assert.rejects(s.sendPeerText(crypto.randomUUID(), "peer", () => true), /回退/);
+    assert.equal(created.length, 0);
+    db.prepare("UPDATE session_view SET rewind_anchor=NULL WHERE session_id=?").run(id);
+    let checks = 0;
+    await assert.rejects(s.sendPeerText(crypto.randomUUID(), "peer", () => {
+      if (++checks === 2) db.prepare("UPDATE session_view SET rewind_anchor='new-anchor' WHERE session_id=?").run(id);
+      return true;
+    }), /回退/);
+    assert.equal(checks, 2);
+    assert.equal(s.queuedMessageCount, 0);
+    assert.equal(s.events.some(({ ev }) => ev.k === "user" && ev.text === "peer"), false);
+    assert.equal(s.rewindAnchor, "new-anchor");
+    db.prepare("UPDATE session_view SET rewind_anchor=NULL WHERE session_id=?").run(id);
+    let activeChecks = 0;
+    assert.equal(await s.sendPeerText(crypto.randomUUID(), "cancelled", () => ++activeChecks < 2), false);
+    assert.equal(s.queuedMessageCount, 0);
+  } finally { await s.shutdown(); }
+});
+
+test("IDEMessages injection permits listing but guards mutations and btw delegation", async () => {
+  const { db } = await import("./db.ts");
+  const { updateSession } = await import("./sessions.ts");
+  const id = crypto.randomUUID(), dir = newDir();
+  await updateSession(id, dir, { writeEnabled: false });
+  const s = await sessions.getOrCreate(id, dir);
+  created = [];
+  try {
+    await s.wake();
+    const q = created[0]!;
+    assert.ok(q.args.options.mcpServers.IDEMessages);
+    const hook = q.args.options.hooks.PreToolUse[0].hooks[0];
+    const check = (tool_name: string) => hook({ hook_event_name: "PreToolUse", tool_name });
+    assert.deepEqual(await check("mcp__IDEMessages__ide_list_alias"), {});
+    const options = { signal: new AbortController().signal, toolUseID: "peer" };
+    for (const name of ["ide_send_message", "ide_set_alias", "ide_remove_alias"]) {
+      const tool = `mcp__IDEMessages__${name}`;
+      assert.equal((await check(tool)).hookSpecificOutput.permissionDecision, "deny");
+      assert.equal((await q.args.options.canUseTool(tool, {}, options)).behavior, "deny");
+    }
+    await updateSession(id, dir, { writeEnabled: true });
+    assert.deepEqual(await check("mcp__IDEMessages__ide_send_message"), {});
+    db.prepare("UPDATE session_view SET btw_parent='parent' WHERE session_id=?").run(id);
+    assert.equal((await check("mcp__IDEMessages__ide_send_message")).hookSpecificOutput.permissionDecision, "deny");
+    assert.equal((await q.args.options.canUseTool("mcp__IDEMessages__ide_send_message", {}, options)).behavior, "deny");
+    assert.deepEqual(await check("mcp__IDEMessages__ide_list_alias"), {});
+  } finally { await sessions.drop(id); }
+});
+
+test("backgrounding targets one live tool without restarting or interrupting the query", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  try {
+    await s.send(crypto.randomUUID(), "run a long command");
+    const q = created[0]!;
+    assert.equal(await s.backgroundTask("tool-bash-1"), true);
+    assert.deepEqual(q.backgroundCalls, ["tool-bash-1"]);
+    assert.equal(q.interruptCalls, 0);
+    assert.equal(q.closed, false);
+    assert.equal(created.length, 1);
+    q.backgroundTasks = async () => false;
+    assert.equal(await s.backgroundTask("finished-tool"), false);
+    q.backgroundTasks = async () => { throw new Error("background tasks disabled"); };
+    await assert.rejects(s.backgroundTask("tool-bash-2"), /background tasks disabled/);
+    await assert.rejects(s.backgroundTask(" "), /缺少工具调用 ID/);
+  } finally {
+    await s.shutdown();
+  }
+});
+
+test("backgrounding an inactive session does not start a query", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  assert.equal(await s.backgroundTask("old-tool"), false);
+  assert.equal(created.length, 0);
+  await s.shutdown();
+});
+
+test("stream and Stop-hook task type aliases retain subagent trace identity", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  try {
+    await s.send(crypto.randomUUID(), "start background work");
+    const q = created[0]!;
+    for (const type of ["local_agent", "subagent"]) {
+      (s as any).handle({ type: "system", subtype: "task_started", task_id: `task-${type}`, tool_use_id: `tool-${type}`, task_type: type, description: "Plan multilingual project site", is_backgrounded: true });
+    }
+    await q.args.options.hooks.Stop[0].hooks[0]({ background_tasks: [
+      { id: "task-local_agent", type: "subagent", status: "running", description: "Plan multilingual project site" },
+      { id: "task-subagent", type: "subagent", status: "completed", description: "Other agent" },
+    ] });
+    const snapshot = s.snapshot();
+    assert.equal(snapshot.tasks[0]?.type, "subagent", "hook summaries carry friendly type names");
+    for (const task of snapshot.tasks) {
+      assert.equal(snapshot.agentTasks?.find((agent) => agent.taskId === task.id)?.toolUseId, task.id.replace("task-", "tool-"));
+    }
+  } finally { await s.shutdown(); }
+});
+
+test("AskUserQuestion can be disabled live without restarting and leaves plan approval pending", async () => {
+  created = [];
+  const { updateSession } = await import("./sessions.ts");
+  const id = crypto.randomUUID();
+  const dir = newDir();
+  const s = await sessions.getOrCreate(id, dir);
+  try {
+    assert.equal(s.snapshot().askQuestionsEnabled, true);
+    await s.send(crypto.randomUUID(), "hi");
+    const q = created[0]!;
+    const options = { signal: new AbortController().signal, toolUseID: "question-tool" };
+    const input = { questions: [{ question: "Which one?", options: [{ label: "A", description: "A" }] }] };
+    const asking = q.args.options.canUseTool("AskUserQuestion", input, options);
+    const plan = q.args.options.canUseTool("ExitPlanMode", { plan: "the plan" }, { ...options, toolUseID: "plan-tool" });
+    assert.equal(s.snapshot().pending.length, 2);
+    await updateSession(id, dir, { askQuestionsEnabled: false });
+    assert.match((await asking).message, /已禁用 AskUserQuestion/);
+    assert.deepEqual(s.snapshot().pending.map((request) => request.kind), ["plan"]);
+    assert.equal(s.snapshot().askQuestionsEnabled, false);
+    assert.equal((await q.args.options.canUseTool("AskUserQuestion", input, options)).behavior, "deny");
+    assert.equal(s.snapshot().pending.length, 1);
+    assert.equal(created.length, 1);
+    assert.equal(q.interruptCalls, 0);
+    assert.equal(q.closed, false);
+    assert.ok(s.events.some(({ ev }) => ev.k === "settings" && ev.askQuestionsEnabled === false));
+    const restored = new LiveSession(id, dir, () => {});
+    assert.equal(restored.snapshot().askQuestionsEnabled, false);
+    await restored.shutdown();
+    await updateSession(id, dir, { askQuestionsEnabled: true });
+    const askingAgain = q.args.options.canUseTool("AskUserQuestion", input, options);
+    const ask = s.snapshot().pending.find((request) => request.kind === "ask")!;
+    assert.ok(ask);
+    s.resolvePending(ask.id, { kind: "ask", answers: { "Which one?": "A" } });
+    assert.equal((await askingAgain).behavior, "allow");
+    s.resolvePending(s.snapshot().pending[0]!.id, { kind: "cancel" });
+    await plan;
+  } finally {
+    await s.shutdown();
+  }
+});
+
+test("AskUserQuestion preference can be saved before a session starts", async () => {
+  created = [];
+  const { updateSession } = await import("./sessions.ts");
+  const id = crypto.randomUUID();
+  const dir = newDir();
+  await updateSession(id, dir, { askQuestionsEnabled: false });
+  const restored = new LiveSession(id, dir, () => {});
+  assert.equal(restored.askQuestionsEnabled, false);
+  assert.equal(created.length, 0);
+  await restored.shutdown();
+});
+
+test("write toggle takes effect during a live query and also guards subsequent subagent calls", async () => {
+  const { updateSession } = await import("./sessions.ts");
+  const { db } = await import("./db.ts");
+  created = [];
+  const dir = newDir(), id = crypto.randomUUID();
+  const s = await sessions.getOrCreate(id, dir);
+  const firstClient: import("../shared/protocol.ts").LiveEvent[] = [], secondClient: typeof firstClient = [];
+  const offA = s.subscribe((_seq, event) => firstClient.push(event));
+  const offB = s.subscribe((_seq, event) => secondClient.push(event));
+  try {
+    assert.equal(s.snapshot().writeEnabled, true);
+    await s.send(crypto.randomUUID(), "working");
+    const query = created[0]!;
+    const pre = query.args.options.hooks.PreToolUse[0].hooks[0];
+    const check = (tool_name: string, agent_id?: string) => pre({ hook_event_name: "PreToolUse", tool_name, agent_id });
+    assert.deepEqual(await check("Write"), {});
+    await updateSession(id, dir, { writeEnabled: false });
+    assert.equal(db.prepare("SELECT write_enabled FROM session_view WHERE session_id=?").get(id)?.write_enabled, 0);
+    assert.equal(s.state, "running");
+    assert.equal(created.length, 1);
+    assert.equal(query.closed, false);
+    for (const tool of ["Bash", "Write", "Edit", "NotebookEdit", "EnterWorktree"]) {
+      for (const agent of [undefined, "child", "nested-child"]) {
+        assert.equal((await check(tool, agent)).hookSpecificOutput.permissionDecision, "deny");
+      }
+    }
+    for (const tool of ["Read", "Grep", "Glob", "Agent", "AskUserQuestion", "ExitPlanMode"]) assert.deepEqual(await check(tool, "child"), {});
+    assert.deepEqual(firstClient.filter((event) => event.k === "settings"), secondClient.filter((event) => event.k === "settings"));
+    assert.ok(firstClient.some((event) => event.k === "settings" && event.writeEnabled === false));
+    assert.equal(s.snapshot().writeEnabled, false, "reconnecting devices receive the current authoritative value");
+    await assert.rejects(s.runBash(crypto.randomUUID(), "echo should-not-run"), /只读/);
+    await s.setPlanMode(true);
+    const plan = (s as any).canUseTool("ExitPlanMode", { plan: "plan" }, { signal: new AbortController().signal, toolUseID: "exit-plan" });
+    const pending = s.snapshot().pending.find((item) => item.kind === "plan")!;
+    assert.equal(s.resolvePending(pending.id, { kind: "plan", approve: true }), true);
+    assert.equal((await plan).behavior, "allow");
+    assert.equal(s.planMode, false);
+    assert.equal((await check("Write", "child")).hookSpecificOutput.permissionDecision, "deny", "plan approval cannot override the write switch");
+    await s.setPlanMode(true);
+    await updateSession(id, dir, { writeEnabled: true });
+    assert.equal(s.planMode, true, "enabling writes does not exit plan mode");
+    assert.deepEqual(await check("Write", "child"), {}, "enabled returns no allow override: ordinary permission checks still apply");
+    assert.equal(created.length, 1);
+    assert.equal(query.closed, false);
+    assert.ok(secondClient.some((event) => event.k === "settings" && event.writeEnabled === true));
+  } finally { offA(); offB(); await sessions.drop(id); }
+});
+
+test("write preference survives unloaded sessions, query restarts and btw defaults", async () => {
+  const { updateSession } = await import("./sessions.ts");
+  const { db } = await import("./db.ts");
+  const { askBtw, promoteBtw } = await import("./btw.ts");
+  const dir = newDir(), id = crypto.randomUUID();
+  created = [];
+  await updateSession(id, dir, { writeEnabled: false });
+  const s = await sessions.getOrCreate(id, dir);
+  try {
+    assert.equal(s.snapshot().writeEnabled, false);
+    await s.wake();
+    const first = created.at(-1)!;
+    assert.equal(first.args.options.permissionMode, "bypassPermissions", "the write flag is independent of permission mode");
+    assert.equal(first.args.options.disallowedTools, undefined, "the tool set must remain available for runtime re-enabling");
+    await s.stop();
+    await s.wake();
+    assert.equal(s.snapshot().writeEnabled, false);
+    assert.equal(created.length, 2);
+    const { id: childId } = await askBtw(dir, id, "side question");
+    const child = sessions.get(childId)!;
+    try {
+      assert.equal(child.snapshot().writeEnabled, false);
+      assert.equal(db.prepare("SELECT write_enabled FROM session_view WHERE session_id=?").get(childId)?.write_enabled, 0);
+      const q = created.at(-1)!;
+      const clear = await q.received(), boundary = await q.received(), question = await q.received();
+      assert.equal((clear.message as { content: unknown }).content, "/goal clear");
+      assert.equal(clear.shouldQuery, false);
+      const { BTW_BOUNDARY: boundaryText } = await import("./btw-instructions.ts");
+      assert.deepEqual(boundary.message, { role: "user", content: boundaryText });
+      assert.equal(boundary.shouldQuery, false, "the boundary must not trigger its own model turn");
+      assert.notEqual(boundary.uuid, question.uuid);
+      assert.notEqual(boundary.isSynthetic, true, "the boundary is a normal persisted user message");
+      assert.deepEqual(child.events.flatMap(({ ev }) => ev.k === "user" ? [ev.text] : []), [boundaryText, "side question"]);
+      assert.equal(s.events.some(({ ev }) => ev.k === "user" && ev.text === boundaryText), false, "the parent receives no boundary message");
+      assert.deepEqual((question.message as { content: unknown }).content, [{ type: "text", text: "side question" }]);
+      (child as any).handle({ type: "system", subtype: "session_state_changed", state: "idle" });
+      (child as any).handle({ type: "result", uuid: "initialization", subtype: "success", num_turns: 0, user_message_uuids: [clear.uuid], total_cost_usd: 0 });
+      assert.equal(child.state, "running", "clearing the inherited goal cannot finish the queued side question");
+      assert.equal(child.queuedMessageCount, 2);
+      assert.equal(child.events.some(({ ev }) => ev.k === "sdk" && ev.m.uuid === "initialization"), false);
+      assert.equal(db.prepare("SELECT btw_goal_isolated FROM session_view WHERE session_id=?").get(childId)?.btw_goal_isolated, 1);
+      (child as any).handle({ type: "system", subtype: "session_state_changed", state: "idle" });
+      (child as any).handle({ type: "result", uuid: "boundary-append", subtype: "success", num_turns: 0, user_message_uuids: [boundary.uuid], total_cost_usd: 0 });
+      assert.equal(child.state, "running", "appending the boundary cannot finish the queued side question");
+      assert.equal(child.queuedMessageCount, 1);
+      assert.equal(child.events.some(({ ev }) => ev.k === "sdk" && ev.m.uuid === "boundary-append"), false, "the append must not create an empty cost row");
+      (child as any).handle({ type: "result", uuid: "side-answer", subtype: "success", num_turns: 1, user_message_uuids: [question.uuid], total_cost_usd: 0.01 });
+      assert.equal(child.queuedMessageCount, 0);
+      assert.ok(child.events.some(({ ev }) => ev.k === "sdk" && ev.m.uuid === "side-answer"), "the real answer's result must remain visible");
+      writeTranscript(dir, childId, [
+        { type: "user", uuid: clear.uuid, message: { role: "user", content: "<command-name>/goal</command-name><command-args>clear</command-args>" } },
+        { type: "user", uuid: boundary.uuid, message: boundary.message },
+        { type: "user", uuid: question.uuid, message: question.message },
+      ]);
+      await child.stop();
+      await child.wake();
+      assert.equal((child as any).inheritedGoalCommand, undefined, "completed isolation is not repeated on resume");
+      await child.send(crypto.randomUUID(), "follow-up question");
+      assert.deepEqual((await created.at(-1)!.received()).message, { role: "user", content: [{ type: "text", text: "follow-up question" }] }, "resuming does not inject another boundary");
+      await updateSession(childId, dir, { writeEnabled: true });
+      assert.equal(child.snapshot().writeEnabled, true, "btw defaults can be changed explicitly");
+      promoteBtw(dir, childId);
+      assert.equal(child.snapshot().writeEnabled, true, "promotion does not silently change the saved switch");
+    } finally { await sessions.drop(childId); }
+    const restored = new LiveSession(id, dir, () => {});
+    assert.equal(restored.snapshot().writeEnabled, false, "a new server-side object restores the persisted switch");
+    restored.close();
+  } finally { await sessions.drop(id); }
+});
+
+test("btw keeps inherited history and appends its boundary only in the child", async () => {
+  const { getSessionMessages } = await import("@anthropic-ai/claude-agent-sdk");
+  const { askBtw } = await import("./btw.ts");
+  const dir = newDir(), parentId = crypto.randomUUID();
+  writeTranscript(dir, parentId, [
+    { type: "user", message: { role: "user", content: "Continue the main task." } },
+    { type: "assistant", message: { role: "assistant", content: [{ type: "text", text: "Main task context." }] } },
+  ]);
+  const before = await getSessionMessages(parentId, { dir });
+  assert.equal(before.length, 2);
+  created = [];
+  const { id } = await askBtw(dir, parentId, "Explain one detail.");
+  try {
+    const inherited = await getSessionMessages(id, { dir });
+    assert.deepEqual(inherited.map(({ type, message }) => ({ type, message })), before.map(({ type, message }) => ({ type, message })), "the native fork retains the parent context with its own message identities");
+    assert.deepEqual(await getSessionMessages(parentId, { dir }), before, "the parent transcript stays unchanged");
+    const q = created.at(-1)!;
+    await q.received(); // inherited goal cleanup
+    const boundary = await q.received(), question = await q.received();
+    assert.match((boundary.message as { content: string }).content, /Everything before this boundary/);
+    assert.equal(boundary.shouldQuery, false);
+    assert.deepEqual((question.message as { content: unknown }).content, [{ type: "text", text: "Explain one detail." }]);
+  } finally { await sessions.drop(id); }
+});
+
+test("concurrent /btw requests share one branch until promotion and never broadcast to another session", async () => {
+  const { askBtw, promoteBtw } = await import("./btw.ts");
+  const { db } = await import("./db.ts");
+  const dir = newDir(), parentId = crypto.randomUUID();
+  const parent = await sessions.getOrCreate(parentId, dir);
+  created = [];
+  const ids = new Set<string>();
+  try {
+    const results = await Promise.all(["first", "second", "third"].map((question) => askBtw(dir, parentId, question)));
+    results.forEach(({ id }) => ids.add(id));
+    assert.equal(ids.size, 1);
+    assert.equal(created.length, 1);
+    const id = results[0]!.id, child = sessions.get(id)!;
+    assert.deepEqual(child.events.flatMap(({ ev }) => ev.k === "user" && ["first", "second", "third"].includes(ev.text) ? [ev.text] : []), ["first", "second", "third"]);
+    assert.equal(parent.events.length, 0, "none of the side questions reach the parent");
+    assert.equal((await askBtw(dir, parentId, "")).id, id, "bare /btw only opens the existing branch");
+    assert.equal((await askBtw(dir, id, "follow-up from inside")).id, id, "inside /btw cannot fork another branch");
+    assert.equal(db.prepare("SELECT COUNT(*) AS n FROM session_view WHERE btw_parent=?").get(id)?.n, 0);
+    assert.equal(db.prepare("SELECT COUNT(*) AS n FROM session_view WHERE btw_parent=?").get(parentId)?.n, 1);
+    const before = child.events.length;
+    promoteBtw(dir, id);
+    const next = await askBtw(dir, parentId, "new side question after promotion");
+    ids.add(next.id);
+    assert.notEqual(next.id, id);
+    assert.equal(db.prepare("SELECT COUNT(*) AS n FROM session_view WHERE btw_parent=?").get(parentId)?.n, 1);
+    assert.equal(child.events.length, before, "the promoted branch does not receive the new branch's prompt");
+  } finally {
+    for (const id of ids) await sessions.drop(id);
+    await sessions.drop(parentId);
+  }
+});
+
+test("btw identity and read-only context are injected on every prompt and change live on promotion", async () => {
+  const { askBtw, promoteBtw } = await import("./btw.ts");
+  const { updateSession } = await import("./sessions.ts");
+  const dir = newDir(), parentId = crypto.randomUUID();
+  created = [];
+  const { id } = await askBtw(dir, parentId, "explain only");
+  try {
+    const q = created[0]!, child = sessions.get(id)!;
+    const prompt = q.args.options.hooks.UserPromptSubmit[0].hooks[0];
+    const pre = q.args.options.hooks.PreToolUse[0].hooks[0];
+    const context = async () => (await prompt({ hook_event_name: "UserPromptSubmit" })).hookSpecificOutput?.additionalContext;
+    assert.match(await context(), /btw side conversation/);
+    assert.match(await context(), /disabled writes/);
+    assert.match(await context(), /Inherited history is reference-only/);
+    for (const tool of ["Write", "Bash", "mcp__external__change_files", "UnknownMutation", "Agent", "SendMessage"]) {
+      assert.equal((await pre({ hook_event_name: "PreToolUse", tool_name: tool })).hookSpecificOutput.permissionDecision, "deny", tool);
+      const permission = await (child as any).canUseTool(tool, {}, { signal: new AbortController().signal, toolUseID: tool });
+      assert.equal(permission.behavior, "deny", "permission callbacks also enforce the policy");
+    }
+    for (const tool of ["Read", "Grep", "Glob", "WebFetch"]) assert.deepEqual(await pre({ hook_event_name: "PreToolUse", tool_name: tool }), {});
+    await updateSession(id, dir, { writeEnabled: true });
+    assert.match(await context(), /Writes are enabled/);
+    assert.equal((await pre({ hook_event_name: "PreToolUse", tool_name: "Agent" })).hookSpecificOutput.permissionDecision, "deny", "side chats cannot delegate even with writes enabled");
+    promoteBtw(dir, id);
+    assert.match(await context(), /promoted.*ordinary conversation/);
+    assert.deepEqual(await pre({ hook_event_name: "PreToolUse", tool_name: "Agent" }), {});
+    assert.equal(created.length, 1, "changing the role requires no CLI restart");
+    assert.equal(child.writeEnabled, true, "promotion preserves the user's explicit permission choice");
+  } finally { await sessions.drop(id); }
+});
+
+test("btw previews are bounded, exclude inherited answers and respect rewind branches", async () => {
+  const { btwInfo } = await import("./btw.ts");
+  const { db } = await import("./db.ts");
+  const dir = newDir(), parentId = crypto.randomUUID(), id = crypto.randomUUID(), prompt = crypto.randomUUID(), inherited = crypto.randomUUID();
+  db.prepare("INSERT INTO session_view(session_id,project_path,btw_parent,btw_prompt_uuid,btw_question,write_enabled) VALUES(?,?,?,?,?,0)").run(id, dir, parentId, prompt, "side question");
+  const prefix = [
+    { type: "assistant", uuid: inherited, message: { role: "assistant", content: [{ type: "text", text: "inherited parent answer" }] } },
+    { type: "user", uuid: prompt, message: { role: "user", content: "side question" } },
+  ];
+  try {
+    writeTranscript(dir, id, prefix.slice(0, 1));
+    assert.equal((await btwInfo(dir, parentId)).children[0]?.answer, undefined);
+    writeTranscript(dir, id, [...prefix, { type: "assistant", message: { role: "assistant", content: [{ type: "text", text: "own answer ".repeat(1000) }] } }]);
+    const answer = (await btwInfo(dir, parentId)).children[0]?.answer;
+    assert.equal(answer?.length, 2000);
+    assert.ok(answer?.startsWith("own answer"));
+    db.prepare("UPDATE session_view SET rewind_anchor=? WHERE session_id=?").run(inherited, id);
+    assert.equal((await btwInfo(dir, parentId)).children[0]?.answer, undefined, "rewinding before the question cannot expose the parent's answer as the side response");
+  } finally { await sessions.drop(id); }
+});
+
+test("a failed context append stops the query and reports the error without an empty result row", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  try {
+    await s.send(crypto.randomUUID(), "side question", [], "Side conversation boundary.");
+    const q = created.at(-1)!;
+    const boundary = await q.received();
+    (s as any).handle({ type: "result", uuid: "append-failed", subtype: "error_during_execution", is_error: true, num_turns: 0, user_message_uuids: [boundary.uuid] });
+    assert.equal(q.closed, true);
+    assert.ok(s.events.some(({ ev }) => ev.k === "error" && ev.message.includes("历史边界未能写入")));
+    assert.equal(s.events.some(({ ev }) => ev.k === "sdk" && ev.m.uuid === "append-failed"), false);
+    await tick();
+    assert.equal(s.queuedMessageCount, 0);
+    assert.equal(s.snapshot().state, "idle");
+  } finally { await s.shutdown(); }
+});
+
+test("cold promoted btw retries interrupted goal cleanup and preserves a recorded own goal", async () => {
+  const { db } = await import("./db.ts");
+  const { promoteBtw } = await import("./btw.ts");
+  const dir = newDir(), id = crypto.randomUUID(), prompt = crypto.randomUUID();
+  db.prepare("INSERT INTO session_view (session_id, project_path, btw_parent, btw_prompt_uuid) VALUES (?, ?, ?, ?)").run(id, dir, crypto.randomUUID(), prompt);
+  promoteBtw(dir, id);
+  const s = new LiveSession(id, dir, () => {});
+  try {
+    await s.wake();
+    assert.equal((await created.at(-1)!.received()).shouldQuery, false);
+    await s.stop();
+    assert.equal(db.prepare("SELECT btw_goal_isolated FROM session_view WHERE session_id=?").get(id)?.btw_goal_isolated, 0, "interrupted cleanup is not marked complete");
+    await s.wake();
+    const clear = await created.at(-1)!.received();
+    (s as any).handle({ type: "result", subtype: "error_during_execution", is_error: true, num_turns: 0, user_message_uuids: [clear.uuid] });
+    assert.equal(db.prepare("SELECT btw_goal_isolated FROM session_view WHERE session_id=?").get(id)?.btw_goal_isolated, 0, "failed cleanup is retried too");
+    await s.stop();
+    const files = path.join(process.env.CLAUDE_CONFIG_DIR!, "projects", dir.replace(/[^a-zA-Z0-9]/g, "-"));
+    fs.mkdirSync(files, { recursive: true });
+    const records = [
+      { type: "attachment", attachment: { type: "goal_status", sentinel: true, condition: "parent" } },
+      { type: "user", uuid: prompt, message: { content: "side question" } },
+      { type: "attachment", attachment: { type: "goal_status", sentinel: true, condition: "child goal" } },
+      { type: "user", message: { content: "<command-name>/goal</command-name><command-args>child goal</command-args>" } },
+    ];
+    writeTranscript(dir, id, records);
+    await s.wake();
+    assert.equal((s as any).inheritedGoalCommand, undefined, "native attachment-before-command owns the goal, even on cold legacy promotion");
+    assert.equal(db.prepare("SELECT btw_goal_isolated FROM session_view WHERE session_id=?").get(id)?.btw_goal_isolated, 0, "a read-only projection does not mutate a permanent isolation flag");
+  } finally { await s.shutdown(); }
+});
+
+test("rewind validates btw isolation in the resumed branch and preserves retained own goals", async () => {
+  const { db } = await import("./db.ts");
+  const { goalState } = await import("./session-file.ts");
+  const dir = newDir(), id = crypto.randomUUID(), prompt = crypto.randomUUID(), clearId = crypto.randomUUID();
+  const parentAnchor = crypto.randomUUID(), ownAnchor = crypto.randomUUID();
+  const command = (args: string) => ({ role: "user", content: `<command-name>/goal</command-name><command-args>${args}</command-args>` });
+  const effect = (condition: string, met = false) => ({ type: "attachment", attachment: { type: "goal_status", condition, sentinel: true, met } });
+  const original: Msg[] = [
+    { ...effect("parent"), forkedFrom: { sessionId: "parent" } },
+    { type: "user", uuid: parentAnchor, message: command("parent"), forkedFrom: { sessionId: "parent" } },
+    effect("parent", true), { type: "user", uuid: clearId, message: command("clear") },
+    { type: "user", uuid: prompt, message: { role: "user", content: "side question" } },
+    effect("own"), { type: "user", uuid: ownAnchor, message: command("own") },
+  ];
+  writeTranscript(dir, id, original);
+  db.prepare("INSERT INTO session_view (session_id, project_path, btw_prompt_uuid, btw_goal_isolated, btw_goal_isolation_uuid) VALUES (?, ?, ?, 1, ?)").run(id, dir, prompt, clearId);
+  const s = new LiveSession(id, dir, () => {});
+  try {
+    await s.rewindConversation(dir, parentAnchor, "rewritten parent input");
+    assert.equal(await goalState(dir, id), null, "a discarded own goal cannot establish isolation in the pending branch");
+    await s.send(crypto.randomUUID(), "rewritten parent input");
+    const q = created.at(-1)!;
+    assert.equal(q.args.options.resumeSessionAt, parentAnchor);
+    const clear = await q.received(), user = await q.received();
+    assert.equal((clear.message as Msg).content, "/goal clear", "a permanent old flag cannot skip branch-local isolation");
+    assert.equal(clear.shouldQuery, false);
+    const clearedStatus = crypto.randomUUID();
+    writeTranscript(dir, id, [...original,
+      { ...effect("parent", true), uuid: clearedStatus, parentUuid: parentAnchor },
+      { type: "user", uuid: clear.uuid, parentUuid: clearedStatus, message: command("clear") },
+      { type: "user", uuid: user.uuid, parentUuid: clear.uuid, message: user.message },
+    ]);
+    (s as any).handle({ type: "result", subtype: "success", num_turns: 0, user_message_uuids: [clear.uuid] });
+    assert.equal((await goalState(dir, id))?.status, "cleared");
+    await s.stop(); await s.wake();
+    assert.equal((s as any).inheritedGoalCommand, undefined, "this branch retains its own successful cleanup");
+    await s.rewindConversation(dir, ownAnchor, "continue own goal");
+    assert.equal((await goalState(dir, id))?.condition, "own");
+    await s.send(crypto.randomUUID(), "continue own goal");
+    const preserved = created.at(-1)!;
+    assert.equal(preserved.args.options.resumeSessionAt, ownAnchor);
+    assert.equal((s as any).inheritedGoalCommand, undefined, "rewinding within a valid own goal does not clear it");
+    assert.notEqual((await preserved.received()).shouldQuery, false);
+  } finally { await s.shutdown(); }
+});
+
+for (const order of ["result-then-idle", "idle-then-result"] as const) {
+  test(`a failed turn notifies as failed (${order})`, async () => {
+    created = [];
+    const transitions: { to: string; failed: boolean }[] = [];
+    const s = new LiveSession(crypto.randomUUID(), newDir(), () => {}, (_from, to, turn) => {
+      if (!turn.silent) transitions.push({ to, failed: turn.failed });
+    });
+    await s.send(crypto.randomUUID(), "hi");
+    const q = created[0]!;
+    const idle = { type: "system", subtype: "session_state_changed", state: "idle", uuid: crypto.randomUUID(), session_id: "x" };
+    const result = { type: "result", subtype: "success", is_error: true, total_cost_usd: 0, uuid: crypto.randomUUID(), session_id: "x" };
+    for (const m of order === "result-then-idle" ? [result, idle] : [idle, result]) q.push(m);
+    await tick();
+    const ended = transitions.filter((t) => t.to === "idle");
+    assert.equal(ended.length, 1, JSON.stringify(transitions));
+    assert.equal(ended[0]!.failed, true);
+    await s.shutdown();
+  });
+}
+
+test("deleting a session can't race with a client creating it again", async () => {
+  created = [];
+  const dir = newDir();
+  const id = crypto.randomUUID();
+  const s = await sessions.getOrCreate(id, dir);
+  await s.send(crypto.randomUUID(), "hi");
+  const dropping = sessions.drop(id);
+  // Another client subscribes while the delete is in progress: it must get the closed instance…
+  const during = await sessions.getOrCreate(id, dir);
+  assert.equal(during, s);
+  await during.send(crypto.randomUUID(), "again"); // …which refuses to start a new CLI process
+  await dropping;
+  await tick();
+  assert.equal(created.length, 1);
+  assert.ok(created[0]!.closed);
+});
+
+test("send and stop are serialized through delivery", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  await s.wake();
+  const received = created[0]!.received();
+  const sending = s.send(crypto.randomUUID(), "must arrive");
+  let stopping: Promise<void> | undefined;
+  queueMicrotask(() => { stopping = s.stop(); });
+  await sending;
+  assert.match(JSON.stringify(await received), /must arrive/);
+  await stopping;
+  assert.equal(created.length, 1);
+  assert.equal(created[0]!.closed, true);
+});
+
+test("a config reload during start does not stop the starting process", async () => {
+  created = [];
+  const id = crypto.randomUUID();
+  // With an extra directory the start has a second step (applying it) after the process exists.
+  const { insertSessionDir } = await import("./session-dirs.ts");
+  insertSessionDir(id, newDir());
+  const s = new LiveSession(id, newDir(), () => {});
+  const sending = s.send(crypto.randomUUID(), "hello");
+  while (created.length === 0) await new Promise((r) => setImmediate(r)); // the process exists, start not finished
+  await s.reloadConfig();
+  await sending;
+  await tick();
+  assert.equal(created.length, 1);
+  assert.equal(created[0]!.closed, false);
+  await s.shutdown();
+});
+
+test("sessions with scheduled tasks are resumed after a restart", async () => {
+  created = [];
+  const dir = newDir();
+  const id = crypto.randomUUID();
+  const s = await sessions.getOrCreate(id, dir);
+  await s.send(crypto.randomUUID(), "/loop 1m ping");
+  // The CLI reports its scheduled tasks through the Stop hook.
+  const stop = created[0]!.args.options.hooks.Stop[0].hooks[0];
+  await stop({ session_crons: [{ id: "c1", schedule: "* * * * *", recurring: true, prompt: "ping" }] });
+  // "Restart": the in-memory session is gone, the process too.
+  await s.stop();
+  (sessions as unknown as { live: Map<string, unknown> }).live.delete(id);
+  const before = created.length;
+  await sessions.resumeScheduled();
+  assert.equal(created.length, before + 1, "the session's CLI process was brought back");
+  assert.equal(created.at(-1)!.args.options.resume ?? created.at(-1)!.args.options.sessionId, id);
+  // Once its tasks are gone it is no longer resumed.
+  await created.at(-1)!.args.options.hooks.Stop[0].hooks[0]({ session_crons: [] });
+  await sessions.drop(id);
+  const n = created.length;
+  await sessions.resumeScheduled();
+  assert.equal(created.length, n);
+});
+
+test("a restarted session shows its persisted task list before the next Stop", async () => {
+  created = [];
+  const dir = newDir();
+  const id = crypto.randomUUID();
+  const s = await sessions.getOrCreate(id, dir);
+  await s.wake();
+  const stop = created[0]!.args.options.hooks.Stop[0].hooks[0];
+  await stop({ session_crons: [{ id: "c1", schedule: "*/5 * * * *", recurring: true, prompt: "ping" }] });
+  await s.stop();
+  (sessions as unknown as { live: Map<string, unknown> }).live.delete(id);
+
+  await sessions.resumeScheduled();
+  const restored = await sessions.getOrCreate(id, dir);
+  assert.deepEqual(restored.snapshot().crons.map((c) => c.id), ["c1"], "the cached list is visible immediately");
+  assert.equal(restored.snapshot().cronsStale, false, "a non-empty cached list needs no refresh prompt");
+  assert.equal(restored.reapIfIdle(0), false, "a cached task list prevents idle reaping");
+  await sessions.drop(id);
+});
+
+test("durable tasks are visible, keep the session scheduled, and persist across a restart", async () => {
+  created = [];
+  const dir = newDir();
+  const id = crypto.randomUUID();
+  fs.mkdirSync(path.join(dir, ".claude"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".claude", "scheduled_tasks.json"), JSON.stringify({
+    tasks: [
+      { id: "d1", cron: "0 9 * * *", prompt: "daily", recurring: true, createdBySessionId: id },
+      { id: "d2", cron: "0 10 * * *", prompt: "elsewhere", recurring: true, createdBySessionId: crypto.randomUUID() },
+    ],
+  }));
+  const s = await sessions.getOrCreate(id, dir);
+  await s.wake();
+  try {
+    assert.deepEqual(s.snapshot().crons.map((c) => c.id), ["d1", "d2"], "every session shows all project durable tasks");
+    assert.equal(s.snapshot().crons[0]!.durable, true);
+    assert.equal(s.reapIfIdle(0), false, "durable work prevents idle reaping");
+    await s.stop();
+    (sessions as unknown as { live: Map<string, unknown> }).live.delete(id);
+    const before = created.length;
+    await sessions.resumeScheduled();
+    assert.equal(created.length, before + 1, "the durable task's owner is brought back");
+    await sessions.getOrCreate(id, dir);
+  } finally {
+    await sessions.drop(id);
+  }
+});
+
+test("a non-owner session shows project durable tasks without claiming them", async () => {
+  created = [];
+  const dir = newDir();
+  const id = crypto.randomUUID();
+  fs.mkdirSync(path.join(dir, ".claude"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".claude", "scheduled_tasks.json"), JSON.stringify({
+    tasks: [{ id: "d1", cron: "0 9 * * *", prompt: "daily", recurring: true, createdBySessionId: crypto.randomUUID() }],
+  }));
+  const s = await sessions.getOrCreate(id, dir);
+  await s.wake();
+  try {
+    assert.deepEqual(s.snapshot().crons.map((c) => c.id), ["d1"]);
+    assert.equal(s.hasScheduledWork(), false, "another session's durable task does not keep this process alive");
+    const { db } = await import("./db.ts");
+    assert.equal(db.prepare("SELECT 1 FROM scheduled_sessions WHERE session_id = ?").get(id), undefined);
+  } finally {
+    await s.shutdown();
+    await sessions.drop(id);
+  }
+});
+
+test("IDECron tasks appear in the snapshot and schedule delivery respects the mode", async () => {
+  created = [];
+  const { idecron } = await import("./idecron.ts");
+  const id = crypto.randomUUID();
+  const task = idecron.create({ sessionId: id, projectPath: "/tmp", when: "10m", prompt: "server tick" });
+  const s = new LiveSession(id, newDir(), () => {});
+  try {
+    assert.deepEqual(s.snapshot().crons.map((c) => c.id), [task.id]);
+    assert.equal(s.snapshot().crons[0]!.server, true);
+    assert.equal(await s.sendScheduled("steer-1", "do the server tick", "steer"), true);
+    const q = created[0]!;
+    const msg = await q.received();
+    assert.equal(msg.priority, undefined, "an idle steer starts a normal turn");
+    assert.equal(msg.client_composed, true);
+    assert.equal(await s.sendScheduled("next-1", "not yet", "next_turn"), false, "a running session waits for the next turn");
+    assert.equal(await s.sendScheduled("steer-2", "steer now", "steer"), true);
+    const queued = await q.received();
+    assert.equal(queued.priority, "next", "a running steer is queued at the next safe point");
+    q.push({ type: "command_lifecycle", command_uuid: "steer-1", state: "completed" });
+    q.push({ type: "command_lifecycle", command_uuid: "steer-2", state: "completed" });
+    q.push({ type: "result", subtype: "success", is_error: false, total_cost_usd: 0, uuid: "steer-1", session_id: "x" });
+    q.push({ type: "system", subtype: "session_state_changed", state: "idle" });
+    await tick();
+    assert.equal(await s.sendScheduled("next-1", "now", "next_turn"), true);
+    assert.equal(idecron.cancel(task.id, id), true);
+    assert.deepEqual(s.snapshot().crons, []);
+  } finally {
+    await s.shutdown();
+  }
+});
+
+test("deleting the durable file clears a durable-only stale row", async () => {
+  created = [];
+  const dir = newDir();
+  const id = crypto.randomUUID();
+  fs.mkdirSync(path.join(dir, ".claude"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".claude", "scheduled_tasks.json"), JSON.stringify({
+    tasks: [{ id: "d1", cron: "0 9 * * *", prompt: "daily", recurring: true, createdBySessionId: id }],
+  }));
+  const s = await sessions.getOrCreate(id, dir);
+  await s.wake();
+  try {
+    assert.equal(s.snapshot().crons.length, 1);
+    fs.rmSync(path.join(dir, ".claude", "scheduled_tasks.json"));
+    assert.equal(s.hasScheduledWork(), false, "the deleted file no longer protects the process");
+    assert.equal(s.snapshot().crons.length, 0);
+    const { db } = await import("./db.ts");
+    assert.equal(db.prepare("SELECT 1 FROM scheduled_sessions WHERE session_id = ?").get(id), undefined, "the stale row is removed");
+  } finally {
+    await s.shutdown();
+    await sessions.drop(id);
+  }
+});
+
+test("cron refresh runs one turn, lists tasks through the Stop hook, and does not notify", async () => {
+  created = [];
+  const transitions: { to: string; silent: boolean }[] = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {}, (_from, to, turn) => {
+    transitions.push({ to, silent: turn.silent });
+  });
+  try {
+    s.hydrateCrons([], true);
+    await s.refreshCrons();
+    const q = created[0]!;
+    const msg = await q.received();
+    const prompt = JSON.stringify(msg.message);
+    assert.match(prompt, /系统恢复/);
+    assert.match(prompt, /CronList/);
+    assert.doesNotMatch(prompt, /claude-ide/);
+    await q.args.options.hooks.Stop[0].hooks[0]({
+      session_crons: [{ id: "c1", schedule: "*/5 * * * *", recurring: true, prompt: "ping" }],
+    });
+    assert.equal(s.snapshot().cronsStale, false);
+    assert.deepEqual(s.snapshot().crons.map((c) => c.id), ["c1"]);
+    q.push({ type: "result", subtype: "success", is_error: false, total_cost_usd: 0, uuid: "refresh", session_id: "x" });
+    q.push({ type: "system", subtype: "session_state_changed", state: "idle" });
+    await tick();
+    assert.equal(transitions.find((t) => t.to === "idle")?.silent, true, "the refresh turn does not notify");
+  } finally {
+    await s.shutdown();
+  }
+});
+
+test("reload landing during delivery preserves the message", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  await s.wake();
+  const received = created[0]!.received();
+  const sending = s.send("delivery", "keep me");
+  let reload: Promise<void> | undefined;
+  queueMicrotask(() => { reload = s.reloadConfig(); });
+  await sending;
+  await reload;
+  assert.match(JSON.stringify(await received), /keep me/);
+  assert.equal(created[0]!.closed, false);
+  await s.shutdown();
+});
+
+for (const order of ["result-first", "idle-first"] as const) {
+  test(`reload waits for queued B after A ends (${order})`, async () => {
+    created = [];
+    const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+    await s.send("A", "first");
+    const q = created[0]!;
+    await q.received();
+    await s.reloadConfig();
+    await s.send("B", "second");
+    const idle = { type: "system", subtype: "session_state_changed", state: "idle" };
+    const result = (uuid: string) => ({ type: "result", subtype: "success", is_error: false, user_message_uuids: [uuid] });
+    for (const m of order === "result-first" ? [result("A"), idle] : [idle, result("A")]) q.push(m);
+    await tick();
+    assert.equal(q.closed, false, "B still needs this process");
+    assert.equal((await q.received()).uuid, "B");
+    for (const m of order === "result-first" ? [result("B"), idle] : [idle, result("B")]) q.push(m);
+    await tick();
+    assert.equal(q.closed, true, "reload happens after both messages finish");
+    await s.shutdown();
+  });
+}
+
+test("no-model commands finish through lifecycle events before config reload", async () => {
+  created = [];
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  await s.runBash("bang", "printf test");
+  await s.reloadConfig();
+  assert.equal(created[0]!.closed, false);
+  created[0]!.push({ type: "command_lifecycle", command_uuid: "bang", state: "completed" });
+  await tick();
+  assert.equal(created[0]!.closed, true);
+  await s.shutdown();
+});
+
+test("/cd moves imported session callbacks, persistence and scheduled ownership", async (t) => {
+  created = [];
+  const { changeSessionDir, pendingRewindDraft } = await import("./sessions.ts");
+  const { db } = await import("./db.ts");
+  const { encodeProjectId } = await import("../shared/protocol.ts");
+  const dir = newDir(), target = newDir(), id = crypto.randomUUID();
+  const s = await sessions.getOrCreate(id, dir); // no session_view row, like a CLI import
+  await s.wake();
+  const hook = created[0]!.args.options.hooks.Stop[0].hooks[0];
+  await hook({ session_crons: [{ id: "c", schedule: "* * * * *", recurring: true, prompt: "ping" }] });
+  await changeSessionDir(id, dir, target);
+  assert.equal(s.cwd, target);
+  const notices: string[] = [];
+  // The manager broadcasts changes for every session. Other tests' deferred
+  // notifications may arrive while this test awaits SDK metadata; only these two
+  // project IDs can show whether this session's callback kept the old owner.
+  const watched = new Set([encodeProjectId(dir), encodeProjectId(target)]);
+  const unsubscribe = sessions.onSessionsChanged((pid) => { if (watched.has(pid)) notices.push(pid); });
+  const activity: string[] = [];
+  let activityArrived!: () => void;
+  const activityReceived = new Promise<void>((resolve) => { activityArrived = resolve; });
+  const unactivity = sessions.onActivity((a) => {
+    if (a.sessionId !== id) return;
+    activity.push(a.projectId);
+    activityArrived();
+  });
+  let activityTimer: ReturnType<typeof setTimeout> | undefined;
+  t.after(() => { clearTimeout(activityTimer); unsubscribe(); unactivity(); });
+  await s.send("cd-message", "hello");
+  created[0]!.push({ type: "result", subtype: "success", is_error: false, user_message_uuids: ["cd-message"] });
+  created[0]!.push({ type: "system", subtype: "session_state_changed", state: "idle" });
+  await Promise.race([activityReceived, new Promise<never>((_resolve, reject) => {
+    activityTimer = setTimeout(() => reject(new Error("Timed out waiting for the moved session's activity notification")), 3000);
+  })]);
+  clearTimeout(activityTimer);
+  assert.ok(notices.length > 0 && notices.every((pid) => pid === encodeProjectId(target)), `moved session notices: ${JSON.stringify(notices)}`);
+  assert.deepEqual(activity, [encodeProjectId(target)]);
+  assert.equal((db.prepare("SELECT project_path FROM session_view WHERE session_id=?").get(id) as any).project_path, target);
+  assert.equal((db.prepare("SELECT cwd FROM session_cwd WHERE session_id=?").get(id) as any).cwd, target);
+  assert.equal((db.prepare("SELECT project_path FROM scheduled_sessions WHERE session_id=?").get(id) as any).project_path, target);
+  await hook({ session_crons: [{ id: "c", schedule: "* * * * *", recurring: true, prompt: "ping" }] });
+  assert.equal((db.prepare("SELECT project_path FROM scheduled_sessions WHERE session_id=?").get(id) as any).project_path, target);
+  const rewindId = await s.rewindConversation(target, "anchor", "original");
+  assert.deepEqual(pendingRewindDraft(id), { rewindText: "original", rewindId });
+  const nextRewindId = await s.rewindConversation(target, "anchor", "original");
+  assert.notEqual(nextRewindId, rewindId, "repeating a rewind has a new identity");
+  unsubscribe(); unactivity();
+  await sessions.drop(id);
+  assert.equal((await sessions.getOrCreate(id, dir)).cwd, target, "old URL cannot reclaim ownership");
+  assert.equal(sessions.projectOf.get(id), target);
+  await sessions.drop(id);
+});
+
+test("/cd does not persist a directory rejected by the CLI trust response", async () => {
+  created = [];
+  const { changeSessionDir } = await import("./sessions.ts");
+  const { db } = await import("./db.ts");
+  const dir = newDir(), target = newDir(), id = crypto.randomUUID();
+  const s = await sessions.getOrCreate(id, dir);
+  await s.wake();
+  let calls = 0;
+  created[0]!.setCwd = async () => ++calls === 1
+    ? { status: "needs_trust", trusted_directory: target }
+    : { status: "error", error: "trust denied" };
+  await assert.rejects(changeSessionDir(id, dir, target), /trust denied/);
+  assert.equal(s.cwd, dir);
+  assert.equal(sessions.projectOf.get(id), dir);
+  assert.equal(db.prepare("SELECT cwd FROM session_cwd WHERE session_id=?").get(id), undefined);
+  assert.equal(db.prepare("SELECT project_path FROM session_view WHERE session_id=?").get(id), undefined);
+  await sessions.drop(id);
+});
+
+test("CACHE-002 active stream checkpoint survives the server replay ring", () => {
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const emit = (event: import("../shared/protocol.ts").LiveEvent) => (s as any).emit(event);
+  for (let i = 0; i < 6000; i++) emit({ k: "delta", msgId: "stream", index: 0, kind: "text", text: `${i},`, parent: null });
+  assert.equal(s.events.length, 5000);
+  assert.equal((s.streamingCheckpoints[0]?.ev as { text: string }).text, Array.from({ length: 6000 }, (_, i) => `${i},`).join(""));
+  emit({ k: "sdk", m: { type: "assistant", uuid: "done", message: { id: "stream", content: [{ type: "text", text: "done" }] } } });
+  assert.equal(s.streamingCheckpoints.length, 0);
+  s.close();
+});
+
+test("server publishes exact thinking stream identities alongside completed display messages", () => {
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const emit = (event: import("../shared/protocol.ts").LiveEvent) => (s as any).emit(event);
+  try {
+    emit({ k: "delta", msgId: "api", index: 7, kind: "thinking", text: "thought", parent: "agent" });
+    emit({ k: "sdk", m: { type: "assistant", uuid: "frame", parent_tool_use_id: "agent", message: { id: "api", content: [
+      { type: "text", text: "unstreamed" }, { type: "thinking", thinking: "thought" },
+    ] } } });
+    const event = s.events.at(-1)?.ev;
+    assert.ok(event?.k === "sdk");
+    assert.deepEqual(event.m._streamBlocks, [7]);
+    assert.deepEqual(event.m._streamThinking, { 1: 7 });
+    assert.equal(s.streamingCheckpoints.length, 0);
+  } finally { s.close(); }
+});
+
+test("CACHE-004 agent lifecycle survives transcript eviction and is recoverable in snapshots", () => {
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const handle = (message: Msg) => (s as any).handle(message);
+  handle({ type: "assistant", uuid: "agent-call", message: { content: [{ type: "tool_use", id: "agent-tool", name: "Agent", input: { description: "independent review", run_in_background: true } }] } });
+  handle({ type: "system", subtype: "task_started", uuid: "started", task_id: "agent-task", tool_use_id: "agent-tool", task_type: "local_agent", is_backgrounded: true, run_id: "run-2" });
+  for (let i = 0; i < 5100; i++) (s as any).emit({ k: "state", state: "running" });
+  assert.equal(s.events.some(({ ev }) => ev.k === "sdk" && ev.m.uuid === "agent-call"), false);
+  assert.equal(s.snapshot().agentTasks?.find((task) => task.toolUseId === "agent-tool")?.status, "running");
+  handle({ type: "user", uuid: "backgrounded", message: { content: [{ type: "tool_result", tool_use_id: "agent-tool", content: "running in background" }] } });
+  assert.equal(s.snapshot().agentTasks?.[0]?.status, "running");
+  handle({ type: "system", subtype: "task_notification", uuid: "finished", task_id: "agent-task", status: "completed", run_id: "run-2" });
+  assert.equal(s.snapshot().agentTasks?.[0]?.status, "completed");
+  assert.ok(s.events.some(({ ev }) => ev.k === "agent_tasks" && ev.tasks[0]?.status === "completed"));
+  handle({ type: "system", subtype: "task_started", uuid: "late", task_id: "agent-task", tool_use_id: "agent-tool", run_id: "run-1" });
+  assert.equal(s.snapshot().agentTasks?.[0]?.status, "completed");
+  s.close();
+});
+
+test("replayed agent messages retain their file identity after the task status map evicts their run", () => {
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const handle = (message: Msg) => (s as any).handle(message);
+  try {
+    handle({ type: "system", subtype: "task_started", task_id: "stable", tool_use_id: "resume-1", task_type: "local_agent" });
+    handle({ type: "assistant", uuid: "old-text", parent_tool_use_id: "resume-1", message: { model: "model", content: [{ type: "text", text: "old live" }] } });
+    handle({ type: "system", subtype: "task_notification", task_id: "stable", tool_use_id: "resume-1", status: "completed" });
+    for (let i = 0; i < 128; i++) handle({ type: "system", subtype: "task_started", task_id: `task-${i}`, tool_use_id: `tool-${i}`, task_type: "local_agent" });
+    assert.equal(s.snapshot().agentTasks?.some((task) => task.toolUseId === "resume-1"), false);
+    const replay = s.events.find(({ ev }) => ev.k === "sdk" && ev.m.uuid === "old-text")?.ev;
+    assert.ok(replay?.k === "sdk");
+    assert.equal(replay.agentId, "stable", "newly connected clients do not need an evicted task-start event");
+  } finally { s.close(); }
+});
+
+test("actual subagent models are captured at stream start and survive replay eviction", () => {
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const handle = (message: Msg) => (s as any).handle(message);
+  const model = (id: string) => s.snapshot().agentTasks?.find((task) => task.toolUseId === id)?.model;
+  try {
+    handle({ type: "assistant", message: { model: "main-model", content: ["agent-a", "agent-b"].map((id) => ({ type: "tool_use", id, name: "Agent", input: { model: "configured-hint" } })) } });
+    assert.equal(model("agent-a"), undefined, "a requested model is not an observed response");
+    handle({ type: "stream_event", parent_tool_use_id: "agent-a", event: { type: "message_start", message: { id: "response-a", model: "actual-a" } } });
+    assert.equal(model("agent-a"), "actual-a");
+    assert.equal(model("agent-b"), undefined);
+    assert.equal(s.events.some(({ ev }) => ev.k === "sdk" && ev.m.type === "stream_event"), false, "raw starts are not sent to clients");
+    assert.ok(s.events.some(({ ev }) => ev.k === "agent_tasks" && ev.tasks.some((task) => task.toolUseId === "agent-a" && task.model === "actual-a")));
+    handle({ type: "assistant", parent_tool_use_id: "agent-a", message: { model: "fallback-a", content: [{ type: "tool_use", id: "nested", name: "Agent", input: {} }] } });
+    handle({ type: "assistant", parent_tool_use_id: "nested", message: { model: "nested-model", content: [] } });
+    handle({ type: "assistant", parent_tool_use_id: "agent-b", message: { model: "actual-b", content: [] } });
+    handle({ type: "assistant", parent_tool_use_id: null, message: { model: "new-main-model", content: [] } });
+    handle({ type: "assistant", parent_tool_use_id: "agent-a", message: { model: "<synthetic>", content: [] } });
+    handle({ type: "assistant", parent_tool_use_id: "agent-a", error: "failed", message: { model: "error-model", content: [] } });
+    handle({ type: "assistant", parent_tool_use_id: "unknown", message: { model: "orphan-model", content: [] } });
+    assert.equal(s.snapshot().agentTasks?.length, 3, "response metadata must not create incomplete agent tasks");
+    for (let i = 0; i < 5100; i++) (s as any).emit({ k: "state", state: "running" });
+    assert.equal(s.events.some(({ ev }) => ev.k === "agent_tasks"), false);
+    assert.equal(model("agent-a"), "fallback-a");
+    assert.equal(model("agent-b"), "actual-b");
+    assert.equal(model("nested"), "nested-model");
+  } finally { s.close(); }
+});
+
+test("late metadata cannot make an older invocation receive current task updates", async () => {
+  const { currentAgentTask } = await import("../shared/agent-tasks.ts");
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const handle = (message: Msg) => (s as any).handle(message);
+  const current = () => currentAgentTask(s.snapshot().agentTasks ?? [], "stable");
+  try {
+    handle({ type: "system", subtype: "task_started", task_id: "stable", tool_use_id: "old-tool", task_type: "local_agent", run_id: "run-1" });
+    handle({ type: "system", subtype: "task_notification", task_id: "stable", tool_use_id: "old-tool", run_id: "run-1", status: "completed" });
+    handle({ type: "system", subtype: "task_started", task_id: "stable", tool_use_id: "resumed-tool", task_type: "local_agent", run_id: "run-2" });
+    handle({ type: "system", subtype: "task_progress", task_id: "stable", tool_use_id: "old-tool", run_id: "run-1", description: "late old progress" });
+    handle({ type: "assistant", parent_tool_use_id: "old-tool", message: { model: "old-model", content: [] } });
+    assert.equal(s.snapshot().agentTasks?.at(-1)?.toolUseId, "old-tool", "the probe really reorders map entries");
+    assert.equal(current()?.toolUseId, "resumed-tool");
+    handle({ type: "system", subtype: "task_updated", task_id: "stable", run_id: "run-2", patch: { status: "paused" } });
+    assert.equal(current()?.status, "paused", "an event without a tool ID targets the latest run");
+    handle({ type: "system", subtype: "task_notification", task_id: "stable", run_id: "run-1", status: "failed" });
+    assert.equal(current()?.status, "paused", "a late notification cannot terminate the newer run");
+    handle({ type: "system", subtype: "task_notification", task_id: "stable", run_id: "run-2", status: "completed" });
+    assert.equal(current()?.status, "completed");
+    assert.equal(s.snapshot().agentTasks?.find((task) => task.toolUseId === "old-tool")?.status, "completed");
+  } finally { s.close(); }
+});
+
+test("CACHE-004 foreground results finish only their agent and shutdown stops unfinished agents", () => {
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const handle = (message: Msg) => (s as any).handle(message);
+  handle({ type: "assistant", uuid: "calls", message: { content: ["first", "second"].map((id) => ({ type: "tool_use", id, name: "Agent", input: {} })) } });
+  handle({ type: "user", uuid: "r", message: { content: [{ type: "tool_result", tool_use_id: "first" }] } });
+  const statuses = new Map(s.snapshot().agentTasks?.map((task) => [task.toolUseId, task.status]));
+  assert.equal(statuses.get("first"), "completed");
+  assert.equal(statuses.get("second"), "running");
+  s.close();
+  assert.equal(s.snapshot().agentTasks?.find((task) => task.toolUseId === "second")?.status, "stopped");
+});
+
+
+test("CACHE-018 results settle only foreground tasks in their parent scope", () => {
+  const s = new LiveSession(crypto.randomUUID(), newDir(), () => {});
+  const track = (message: Msg) => (s as any).trackAgentTasks(message);
+  const call = (id: string, parent: string | null, background = false) => track({ type: "assistant", parent_tool_use_id: parent,
+    message: { content: [{ type: "tool_use", id, name: "Agent", input: { run_in_background: background } }] } });
+  call("background", null, true);
+  track({ type: "system", subtype: "task_started", tool_use_id: "background", task_id: "parent-task", task_type: "local_agent" });
+  call("child", "background");
+  track({ type: "system", subtype: "task_started", tool_use_id: "child", task_id: "child-task", parent_task_id: "parent-task", spawn_depth: 2 });
+  call("direct", null);
+  // task_started can supply ancestry even when no assistant tool-call frame is retained.
+  track({ type: "system", subtype: "task_started", tool_use_id: "metadata-child", task_id: "metadata-task", parent_task_id: "parent-task", task_type: "local_agent" });
+  track({ type: "result", subtype: "success", parent_tool_use_id: null });
+  const status = (id: string) => s.snapshot().agentTasks?.find((task) => task.toolUseId === id)?.status;
+  assert.equal(status("direct"), "completed");
+  assert.equal(status("background"), "running");
+  assert.equal(status("child"), "running");
+  assert.equal(status("metadata-child"), "running");
+  track({ type: "result", subtype: "success", parent_tool_use_id: "background" });
+  assert.equal(status("child"), "completed");
+  assert.equal(status("metadata-child"), "completed");
+  call("terminal-child", "background");
+  track({ type: "system", subtype: "task_notification", tool_use_id: "terminal-child", status: "failed" });
+  assert.equal(status("terminal-child"), "failed");
+  call("shutdown-child", "background");
+  s.close();
+  assert.equal(status("background"), "stopped");
+  assert.equal(status("shutdown-child"), "stopped");
+});