@jskit-ai/assistant-core 0.1.200 → 0.1.202

package/test/claudeInstructionResume.test.js

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, rm } from "node:fs/promises";
+import { createServer } from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import { createClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
+
+const execute = promisify(execFile);
+
+test("native Claude replaces a recorded system prompt on resume and retains ordinary history", { timeout: 90_000 }, async (t) => {
+  try { await execute("claude", ["--version"]); }
+  catch (error) { if (error.code === "ENOENT") { t.skip("Claude Code is not installed."); return; } throw error; }
+  const root = await mkdtemp(path.join(os.tmpdir(), "jskit-claude-instructions-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const requests = [];
+  const server = createServer(async (request, response) => {
+    if (request.url.includes("count_tokens")) {
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify({ input_tokens: 20 }));
+      return;
+    }
+    if (!request.url.startsWith("/v1/messages")) { response.writeHead(404); response.end(); return; }
+    let input = "";
+    for await (const chunk of request) input += chunk;
+    const body = JSON.parse(input);
+    requests.push(body);
+    const message = { id: "msg_local", type: "message", role: "assistant", model: body.model,
+      content: [{ type: "text", text: "ACK" }], stop_reason: "end_turn", stop_sequence: null,
+      usage: { input_tokens: 20, output_tokens: 1 } };
+    if (!body.stream) {
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify(message));
+      return;
+    }
+    response.writeHead(200, { "content-type": "text/event-stream" });
+    const event = (type, data) => response.write(`event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`);
+    event("message_start", { message: { ...message, content: [], stop_reason: null, usage: { input_tokens: 20, output_tokens: 0 } } });
+    event("content_block_start", { index: 0, content_block: { type: "text", text: "" } });
+    event("content_block_delta", { index: 0, delta: { type: "text_delta", text: "ACK" } });
+    event("content_block_stop", { index: 0 });
+    event("message_delta", { delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: 1 } });
+    event("message_stop", {});
+    response.end();
+  });
+  await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
+  t.after(() => new Promise(resolve => { server.close(resolve); server.closeAllConnections(); }));
+  const env = {
+    PATH: process.env.PATH, HOME: root, CLAUDE_CONFIG_DIR: path.join(root, "config"),
+    ANTHROPIC_BASE_URL: `http://127.0.0.1:${server.address().port}`,
+    ANTHROPIC_AUTH_TOKEN: "local-test", ANTHROPIC_MODEL: "fixture-model",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "fixture-model", CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+    CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1", DISABLE_AUTOUPDATER: "1"
+  };
+  const runtime = createClaudeConversationTurn({ conversationId: "instruction-arguments", process: { getProcess: () => null,
+    isActive: () => false, startProcess: () => {}, stopProcess: () => {} } });
+  async function turn(id, instructions, text, resume) {
+    const { stdout } = await execute("claude", ["--bare", "--print", "--output-format", "json", "--model", "fixture-model",
+      "--tools", "", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
+      resume ? "--resume" : "--session-id", id, ...instructions, "--", text], { cwd: root, env, timeout: 25_000 });
+    const result = JSON.parse(stdout);
+    assert.equal(result.is_error, false);
+    assert.equal(result.session_id, id);
+    return requests.at(-1);
+  }
+  for (const instructionMode of ["append", "replace"]) {
+    const id = randomUUID();
+    await turn(id, [instructionMode === "append" ? "--append-system-prompt" : "--system-prompt",
+      "CALENDAR_INSTRUCTIONS_A", "--system-prompt-snapshot", "on"], "First request", false);
+    const current = runtime.instructionArguments({ systemPrompt: "CALENDAR_INSTRUCTIONS_B", instructionMode });
+    const resumed = await turn(id, current, "Second request", true);
+    assert.match(JSON.stringify(resumed.system), /CALENDAR_INSTRUCTIONS_B/);
+    assert.doesNotMatch(JSON.stringify(resumed.system), /CALENDAR_INSTRUCTIONS_A/);
+    const followup = await turn(id, current, "Third request", true);
+    assert.equal(followup.messages.filter(message => message.role === "user").length, 3);
+    assert.match(JSON.stringify(followup.messages.at(-1)), /Third request/);
+    assert.doesNotMatch(JSON.stringify(followup.messages), /CALENDAR_INSTRUCTIONS_[AB]/);
+  }
+});

package/test/claudeProcess.test.js

@@ -0,0 +1,204 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os, { tmpdir } from "node:os";
+import path, { join } from "node:path";
+import { test } from "node:test";
+import { claudePlanUsage, claudeCodeArguments, claudeModelConfiguration, createClaudeCodeProcess, readClaudeCodeAuthStatus, stopClaudeCodeProcess } from "../src/server/conversation/claudeProcess.js";
+
+test("native command construction preserves tool-free constraints without granting permissions by default", () => {
+  const args = claudeCodeArguments({ sessionId: "session", resume: true, model: "sonnet", effort: "high", toolFree: true });
+  assert.equal(args[args.indexOf("--resume") + 1], "session");
+  assert.equal(args[args.indexOf("--tools") + 1], "");
+  assert.equal(args[args.indexOf("--thinking-display") + 1], "summarized");
+  assert.equal(args.includes("bypassPermissions"), false);
+  assert.equal(claudeCodeArguments().includes("--permission-mode"), false);
+  assert.equal(claudeCodeArguments({ terminal: true }).includes("--print"), false);
+  const tools = claudeCodeArguments({ toolFree: true, applicationTools: true });
+  assert.equal(tools[tools.indexOf("--tools") + 1], "");
+  assert.equal(tools[tools.indexOf("--permission-mode") + 1], "dontAsk");
+  assert.equal(tools[tools.indexOf("--allowedTools") + 1], "mcp__application__*");
+  assert.equal(tools.includes("--safe-mode"), true);
+  assert.equal(tools.includes("--restricted"), true);
+  assert.deepEqual(JSON.parse(tools[tools.indexOf("--mcp-config") + 1]), { mcpServers: { application: { type: "sdk", name: "application" } } });
+  const coding = claudeCodeArguments({ isolated: true, applicationTools: true, permissionMode: "bypassPermissions" });
+  assert.equal(coding.includes("--restricted"), false);
+  assert.equal(coding[coding.indexOf("--permission-mode") + 1], "bypassPermissions");
+  assert.match(coding[coding.indexOf("--tools") + 1], /Bash,Read,Edit,Write/);
+  assert.equal(coding.includes("--safe-mode"), true);
+  assert.deepEqual(JSON.parse(coding[coding.indexOf("--mcp-config") + 1]), { mcpServers: { application: { type: "sdk", name: "application" } } });
+});
+
+async function fixture(t, body) {
+  const directory = await mkdtemp(join(tmpdir(), "jskit-claude-process-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const command = join(directory, "claude-fixture.mjs");
+  await writeFile(command, `#!${process.execPath}\n${body}`, { mode: 0o700 });
+  return { command, workdir: directory };
+}
+
+test("standalone Claude startup uses the supplied execution host and carries its native protocol", { skip: process.platform === "win32" }, async (t) => {
+  const setup = await fixture(t, `
+    import { createInterface } from "node:readline";
+    createInterface({ input: process.stdin }).on("line", line => {
+      const frame = JSON.parse(line);
+      process.stdout.write(JSON.stringify(frame.type === "control_request"
+        ? { type: "control_response", response: { subtype: "success", request_id: frame.request_id,
+            response: { models: [{ value: "fixture" }], parentContext: process.env.CLAUDECODE || "",
+              automaticUpdates: process.env.DISABLE_AUTOUPDATER } } }
+        : frame) + "\\n");
+    });
+  `);
+  const observed = Promise.withResolvers();
+  const native = await createClaudeCodeProcess({ ...setup, env: { ...process.env, CLAUDECODE: "parent-context" },
+    onEvent: (frame) => observed.resolve(frame) });
+  t.after(() => native.stop());
+  assert.equal(native.initialization.models[0].value, "fixture");
+  assert.equal(native.initialization.parentContext, "");
+  assert.equal(native.initialization.automaticUpdates, "1");
+  await native.client.send("Unicode 🌏", { messageId: "request", sessionId: "conversation" });
+  const event = await observed.promise;
+  assert.equal(event.message.content, "Unicode 🌏");
+  assert.equal(event.uuid, "request");
+  assert.equal(event.session_id, "conversation");
+  assert.deepEqual(await native.stop(), { scopeEmpty: true, exited: true });
+  assert.deepEqual(await native.stop(), { scopeEmpty: true, exited: true });
+});
+
+test("failed native initialization stops its owned process and reports the protocol failure", { skip: process.platform === "win32" }, async (t) => {
+  const setup = await fixture(t, 'process.stdin.once("data", () => process.stdout.write("invalid frame\\n"));');
+  await assert.rejects(createClaudeCodeProcess(setup), /invalid UTF-8 or JSON/);
+});
+
+test("Claude stop uses the retained process before recovery and accepts the original host exit proofs", async () => {
+  const recovered = [];
+  const stopExecution = async (...args) => { recovered.push(args); return { scopeEmpty: true }; };
+  assert.deepEqual(await stopClaudeCodeProcess({ process: { stop: async () => ({ exited: true }) },
+    executionId: "retained", stopExecution }), { exited: true });
+  assert.deepEqual(recovered, []);
+  assert.deepEqual(await stopClaudeCodeProcess({ executionId: "recovered", stopExecution }),
+    { scopeEmpty: true, exited: true });
+  assert.deepEqual(recovered, [["recovered", { allowMissingRecordScopeRecovery: true, reason: "claude-code-stop" }]]);
+});
+
+test("Claude stop keeps unconfirmed cleanup retryable and preserves host failures", async () => {
+  let stopped = false;
+  const input = { executionId: "recovered", stopExecution: async () => ({ scopeEmpty: stopped }) };
+  await assert.rejects(stopClaudeCodeProcess(input), {
+    code: "claude_stop_unconfirmed", stopProof: { scopeEmpty: false }
+  });
+  stopped = true;
+  assert.deepEqual(await stopClaudeCodeProcess(input), { scopeEmpty: true, exited: true });
+  const failure = new Error("Execution host unavailable");
+  await assert.rejects(stopClaudeCodeProcess({ ...input, stopExecution: async () => { throw failure; } }), failure);
+});
+
+test("Claude model configuration maps background calls and resets external settings", () => {
+  for (const [provider, model, window] of [["deepseek", "deepseek-flash", "786432"], ["zai-coding-plan", "glm-5.3", "1000000"]]) {
+    const configured = claudeModelConfiguration({ providerId: provider, model: model }, { apiKey: "test-secret", baseUrl: "https://provider.test" });
+    assert.equal(configured.model, `${model}[1m]`);
+    assert.equal(configured.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW, window);
+    for (const name of ["ANTHROPIC_DEFAULT_OPUS_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_FABLE_MODEL"]) {
+      assert.equal(configured.env[name], `${model}[1m]`);
+    }
+    const native = claudeModelConfiguration({ providerId: "anthropic", model: "opus" }, null);
+    for (const name of Object.keys(configured.env)) {
+      if (!["ANTHROPIC_BASE_URL", "CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST"].includes(name)) assert.equal(native.env[name], "", name);
+    }
+    assert.equal(native.model, "opus");
+  }
+});
+
+test("Claude status reads native JSON and returns only public account details", async () => {
+  const status = await readClaudeCodeAuthStatus({ credentialHome: { home: "/home/fixture" }, commandRunner: async (input) => {
+    assert.deepEqual(input.args, ["auth", "status", "--json"]);
+    assert.equal(input.timeout, 30_000);
+    assert.equal(input.credentialHome.home, "/home/fixture");
+    return { ok: true, stdout: JSON.stringify({ loggedIn: true, email: "owner@example.test", authMethod: "claude.ai", subscriptionType: "max", accessToken: "not-public" }) };
+  } });
+  assert.equal(status.loggedIn, true);
+  assert.equal(status.email, "owner@example.test");
+  assert.equal(JSON.stringify(status).includes("not-public"), false);
+});
+
+test("Claude signed-out JSON is normal while failed and malformed status responses stay errors", async () => {
+  const readStatus = (result) => readClaudeCodeAuthStatus({
+    credentialHome: { home: "/home/fixture" }, commandRunner: async () => result
+  });
+  const signedOut = { ok: false, exitCode: 1, stdout: JSON.stringify({ loggedIn: false, authMethod: "none" }) };
+  assert.deepEqual(await readStatus(signedOut), {
+    loggedIn: false, email: "", authMethod: "none", subscriptionType: ""
+  });
+  for (const result of [
+    { ...signedOut, timedOut: true },
+    { ...signedOut, signal: "SIGTERM" },
+    { ...signedOut, exitCode: 2 },
+    { ...signedOut, stdout: JSON.stringify({ loggedIn: true, email: "owner@example.test" }) },
+    { ...signedOut, stdout: "invalid" },
+    { ok: true, stdout: "{}" },
+    { ok: true, stdout: "null" }
+  ]) {
+    const status = await readStatus(result);
+    assert.equal(status.loggedIn, false);
+    assert.ok(status.error);
+  }
+});
+
+test("Claude status shares concurrent reads and invalidates when native account files change", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "claude-auth-status-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const configRoot = path.join(home, ".claude");
+  await mkdir(configRoot);
+  let calls = 0;
+  let email = "first@example.test";
+  const input = { env: { CLAUDE_CONFIG_DIR: configRoot }, credentialHome: { home }, commandRunner: async () => {
+    calls += 1;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    return { ok: true, stdout: JSON.stringify({ loggedIn: true, email, authMethod: "claude.ai" }) };
+  } };
+  const statuses = await Promise.all(Array.from({ length: 8 }, () => readClaudeCodeAuthStatus(input)));
+  assert.equal(calls, 1);
+  assert.ok(statuses.every((status) => status.email === email));
+  if (process.platform !== "darwin") {
+    await readClaudeCodeAuthStatus(input);
+    assert.equal(calls, 1);
+  }
+  for (const file of [path.join(configRoot, ".credentials.json"), path.join(home, ".claude.json"), path.join(configRoot, ".claude.json")]) {
+    email = `${calls}@example.test`;
+    // Deliberately not JSON: the wrapper must never parse native credentials.
+    await writeFile(file, "native-account-changed");
+    assert.equal((await readClaudeCodeAuthStatus(input)).email, email);
+    await rm(file);
+    const before = calls;
+    await readClaudeCodeAuthStatus(input);
+    assert.equal(calls, before + 1);
+  }
+});
+
+test("Claude status failures do not poison later reads or share across credential homes", async () => {
+  let calls = 0;
+  const commandRunner = async () => {
+    calls += 1;
+    return calls === 1 ? { ok: false, error: "Temporary failure" }
+      : { ok: true, stdout: JSON.stringify({ loggedIn: false }) };
+  };
+  const input = { env: {}, credentialHome: { home: "/home/fixture" }, commandRunner };
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Temporary failure");
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, undefined);
+  assert.equal(calls, 2);
+  await readClaudeCodeAuthStatus({ ...input, credentialHome: { home: "/home/another" } });
+  assert.equal(calls, 3);
+});
+
+test("Claude plan usage retains real windows and never invents an allowance after reset", () => {
+  assert.deepEqual(claudePlanUsage({ rate_limits_available: false }).windows, []);
+  const usage = claudePlanUsage({ rate_limits_available: true, rate_limits: {
+    five_hour: { utilization: 25, resets_at: "2099-01-01T00:00:00Z" },
+    seven_day: { utilization: 100, resets_at: null },
+    seven_day_sonnet: { utilization: 10, resets_at: "2000-01-01T00:00:00Z" },
+    seven_day_opus: { utilization: null, resets_at: null }
+  } });
+  assert.equal(usage.status, "available");
+  assert.deepEqual(usage.windows.map(({ id, remainingPercent }) => ({ id, remainingPercent })), [
+    { id: "five_hour", remainingPercent: 75 }, { id: "seven_day", remainingPercent: 0 }
+  ]);
+});

package/test/claudeTurn.test.js

@@ -0,0 +1,253 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createClaudeConversationTurn, claudeNativeMessageId, runClaudeRenewalTurn,
+  waitForClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
+
+function fixture() {
+  const events = [];
+  const turn = createClaudeConversationTurn({ conversationId: "native-session", onEvent: async event => events.push(event) });
+  const client = { async send(_message, { messageId }) {
+    await turn.receive({ type: "user", uuid: messageId, session_id: "native-session" });
+  }, async interrupt() {} };
+  const send = (id = "first", options = {}) => turn.send(client, "Hello", {
+    messageId: claudeNativeMessageId(id), accept: async () => {}, ...options
+  });
+  turn.begin({ id: "turn-1" });
+  return { turn, events, client, send };
+}
+
+test("a pipe write is not admission; queued and replayed acknowledgements persist the user exactly once", async () => {
+  const { turn, client, send, events } = fixture();
+  client.send = async () => {};
+  let saved = 0;
+  let delivered = false;
+  const sending = send("first", { accept: async () => { saved += 1; } }).then(() => { delivered = true; });
+  await turn.receive({ type: "user", uuid: "tool-result" });
+  await Promise.resolve();
+  assert.equal(delivered, false);
+  const uuid = claudeNativeMessageId("first");
+  await turn.receive({ type: "command_lifecycle", command_uuid: uuid, state: "queued" });
+  await sending;
+  await turn.receive({ type: "user", uuid });
+  assert.equal(saved, 1);
+  assert.equal(events.filter(event => event.type === "admitted").length, 2);
+  turn.stop();
+});
+
+test("steering waits for the generation's terminal event after the control acknowledgement", async () => {
+  const { turn, send, client, events } = fixture();
+  await send();
+  let interrupted = false;
+  const steering = turn.interruptGeneration(client).then(() => { interrupted = true; });
+  await Promise.resolve();
+  assert.equal(interrupted, false);
+  await turn.receive({ type: "result", subtype: "success", terminal_reason: "aborted_streaming", result: "" });
+  await steering;
+  assert.equal(events.some(event => event.type === "settled"), false);
+  await send("follow-up");
+  await turn.receive({ type: "result", subtype: "success", result: "Revised answer" });
+  assert.equal(turn.read().text, "Revised answer");
+  assert.equal(turn.read().status, "completed");
+});
+
+test("interruption does not claim process exit or complete work on a control acknowledgement", async () => {
+  const { turn, send, client, events } = fixture();
+  await send();
+  await turn.receive({ type: "system", subtype: "status", status: "compacting" });
+  await turn.interrupt(client);
+  await turn.receive({ type: "result", subtype: "success", terminal_reason: "aborted_tools", result: "" });
+  assert.equal(turn.read().active, true);
+  assert.equal(events.some(event => event.type === "settled"), false);
+  turn.stop("Owned process scope drained.");
+  assert.equal(turn.read().active, false);
+  assert.equal(turn.read().phase, "");
+  assert.equal(turn.read().status, "interrupted");
+  turn.begin({ id: "next" });
+  await send("next");
+  await turn.receive({ type: "result", subtype: "success", result: "Resumed" });
+  assert.equal(turn.read().text, "Resumed");
+});
+
+test("lost acknowledgement stays uncertain and stop rejects pending admission", async () => {
+  const { turn, client, send } = fixture();
+  client.send = async () => {};
+  await assert.rejects(send("timeout", { timeoutMs: 5 }), error => error.delivery === "uncertain");
+  const pending = send("stopped");
+  turn.stop("Connection lost.");
+  await assert.rejects(pending, /Connection lost/);
+  assert.equal(turn.read().pendingCommands, 0);
+  await turn.receive({ type: "result", subtype: "success", result: "Late reply" });
+  assert.equal(turn.read().text, "");
+});
+
+test("native session identity and helper output bounds are enforced without truncating answers", async () => {
+  const { turn, send } = fixture();
+  await assert.rejects(turn.receive({ type: "user", session_id: "another-session" }), /different conversation id/);
+  turn.stop();
+  turn.begin({ id: "bounded", maxOutputCharacters: 5 });
+  await send();
+  await turn.receive({ type: "assistant", uuid: "reasoning", message: { content: [{ type: "thinking", thinking: "Longer reasoning summary" }] } });
+  await assert.rejects(turn.receive({ type: "assistant", uuid: "answer", message: { content: [{ type: "text", text: "Too long" }] } }), /size limit/);
+  await assert.rejects(turn.receive({ type: "result", subtype: "success", structured_output: { text: "Too long" } }), /size limit/);
+  turn.stop();
+});
+
+function renewalFixture() {
+  const input = { clientMessageId: "renewal-operation", prompt: "Approved prompt", timeoutMs: 100 };
+  const uuid = claudeNativeMessageId(input.clientMessageId);
+  const events = [];
+  const history = { userIds: [], messages: [] };
+  const state = { id: "exact-native-conversation", lastMessageId: "", turn: null, process: null };
+  const conversation = {
+    state,
+    async readHistory() { events.push("history"); return history; },
+    async send(value, options) {
+      events.push(["send", value, options]);
+      state.lastMessageId = uuid;
+      state.turn = { id: uuid, active: true };
+    },
+    async wait(value) { events.push(["wait", value]); return { status: "completed", text: "Finished", threadId: state.id, turnId: uuid }; },
+    async stop(reason) { events.push(["stop", reason]); return { exited: true }; }
+  };
+  return { input, uuid, events, history, state, conversation };
+}
+
+test("renewal recovers the exact accepted native answer without another dispatch and closes before returning", async () => {
+  const f = renewalFixture();
+  f.history.userIds.push(f.uuid);
+  f.history.messages.push({ userId: "other", role: "assistant", text: "Unrelated" },
+    { userId: f.uuid, role: "thinking", text: "Private reasoning" },
+    { userId: f.uuid, role: "assistant", text: "First" }, { userId: f.uuid, role: "assistant", text: "Second" });
+  const result = await runClaudeRenewalTurn(f.conversation, f.input);
+  assert.deepEqual(result, { text: "First\nSecond", threadId: f.state.id, turnId: f.uuid, reconciled: true,
+    clientMessageId: f.input.clientMessageId, freshThread: false, processExitProof: { exited: true } });
+  assert.deepEqual(f.events, ["history", ["stop", undefined]]);
+});
+
+test("renewal refuses changed or unrelated successor history before native work and never resends unreadable accepted input", async () => {
+  const f = renewalFixture();
+  await assert.rejects(runClaudeRenewalTurn(f.conversation, { ...f.input, expectedThreadId: "different" }), /expected native history/);
+  await assert.rejects(runClaudeRenewalTurn(f.conversation, { ...f.input, requireFreshHistory: true,
+    forbiddenThreadId: f.state.id }), /expected native history/);
+  assert.deepEqual(f.events, []);
+  f.history.userIds.push("unrelated");
+  await assert.rejects(runClaudeRenewalTurn(f.conversation, { ...f.input, requireFreshHistory: true }), /unrelated messages/);
+  assert.deepEqual(f.events, ["history"]);
+  f.history.userIds.splice(0, 1, f.uuid);
+  await assert.rejects(runClaudeRenewalTurn(f.conversation, f.input), error => {
+    assert.equal(error.code, "assistant_claude_turn_unreadable");
+    assert.deepEqual(error.details, { clientMessageId: f.input.clientMessageId, inputAccepted: true,
+      threadId: f.state.id, turnId: f.uuid });
+    return true;
+  });
+  assert.equal(f.events.some(event => event[0] === "send"), false);
+  assert.match(f.events.at(-1)[1], /will not be submitted again/);
+});
+
+test("renewal dispatches once with the original schema and waits before confirmed cleanup", async () => {
+  const f = renewalFixture();
+  const outputSchema = { type: "object" };
+  const result = await runClaudeRenewalTurn(f.conversation, { ...f.input, outputSchema, requireFreshHistory: true });
+  assert.equal(result.freshThread, true);
+  assert.deepEqual(f.events, ["history", ["send", { message: f.input.prompt,
+    messageId: f.input.clientMessageId, outputSchema }, { renewal: true }],
+  ["wait", { conversationId: f.state.id, timeoutMs: 100 }], ["stop", undefined]]);
+  assert.deepEqual(result.processExitProof, { exited: true });
+});
+
+test("renewal preserves acceptance evidence and retries cleanup when the successful turn's close fails", async () => {
+  const f = renewalFixture();
+  const problem = Object.assign(new Error("Exit proof unavailable"), { details: { retained: true } });
+  let stops = 0;
+  f.conversation.stop = async reason => {
+    f.events.push(["stop", reason]);
+    if (++stops === 1) throw problem;
+    return { exited: true };
+  };
+  await assert.rejects(runClaudeRenewalTurn(f.conversation, f.input, { acceptedField: "handoverPromptAccepted" }), error => {
+    assert.equal(error, problem);
+    assert.deepEqual(error.details, { retained: true, clientMessageId: f.input.clientMessageId,
+      handoverPromptAccepted: true, threadId: f.state.id, turnId: f.uuid });
+    return true;
+  });
+  assert.equal(f.events.filter(event => event[0] === "send").length, 1);
+  assert.deepEqual(f.events.slice(-2), [["stop", undefined], ["stop", problem.message]]);
+});
+
+test("wait cleans up a restored execution before reading saved output and keeps the existing completion on success", async () => {
+  const events = [];
+  const state = { executionId: "owned-process", process: null, turn: { active: false } };
+  const saved = { text: "Saved output", status: "completed" };
+  const conversation = { state,
+    async stop(reason) { events.push(["stop", reason]); },
+    async read(input) { events.push(["read", input]); return saved; },
+    async interrupt() { events.push("interrupt"); }
+  };
+  const input = { messageId: "accepted" };
+  assert.equal(await waitForClaudeConversationTurn(conversation, input), saved);
+  assert.deepEqual(events, [["stop", "Claude was interrupted when the application disconnected."], ["read", input]]);
+  state.process = {};
+  state.turn.active = true;
+  state.completion = Promise.withResolvers();
+  const controller = new AbortController();
+  const waiting = waitForClaudeConversationTurn(conversation, {}, { signal: controller.signal, defaultTimeoutMs: Infinity });
+  state.completion.resolve(saved);
+  assert.equal(await waiting, saved);
+  controller.abort();
+  assert.equal(events.includes("interrupt"), false, "Completed waits remove their abort listener");
+});
+
+test("wait interrupts on its bounded timeout or caller abort without replacing the conversation completion", async () => {
+  let interrupts = 0;
+  const state = { process: {}, turn: { active: true }, completion: Promise.withResolvers() };
+  const conversation = { state, async interrupt() { interrupts++; } };
+  await assert.rejects(waitForClaudeConversationTurn(conversation, { timeoutMs: 10_000 }, { maximumTimeoutMs: 5 }), /within the time limit/);
+  assert.equal(interrupts, 1);
+  const controller = new AbortController();
+  conversation.interrupt = async () => { interrupts++; state.completion.resolve({ status: "interrupted" }); };
+  const waiting = waitForClaudeConversationTurn(conversation, {}, { signal: controller.signal, defaultTimeoutMs: Infinity });
+  controller.abort();
+  assert.deepEqual(await waiting, { status: "interrupted" });
+  assert.equal(interrupts, 2);
+});
+
+test("Claude split completions carry the exact live output identity before native block retirement", async () => {
+  const { turn, events, send } = fixture();
+  await send();
+  await turn.receive({ type: "stream_event", event: { type: "message_start", message: { id: "same-api-message" } } });
+  for (const [index, block] of [
+    { type: "thinking", thinking: "The reasoning." }, { type: "text", text: "The answer." }
+  ].entries()) {
+    await turn.receive({ type: "stream_event", event: { type: "content_block_start", index, content_block: { type: block.type } } });
+    await turn.receive({ type: "stream_event", event: { type: "content_block_delta", index,
+      delta: block.type === "thinking" ? { thinking: block.thinking } : { text: block.text } } });
+    // Claude's documented wire order completes the split frame before its stop.
+    await turn.receive({ type: "assistant", uuid: `saved-block-${index}`, message: { id: "same-api-message", content: [block] } });
+    const complete = events.filter(event => event.type === "message" && event.message.complete).at(-1).message;
+    assert.equal(complete.id, `claude_saved-block-${index}_0`, "Native history keeps its frame UUID and local index");
+    assert.equal(complete.outputId, `claude_same-api-message_${index}`, "The existing live map supplies the global block index");
+    await turn.receive({ type: "stream_event", event: { type: "content_block_stop", index } });
+    assert.equal(events.at(-1).messageId, complete.outputId);
+  }
+  assert.deepEqual(turn.read().messages.map(message => message.id), ["claude_saved-block-0_0", "claude_saved-block-1_0"]);
+  assert.deepEqual(turn.read().messages.map(message => message.outputId), ["claude_same-api-message_0", "claude_same-api-message_1"]);
+});
+
+test("Claude output identity is absent without unique live proof or with a conflicting explicit index", async () => {
+  for (const mode of ["retired", "ambiguous", "foreign", "missing-id", "wrong-index", "invalid-index", "explicit-index"]) {
+    const { turn, events } = fixture();
+    const receive = event => turn.receive({ type: "stream_event", event });
+    await receive({ type: "message_start", message: { id: mode === "missing-id" ? undefined : "native" } });
+    await receive({ type: "content_block_start", index: 3, content_block: { type: "text", text: "Partial" } });
+    if (mode === "retired") await receive({ type: "content_block_stop", index: 3 });
+    if (mode === "ambiguous") await receive({ type: "content_block_start", index: 4, content_block: { type: "text", text: "Another" } });
+    await turn.receive({ type: "assistant", uuid: "saved", message: {
+      id: mode === "missing-id" ? undefined : mode === "foreign" ? "other" : "native", content: [{ type: "text", text: "Complete" }]
+    }, ...(mode === "wrong-index" ? { apiBlockIndex: 4 } : mode === "invalid-index" ? { apiBlockIndex: "3" }
+      : mode === "explicit-index" ? { apiBlockIndex: 3 } : {}) });
+    const message = events.filter(event => event.type === "message").at(-1).message;
+    assert.equal(message.id, "claude_saved_0");
+    if (mode === "explicit-index") assert.equal(message.outputId, "claude_native_3");
+    else assert.equal(Object.hasOwn(message, "outputId"), false, mode);
+  }
+});