@jskit-ai/assistant-core 0.1.226 → 0.1.227

package/test/claudeTurn.test.js

@@ -1,8 +1,11 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { Duplex } from "node:stream";
+import { createClaudeJsonClient } from "../src/server/conversation/claudeClient.js";
 import { setTimeout as delay } from "node:timers/promises";
 import { createClaudeConversationTurn, claudeNativeMessageId, runClaudeRenewalTurn,
   waitForClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
+import { readClaudeHistory } from "../src/server/conversation/claudeHistory.js";
 
 function fixture() {
   const events = [];
@@ -17,6 +20,131 @@ function fixture() {
   return { turn, events, client, send };
 }
 
+test("native local command output retains protocol provenance through transcript storage", async () => {
+  const { createConversationTranscript, createMemoryConversationStorage } = await import("../src/server/conversation/index.js");
+  const { turn, send, events } = fixture();
+  await send();
+  await turn.receive({ type: "system", subtype: "local_command_output", uuid: "goal-confirmation", content: "Goal cleared: Finish checks" });
+  const message = events.find(event => event.type === "message").message;
+  assert.deepEqual(message.data, { native: { engineId: "claude", type: "system", subtype: "local_command_output" } });
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await transcript.writeConversationUserMessage("test", { messageId: "user", text: "/goal clear" });
+  await transcript.writeConversationCommentaryMessage("test", { ...message, messageId: message.id });
+  const [saved] = await transcript.readConversationLog("test");
+  assert.deepEqual(saved.commentary[0].data, message.data);
+  message.data.native.subtype = "changed";
+  assert.equal((await transcript.readConversationLog("test"))[0].commentary[0].data.native.subtype, "local_command_output");
+  turn.stop();
+});
+
+test("actual Claude synthetic goal confirmations retain command provenance without relabelling ordinary replies", async () => {
+  const { turn, send, events } = fixture();
+  await send();
+  // Captured from Claude 2.1.289's stream-json /goal clear operation. Native
+  // history stores system/local_command, but the live protocol uses assistant.
+  await turn.receive({ type: "assistant", uuid: "clear-confirmation", local_command_run: { command: "goal", args: "clear" },
+    local_command_source: "<local-command-stdout>No goal set</local-command-stdout>",
+    message: { id: "synthetic-command", model: "<synthetic>", stop_reason: "end_turn", content: [{ type: "text", text: "No goal set" }] } });
+  await turn.receive({ type: "result", subtype: "success", local_command: "goal", result: "No goal set" });
+  const output = events.filter(event => event.type === "message" && event.message.complete);
+  assert.equal(output.length, 1, "The result does not duplicate its synthetic assistant carrier");
+  assert.deepEqual(output[0].message.data, { native: { engineId: "claude", type: "assistant", command: "goal", output: "stdout" } });
+  const transcript = createConversationTranscript({ storage: createMemoryConversationStorage() });
+  await transcript.writeConversationUserMessage("test", { messageId: "clear", text: "/goal clear" });
+  await transcript.writeConversationAssistantMessage("test", { ...output[0].message, messageId: output[0].message.id });
+  assert.deepEqual((await transcript.readConversationLog("test"))[0].assistant.data, output[0].message.data);
+  turn.begin({ id: "ordinary" });
+  await send("ordinary");
+  await turn.receive({ type: "assistant", uuid: "ordinary-answer", message: { id: "ordinary-api", model: "haiku", stop_reason: "end_turn",
+    content: [{ type: "text", text: "Goal set: I will work through the checks." }] } });
+  assert.equal(events.findLast(event => event.type === "message").message.data, undefined);
+  turn.stop();
+});
+
+test("Claude native no-response placeholders are excluded from live and cold replies without hiding errors or model answers", async t => {
+  const { turn, send, events } = fixture();
+  t.after(() => turn.stop());
+  await send();
+  // SAS26: native 2.1.289 appends this placeholder after a stopped request
+  // when changing models. Its own lI classifier uses this exact provenance.
+  const placeholder = { type: "assistant", uuid: "b53b36f5-0eca-4fea-9e70-5b8f67353256", isApiErrorMessage: false,
+    message: { id: "79b0fcfc-0510-4fd7-8f41-7623dba7697a", model: "<synthetic>", stop_reason: "stop_sequence",
+      usage: { input_tokens: 0, output_tokens: 0 }, content: [{ type: "text", text: "No response requested." }] } };
+  const frames = [placeholder,
+    { ...placeholder, uuid: "real-answer", message: { ...placeholder.message, id: "real-api", model: "claude-haiku-4-5-20251001" } },
+    { ...placeholder, uuid: "api-error", isApiErrorMessage: true, message: { ...placeholder.message, id: "error-api" } },
+    { ...placeholder, uuid: "other-synthetic", message: { ...placeholder.message, id: "other-api", content: [{ type: "text", text: "Different native notice" }] } }
+  ];
+  for (const frame of frames) await turn.receive(frame);
+  const expected = ["claude_real-answer_0", "claude_api-error_0", "claude_other-synthetic_0"];
+  assert.deepEqual(events.filter(event => event.type === "message").map(event => event.message.id), expected);
+  const root = await mkdtemp(path.join(os.tmpdir(), "claude-placeholder-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const directory = path.join(root, "projects", root.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  const conversationId = "669021a9-a56e-48e8-b752-44e6accb1300";
+  await writeFile(path.join(directory, `${conversationId}.jsonl`), [
+    { type: "user", uuid: "original-request", message: { content: "Original request" } }, ...frames
+  ].map(JSON.stringify).join("\n") + "\n");
+  const history = await readClaudeHistory({ configRoot: root, workdir: root, conversationId });
+  assert.deepEqual(history.messages.map(message => message.id), expected);
+  assert.ok(history.messages.every(message => message.userId === "original-request"));
+  assert.deepEqual(history.userIds, ["original-request"]);
+});
+
+test("Claude successful native clear removes a failed goal without a clearing sentinel", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "claude-clear-goal-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const directory = path.join(root, "projects", root.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  const conversationId = "cde87511-7341-4f9e-9d8a-6fe849a953a5";
+  const file = path.join(directory, `${conversationId}.jsonl`);
+  const failed = { type: "attachment", uuid: "failed", timestamp: "2026-10-16T18:08:11.407Z",
+    attachment: { type: "goal_status", condition: "Finish checks", met: false, failed: true } };
+  // Actual Claude 2.1.289 history after Cancel on an impossible goal. It emits
+  // no goal_status sentinel because its native checker already removed the goal.
+  const cleared = { type: "system", subtype: "local_command", uuid: "cleared",
+    timestamp: "2026-10-16T18:09:31.206Z", commandRun: { command: "goal", args: "clear" },
+    content: "<local-command-stdout>No goal set</local-command-stdout>" };
+  const frames = [failed,
+    { ...cleared, type: "assistant", uuid: "quoted", message: { content: "No goal set" } },
+    { ...cleared, uuid: "nested", parent_tool_use_id: "child" },
+    { ...cleared, uuid: "sidechain", isSidechain: true },
+    { ...cleared, uuid: "meta", isMeta: true },
+    { ...cleared, uuid: "other-command", commandRun: { command: "help", args: "clear" } },
+    { ...cleared, uuid: "status-only", commandRun: { command: "goal", args: "" } },
+    { ...cleared, uuid: "error", content: "<local-command-stderr>No goal set</local-command-stderr>" }
+  ];
+  await writeFile(file, frames.map(JSON.stringify).join("\n") + "\n");
+  const options = { configRoot: root, workdir: root, conversationId };
+  assert.equal((await readClaudeHistory(options)).goal.status, "blocked", "quotes, nested commands and failures cannot clear the goal");
+  await writeFile(file, JSON.stringify(cleared) + "\n", { flag: "a" });
+  const original = await readFile(file, "utf8");
+  assert.equal((await readClaudeHistory(options)).goal, null);
+  assert.equal((await readClaudeHistory(options)).goal, null, "a fresh read cannot resurrect the failed goal");
+  assert.equal(await readFile(file, "utf8"), original, "projection does not mutate native history");
+  await writeFile(file, JSON.stringify({ ...failed, uuid: "next", timestamp: "2026-10-16T18:10:00.000Z",
+    attachment: { type: "goal_status", condition: "Next checks", met: false, sentinel: true } }) + "\n", { flag: "a" });
+  assert.equal((await readClaudeHistory(options)).goal.objective, "Next checks", "a later goal still wins");
+});
+
+test("Claude local-command error output stays distinguishable and result-only success retains provenance", async () => {
+  const { turn, send, events } = fixture();
+  await send();
+  await turn.receive({ type: "assistant", uuid: "command-error", local_command_run: { command: "goal", args: "invalid" },
+    local_command_source: "<local-command-stderr>Goal cannot be changed</local-command-stderr>",
+    message: { id: "error-command", stop_reason: "end_turn", content: [{ type: "text", text: "Goal cannot be changed" }] } });
+  assert.deepEqual(events.find(event => event.type === "message").message.data,
+    { native: { engineId: "claude", type: "assistant", command: "goal", output: "stderr" } });
+  turn.stop();
+  turn.begin({ id: "result-only" });
+  await send("result-only");
+  await turn.receive({ type: "result", subtype: "success", local_command: "goal", result: "Goal cleared: Previous objective" });
+  assert.deepEqual(events.findLast(event => event.type === "message").message.data,
+    { native: { engineId: "claude", type: "result", command: "goal", output: "stdout" } });
+});
+
 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 () => {};
@@ -51,6 +179,193 @@ test("steering waits for the generation's terminal event after the control ackno
   assert.equal(turn.read().status, "completed");
 });
 
+test("interrupted Claude output keeps its input identity after a follow-up is accepted", async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.owner.send(f.entry, { messageId: "first", message: "First request" });
+  const native = f.processes.at(-1);
+  await native.options.onEvent({ type: "stream_event", event: { type: "message_start", message: { id: "first-api" } } });
+  await native.options.onEvent({ type: "stream_event", event: { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } } });
+  await native.options.onEvent({ type: "stream_event", event: { type: "content_block_delta", index: 0, delta: { text: "FIRST-PARTIAL" } } });
+  await native.options.onEvent({ type: "assistant", uuid: "first-output", message: { id: "first-api", content: [{ type: "text", text: "FIRST-PARTIAL" }] } });
+  await f.owner.send(f.entry, { messageId: "second", message: "Second request" });
+  await native.options.onEvent({ type: "assistant", uuid: "second-output", message: { id: "second-api", content: [{ type: "text", text: "SECOND-OK" }], stop_reason: "end_turn" } });
+  await native.options.onEvent({ type: "result", subtype: "success", result: "SECOND-OK" });
+  const read = await f.owner.read(f.entry, { messageId: "second", requestMessageIds: ["first", "second"] });
+  assert.equal(read.messages.find(message => message.text === "FIRST-PARTIAL").requestMessageId, "first");
+  assert.equal(read.messages.find(message => message.text === "FIRST-PARTIAL").role, "commentary");
+  assert.equal(read.messages.find(message => message.text === "SECOND-OK").requestMessageId, "second");
+  // A cold read uses the original native input identities, without live state.
+  const directory = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  await writeFile(path.join(directory, `${f.conversationId}.jsonl`), [
+    { type: "user", uuid: claudeNativeMessageId("first"), message: { content: "First request" } },
+    { type: "assistant", uuid: "first-output", message: { id: "first-api", content: [{ type: "text", text: "FIRST-PARTIAL" }] } },
+    { type: "user", uuid: claudeNativeMessageId("second"), message: { content: "Second request" } },
+    { type: "assistant", uuid: "second-output", message: { id: "second-api", content: [{ type: "text", text: "SECOND-OK" }] } }
+  ].map(JSON.stringify).join("\n") + "\n");
+  f.entry.nativeTurn.reset();
+  const restored = await f.owner.read(f.entry, { messageId: "second", requestMessageIds: ["first", "second"] });
+  assert.deepEqual(restored.messages.map(message => [message.text, message.requestMessageId]),
+    [["FIRST-PARTIAL", "first"], ["SECOND-OK", "second"]]);
+});
+
+for (const savedFrame of [false, true]) test(`verified Claude Stop retains partial output for transcript reads, savedFrame=${savedFrame}`, async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send("stopped-request");
+  await f.frame({ type: "stream_event", event: { type: "message_start", message: { id: "stopped-api" } } });
+  await f.frame({ type: "stream_event", event: { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } } });
+  await f.frame({ type: "stream_event", event: { type: "content_block_delta", index: 0, delta: { text: "Already visible partial answer" } } });
+  if (savedFrame) await f.frame({ type: "assistant", uuid: "stopped-output", message: { id: "stopped-api",
+    content: [{ type: "text", text: "Already visible partial answer" }] } });
+  // The control acknowledgement need not deliver a terminal generation frame
+  // before the managed process is drained, as observed in the live Stop case.
+  const native = f.entry.process;
+  native.client.interrupt = async () => {};
+  native.stop = async () => ({ scopeEmpty: false, exited: false });
+  await assert.rejects(f.owner.interrupt(f.entry), { code: "claude_stop_unconfirmed" });
+  const unconfirmed = await f.owner.read(f.entry, { messageId: "stopped-request" });
+  assert.equal(unconfirmed.messages.find(m => m.text === "Already visible partial answer").complete, false);
+  native.stop = async () => ({ scopeEmpty: true, exited: true });
+  await f.owner.interrupt(f.entry);
+  const stopped = await f.owner.read(f.entry, { messageId: "stopped-request" });
+  assert.equal(stopped.status, "interrupted");
+  assert.equal(stopped.messages.length, 1, "Saved-frame and streaming aliases are one interrupted output");
+  assert.deepEqual(stopped.messages.map(m => ({ text: m.text, role: m.role, complete: m.complete,
+    requestMessageId: m.requestMessageId, outputId: m.outputId })), [{
+    text: "Already visible partial answer", role: "commentary", complete: true,
+    requestMessageId: "stopped-request", outputId: "claude_stopped-api_0"
+  }]);
+  assert.equal(f.final(), null, "An interrupted partial is never a completed answer receipt");
+  await f.owner.interrupt(f.entry);
+  assert.deepEqual((await f.owner.read(f.entry, { messageId: "stopped-request" })).messages, stopped.messages);
+  const { readPersistentConversation, projectStoredPersistentConversation } = await import("../src/server/conversation/providers/scoped.js");
+  const transcript = createConversationTranscript({ storage: createMemoryConversationStorage() });
+  const store = Object.fromEntries(Object.entries(transcript).map(([name, operation]) =>
+    [name, (scope, ...args) => operation(JSON.stringify([scope.sessionId, scope.conversationId]), ...args)]));
+  store.readConversationStream = () => ({ messages: [] });
+  const scope = { sessionId: "session", conversationId: "temporary" };
+  await store.writeConversationUserMessage(scope, { messageId: "stopped-request", text: "Explain" });
+  const options = { ...scope, store, context: {},
+    record: { conversationId: "temporary", providerConversationId: f.conversationId, messageId: "stopped-request", status: "interrupted" },
+    operations: { readConversation: (_sessionId, input) => f.owner.read(f.entry, input) },
+    records: { input: (record, input) => ({ ...record, ...input }), save: async (_context, record, patch) => ({ ...record, ...patch }) },
+    receipts: { persisted: () => true },
+    projection: { context: context => context, messageScope: (_context, scope) => scope,
+      message: message => message, messageMetadata: () => ({}), snapshot: value => value }, publish: async () => {}
+  };
+  await readPersistentConversation(options);
+  await readPersistentConversation(options);
+  f.entry.nativeTurn.reset();
+  const restored = await projectStoredPersistentConversation(options);
+  assert.deepEqual(restored.messages.map(m => [m.role, m.text]), [
+    ["user", "Explain"], ["commentary", "Already visible partial answer"]
+  ], "Canonical history retains exactly one interrupted partial after live state is gone");
+});
+
+for (const historyFirst of [true, false]) test(`stopped Claude output and late native history remain one output, historyFirst=${historyFirst}`, async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send("stopped-race");
+  await f.frame({ type: "stream_event", event: { type: "message_start", message: { id: "race-api" } } });
+  await f.frame({ type: "stream_event", event: { type: "content_block_start", index: 1, content_block: { type: "text", text: "" } } });
+  await f.frame({ type: "stream_event", event: { type: "content_block_delta", index: 1, delta: { text: "Already visible" } } });
+  f.entry.process.client.interrupt = async () => {};
+  await f.owner.interrupt(f.entry);
+  const saveNative = async () => {
+    const directory = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+    await mkdir(directory, { recursive: true });
+    await writeFile(path.join(directory, `${f.conversationId}.jsonl`), [
+      { type: "user", uuid: claudeNativeMessageId("stopped-race"), message: { content: "Explain" } },
+      { type: "assistant", uuid: "race-saved", apiBlockIndex: 1,
+        message: { id: "race-api", stop_reason: "end_turn", content: [{ type: "text", text: "Already visible, with later native text" }] } }
+    ].map(JSON.stringify).join("\n") + "\n");
+  };
+  if (historyFirst) await saveNative();
+  const read = await f.owner.read(f.entry, { messageId: "stopped-race" });
+  assert.equal(read.messages.length, 1, "One native API block cannot become both a saved answer and a live partial");
+  assert.equal(read.messages[0].role, "commentary");
+  assert.equal(read.messages[0].outputId, "claude_race-api_1");
+  assert.equal(read.messages[0].text, historyFirst ? "Already visible, with later native text" : "Already visible");
+  assert.equal(f.final(), null);
+  const { readPersistentConversation } = await import("../src/server/conversation/providers/scoped.js");
+  const transcript = createConversationTranscript({ storage: createMemoryConversationStorage() });
+  const store = Object.fromEntries(Object.entries(transcript).map(([name, operation]) =>
+    [name, (scope, ...args) => operation(JSON.stringify([scope.sessionId, scope.conversationId]), ...args)]));
+  store.readConversationStream = () => ({ messages: [] });
+  const scope = { sessionId: "session", conversationId: "temporary" };
+  await store.writeConversationUserMessage(scope, { messageId: "stopped-race", text: "Explain" });
+  const options = { ...scope, store, context: {},
+    record: { conversationId: "temporary", providerConversationId: f.conversationId, messageId: "stopped-race", status: "interrupted" },
+    operations: { readConversation: (_sessionId, input) => f.owner.read(f.entry, input) },
+    records: { input: (record, input) => ({ ...record, ...input }), save: async (_context, record, patch) => ({ ...record, ...patch }) },
+    receipts: { persisted: () => true },
+    projection: { context: context => context, messageScope: (_context, scope) => scope,
+      message: message => message, messageMetadata: () => ({}), snapshot: value => value }, publish: async () => {}
+  };
+  await readPersistentConversation(options);
+  if (!historyFirst) await saveNative();
+  await readPersistentConversation(options);
+  f.entry.nativeTurn.reset();
+  await readPersistentConversation(options);
+  const turns = await store.readConversationLog(scope);
+  assert.equal(turns.length, 1);
+  assert.equal(turns[0].assistant, null, "Reload cannot promote an already retained interruption into an answer");
+  assert.equal(turns[0].commentary.length, 1, "Later native identity cannot duplicate the saved output");
+  assert.equal(turns[0].commentary[0].text, read.messages[0].text);
+});
+
+// Claude 2.1.289 folds internal commands into the outer turn. Their lifecycle
+// completes before result; the original input's completion follows result.
+for (const background of [false, true]) test(`folded native command cannot strand its outer input, background=${background}`, async () => {
+  const { turn, send, events } = fixture();
+  await send();
+  const outer = claudeNativeMessageId("first");
+  await turn.receive({ type: "command_lifecycle", command_uuid: outer, state: "started" });
+  if (background) await turn.receive({ type: "system", subtype: "task_started", task_id: "background" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: "internal-notification", state: "started" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: "internal-notification", state: "completed" });
+  assert.equal(turn.read().active, true, "A folded command's completion does not complete its outer generation");
+  await turn.receive({ type: "result", subtype: "success", result: "Done" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: outer, state: "completed" });
+  assert.equal(turn.read().pendingCommands, 0);
+  assert.equal(turn.read().active, background);
+  if (background) {
+    await turn.receive({ type: "system", subtype: "task_notification", task_id: "background", status: "completed" });
+    assert.equal(turn.read().active, true, "The main model still needs to consume the worker result");
+    await turn.receive({ type: "result", subtype: "success", result: "Worker checked" });
+  }
+  assert.equal(turn.read().status, "completed");
+  assert.equal(events.filter(event => event.type === "settled").length, 1);
+});
+
+test("folded lifecycle completion cannot acknowledge interruption before the generation result", async () => {
+  const { turn, send, client } = fixture();
+  await send();
+  await turn.receive({ type: "command_lifecycle", command_uuid: "internal-notification", state: "started" });
+  let confirmed = false;
+  const steering = turn.interruptGeneration(client).then(() => { confirmed = true; });
+  await turn.receive({ type: "command_lifecycle", command_uuid: "internal-notification", state: "completed" });
+  await Promise.resolve();
+  assert.equal(confirmed, false);
+  await turn.receive({ type: "result", subtype: "success", terminal_reason: "aborted_streaming", result: "" });
+  await steering;
+  await send("goal");
+  await turn.receive({ type: "result", subtype: "success", result: "Goal accepted" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: claudeNativeMessageId("goal"), state: "completed" });
+  assert.equal(turn.read().pendingCommands, 0);
+  assert.equal(turn.read().status, "completed");
+});
+
+test("late input completion cannot settle a newer native continuation", async () => {
+  const { turn, send } = fixture();
+  await send();
+  await turn.receive({ type: "result", subtype: "success", result: "First answer" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: "native-successor", state: "started" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: claudeNativeMessageId("first"), state: "completed" });
+  assert.equal(turn.read().active, true);
+  await turn.receive({ type: "result", subtype: "success", result: "Successor answer" });
+  assert.equal(turn.read().status, "completed");
+});
+
 test("Claude native follow-ups reactivate a completed turn without admitting another human message", async () => {
   for (const start of [
     { type: "user", uuid: "notification", origin: { kind: "task-notification" } },
@@ -93,6 +408,8 @@ test("Claude authoritative task snapshots repair membership and ignore ambient w
   await turn.receive({ type: "system", subtype: "background_tasks_changed", tasks: [
     { task_id: "watcher", task_type: "local_bash", ambient: true }
   ] });
+  assert.equal(turn.read().active, true);
+  await turn.receive({ type: "result", subtype: "success", result: "Background work checked" });
   assert.equal(turn.read().active, false);
   await turn.receive({ type: "system", subtype: "status", status: null });
   await turn.receive({ type: "system", subtype: "background_tasks_changed", tasks: [] });
@@ -100,6 +417,8 @@ test("Claude authoritative task snapshots repair membership and ignore ambient w
   await turn.receive({ type: "system", subtype: "background_tasks_changed", tasks: [{ task_id: "late", task_type: "local_bash" }] });
   assert.equal(turn.read().active, true, "A later task snapshot restores the working state");
   await turn.receive({ type: "system", subtype: "task_updated", task_id: "late", patch: { status: "completed" } });
+  assert.equal(turn.read().active, true);
+  await turn.receive({ type: "result", subtype: "success", result: "Late worker checked" });
   assert.equal(turn.read().active, false);
 });
 
@@ -397,7 +716,7 @@ test("Claude split text followed by a tool is commentary, never a final answer",
 
 
 import { createClaudeConversationOwner } from "../src/server/conversation/claudeTurn.js";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, mkdir, rm, readFile, writeFile, appendFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { createConversationRuntime, createMemoryConversationStorage, createConversationTranscript } from "../src/server/conversation/index.js";
@@ -419,7 +738,7 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
       ...(releaseExecution ? { releaseExecution } : {}),
       select() {}, read: (_context, id) => saved.get(id),
       async save(entry) { saved.set(entry.id, JSON.stringify({ turnId: entry.turn?.id,
-        state: entry.turn?.state, accountIdentity: entry.accountIdentity })); },
+        state: entry.turn?.state, pausedGoal: entry.pausedGoal, blockedGoal: entry.blockedGoal, accountIdentity: entry.accountIdentity })); },
       async hasMessage() { return false; },
       readSessionConversations: () => ({ ids: [...saved.keys()], context })
     },
@@ -427,7 +746,7 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
       context: async () => context,
       entry: () => ({ options: { mainId: conversationId }, check() {} }),
       check() {}, account: () => ({ identity: behavior.account, providerId }),
-      async configuration() { await behavior.configure?.(); return { systemPrompt: "Retained host instructions", settings: {}, model: providerId === "deepseek" ? "deepseek-flash" : "sonnet" }; },
+      async configuration() { await behavior.configure?.(); return { systemPrompt: behavior.systemPrompt || "Retained host instructions", settings: {}, model: providerId === "deepseek" ? "deepseek-flash" : "sonnet" }; },
       async message(_entry, _input, { message }) { return message; }
     },
     process: {
@@ -437,7 +756,35 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
           async stop() { return { scopeEmpty: true, exited: true }; },
           client: { async request() { return {}; },
             async send(_message, input) {
+              (behavior.nativeInputs ||= []).push(_message);
               await options.onEvent({ type: "user", uuid: input.messageId, session_id: options.sessionId });
+              if (_message.startsWith("/goal ")) {
+                behavior.goalAttachmentWork = (async () => {
+                  await behavior.beforeGoalAttachment?.();
+                  const directory = path.join(root, "projects", root.replace(/[^a-zA-Z0-9]/gu, "-"));
+                  await mkdir(directory, { recursive: true });
+                  const condition = _message.slice(6);
+                  if (condition === "clear" && behavior.clearWithoutGoalSentinel) {
+                    const user = { type: "user", uuid: input.messageId, message: { content: "<command-name>/goal</command-name>\n<command-args>clear</command-args>" } };
+                    const receipt = { type: "system", subtype: "local_command", uuid: `${input.messageId}-clear`, parentUuid: input.messageId,
+                      commandRun: { command: "goal", args: "clear" }, content: "<local-command-stdout>No goal set</local-command-stdout>" };
+                    await appendFile(path.join(directory, `${options.sessionId}.jsonl`), [user, receipt].map(JSON.stringify).join("\n") + "\n");
+                    await options.onEvent({ type: "result", subtype: "success", local_command: "goal", user_message_uuid: input.messageId });
+                    return;
+                  }
+                  const marker = { type: "attachment", uuid: `${input.messageId}-goal`, timestamp: new Date().toISOString(),
+                    attachment: { type: "goal_status", condition, sentinel: true, met: condition === "clear" } };
+                  const user = { type: "user", uuid: input.messageId, parentUuid: marker.uuid, message: { content: _message } };
+                  const caveat = { type: "user", uuid: `${input.messageId}-caveat`, parentUuid: marker.uuid,
+                    message: { content: "<local-command-caveat>Native command context</local-command-caveat>" } };
+                  const receipt = { type: "system", subtype: "local_command", uuid: `${input.messageId}-receipt`, parentUuid: input.messageId,
+                    commandRun: { command: "goal", args: "clear" }, content: "<local-command-stdout>Goal cleared: prior goal</local-command-stdout>" };
+                  await appendFile(path.join(directory, `${options.sessionId}.jsonl`), (condition === "clear"
+                    ? [marker, caveat, { ...user, parentUuid: caveat.uuid }, receipt] : [marker, user]).map(JSON.stringify).join("\n") + "\n");
+                  if (condition === "clear") await options.onEvent({ type: "result", subtype: "success", local_command: "goal", user_message_uuid: input.messageId });
+                })();
+                void behavior.goalAttachmentWork.catch(() => {});
+              }
             },
             async interrupt() {
               await options.onEvent({ type: "result", subtype: "success", result: "", terminal_reason: "aborted_streaming" });
@@ -478,6 +825,28 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
     async reopen() { entry = await owner.open(context, { mainId: conversationId }); return entry; } };
 }
 
+test("Claude status retains active instructions and applies changed guidance once idle", async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send();
+  const original = f.entry.process;
+  f.behavior.systemPrompt = "Changed project guidance during the active turn.";
+  const state = await f.owner.ensureReady(f.entry);
+  assert.equal(state.turn.active, true);
+  assert.equal(f.entry.process, original);
+  assert.equal(f.processes.length, 1);
+  await f.frame({ type: "result", subtype: "success", result: "Done" });
+  await f.owner.ensureReady(f.entry);
+  assert.equal(f.processes.length, 2, "Idle readiness installs the changed instructions");
+});
+
+test("Claude active status still rejects account replacement", async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send();
+  f.behavior.account = "account-b";
+  await assert.rejects(f.owner.ensureReady(f.entry), { code: "claude_account_changed" });
+  assert.equal(f.entry.process, null);
+});
+
 test("Claude continuation supersedes an older completion checkpoint", { timeout: 10_000 }, async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();
@@ -569,6 +938,8 @@ test("Claude final receipt waits for original background settlement and preserve
   assert.equal(f.final(), null);
   assert.equal(f.entry.nativeTurn.read().active, true);
   await f.frame({ type: "system", subtype: "task_notification", task_id: "background", status: "completed" });
+  assert.equal(f.final(), null, "The main model must finish processing the task notification");
+  await f.frame({ type: "result", subtype: "success", result: "The answer" });
   assert.equal(f.final().itemId, "claude_saved-answer_0");
   assert.equal(f.final().outputId, "claude_api-answer_3");
   assert.equal(f.messages.length, 1, "Original duplicate result adds no synthetic assistant carrier");
@@ -921,11 +1292,11 @@ test("Claude verified native cleanup retains interrupted checkpoint refusal with
 
 // Retain the original supplied-store/native process fixture and drive it through
 // the actual common runtime, including its completion-only admitted receipt.
-async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming } = {}) {
+async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, representation = "canonical", beforeToolWrite, signal, executeTool = async () => ({}) } = {}) {
   const f = await publishedClaudeFixture(t, { canonicalAdmission: true });
   const storage = createMemoryConversationStorage();
   const transcript = createConversationTranscript({ storage });
-  const context = { actor: { id: "owner" }, surface: "app" };
+  const context = { actor: { id: "owner" }, surface: "app", signal };
   const admissions = [];
   const checkpoints = [];
   const actions = createActionCatalogue();
@@ -933,7 +1304,7 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming } = {})
     id: "lesson.inspect", version: 1, kind: "query", channels: ["automation"], surfaces: ["app"],
     permission: { require: "authenticated" }, idempotency: "none",
     input: { schema: createSchema({}), mode: "replace" },
-    output: { schema: createSchema({}), mode: "replace" }, execute: async () => ({})
+    output: { schema: createSchema({}), mode: "replace" }, execute: executeTool
   }] });
   let delivery;
   f.behavior.admit = event => transcript.writeConversationUserMessage("lesson", {
@@ -958,13 +1329,15 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming } = {})
     transcript: { history: async () => [], readConversationLog: () => transcript.readConversationLog("lesson"),
       hasMessage: id => transcript.conversationMessageIdExists("lesson", id),
       writeUserMessage: input => transcript.writeConversationUserMessage("lesson", input) },
-    ...(tools ? { applicationTools: { storage, prepareContext(actual, admission) {
+    ...(tools ? { applicationTools: { storage: beforeToolWrite ? { ...storage, async write(...args) {
+      await beforeToolWrite(); return storage.write(...args);
+    } } : storage, prepareContext(actual, admission) {
       admissions.push(admission); return actual;
     } } } : {}) };
   const runtime = createConversationRuntime({ ...(tools ? { actions } : {}), authorize: () => true, onDeliveryTiming,
     host: { conversation: () => binding } });
   t.after(() => runtime.close());
-  const conversation = await runtime.open({ id: "lesson", context });
+  const conversation = await runtime.open({ id: "lesson", context, representation });
   f.setBeforeState((entry, event) => {
     if (event.state !== "completed") return;
     assert.equal(entry.turn.active, true, "Retained checkpoint still precedes saved idle state");
@@ -985,7 +1358,7 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming } = {})
         arguments: { actionId: "lesson.inspect", version: 1 }, _meta: { "claudecode/toolUseId": id } } }
     }, { signal: new AbortController().signal });
   }
-  return { ...f, get entry() { return f.entry; }, runtime, conversation, binding, admissions, checkpoints, loadContract, testSignal: t.signal };
+  return { ...f, get entry() { return f.entry; }, runtime, conversation, binding, admissions, checkpoints, loadContract, storage, toolContext: context, testSignal: t.signal };
 }
 
 async function sendCommon(f, messageId) {
@@ -1022,6 +1395,51 @@ test("Claude fast follow-up completes while the earlier common checkpoint is hel
   assert.equal(f.entry.process.stopped, undefined);
 });
 
+for (const failedSave of [false, true]) test(`Claude goal waits for common final saving, failedSave=${failedSave}`, { timeout: 5_000 }, async t => {
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  let held = false;
+  const f = await suppliedCommonFixture(t, { async beforeToolWrite() {
+    if (!held && f.entry.turn.state === "completed") {
+      held = true;
+      entered.resolve();
+      await release.promise;
+      if (failedSave) throw new Error("Final save unavailable");
+    }
+  } });
+  await sendCommon(f, "before-goal");
+  await f.loadContract();
+  const completing = f.frame({ type: "result", subtype: "success", result: "First answer" });
+  await entered.promise;
+  const command = { action: "set", objective: "Finish the checks", messageId: "finishing-goal",
+    expectedSegmentId: `claude:${f.conversationId}` };
+  f.setBeforeState(() => {});
+  const goalChecked = Promise.withResolvers();
+  f.binding.admission = (_context, operation) => { if (operation === "goal") goalChecked.resolve(); };
+  let result;
+  const setting = f.conversation.updateGoal(command).then(value => { result = value; return value; }, error => { result = error; throw error; });
+  void setting.catch(() => {});
+  try {
+    await goalChecked.promise;
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(result, undefined, "The goal waits for the original final save before dispatch");
+    assert.equal(f.entry.command, null);
+  } finally { release.resolve(); }
+  await completing;
+  if (failedSave) {
+    await assert.rejects(setting, { code: "conversation_storage_unavailable" });
+    assert.equal(f.entry.command, null, "Failed saving must not dispatch a goal");
+  } else {
+    assert.equal((await setting).status, "accepted");
+    assert.equal(f.entry.command.messageId, command.messageId);
+    await f.frame({ type: "result", subtype: "success", result: "Checks complete" });
+    await f.conversation.wait();
+    assert.equal((await f.conversation.updateGoal(command)).duplicate, true);
+    const log = await f.binding.transcript.readConversationLog();
+    assert.equal(log.flatMap(turn => turn.messages).filter(message => message.messageId === command.messageId).length, 1);
+  }
+});
+
 test("Claude delivery timing separates native acknowledgement from the held canonical receipt", { timeout: 10_000 }, async t => {
   const timings = [];
   const f = await suppliedCommonFixture(t, { onDeliveryTiming: event => timings.push(event) });
@@ -1060,9 +1478,24 @@ for (const tools of [true, false]) test(`Claude supplied common runtime checkpoi
   if (tools) f.admissions.at(-1).assertCompletionCurrent();
 });
 
-test("Claude supplied common completion joins accepted steering and checkpoints only its own final", { timeout: 10_000 }, async t => {
+for (const sendNow of [false, true]) test(`Claude supplied common completion joins accepted steering and checkpoints only its own final, sendNow=${sendNow}`, { timeout: 10_000 }, async t => {
   const f = await suppliedCommonFixture(t);
   await sendCommon(f, "common-first");
+  if (sendNow) {
+    const native = f.entry.process;
+    const send = native.client.send;
+    native.client.supportsSendNow = () => true;
+    native.client.interrupt = async () => { throw Error("Steering must preserve the background worker"); };
+    await f.frame({ type: "system", subtype: "task_started", task_id: "common-worker" });
+    native.client.send = async (message, input) => {
+      assert.equal(input.sendNow, true);
+      await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
+      await f.frame({ type: "result", subtype: "error_during_execution", is_error: true,
+        terminal_reason: "aborted_tools", user_message_uuid: claudeNativeMessageId("common-first") });
+      await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "started" });
+      await send(message, input);
+    };
+  }
   await f.loadContract("first-contract");
   const first = f.admissions.at(-1);
   const legacyCompletion = f.entry.completion.promise;
@@ -1076,6 +1509,12 @@ test("Claude supplied common completion joins accepted steering and checkpoints
   await f.loadContract("successor-contract");
   assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
   await f.frame({ type: "result", subtype: "success", result: "The successor question", uuid: "successor-final" });
+  if (sendNow) {
+    assert.equal(f.checkpoints.length, 0, "Foreground completion cannot checkpoint live background work");
+    await f.frame({ type: "system", subtype: "task_notification", task_id: "common-worker", status: "completed" });
+    assert.equal(f.checkpoints.length, 0);
+    await f.frame({ type: "result", subtype: "success", result: "The successor question", uuid: "successor-final" });
+  }
   await f.conversation.wait();
   assert.equal((await legacyCompletion).status, "completed");
   assert.equal(f.checkpoints.length, 1);
@@ -1084,6 +1523,35 @@ test("Claude supplied common completion joins accepted steering and checkpoints
   assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
 });
 
+for (const preceding of [null, "task_updated", "background_tasks_changed"])
+test(`Claude background completion retains admitted tools until the main continuation answers: ${preceding}`, { timeout: 5_000 }, async t => {
+  const f = await suppliedCommonFixture(t);
+  await sendCommon(f, "background-authority");
+  await f.loadContract("before-background");
+  await f.frame({ type: "system", subtype: "task_started", task_id: "worker" });
+  await f.frame({ type: "result", subtype: "success", result: "The worker is running." });
+  if (preceding) {
+    await f.frame(preceding === "task_updated"
+      ? { type: "system", subtype: preceding, task_id: "worker", patch: { status: "completed" } }
+      : { type: "system", subtype: preceding, tasks: [] });
+    await new Promise(resolve => setImmediate(resolve));
+  }
+  await f.frame({ type: "system", subtype: "task_notification", task_id: "worker", status: "completed" });
+  // The process delivers the task's completed notice before the main model
+  // consumes it. Let the existing runtime finish any incorrectly queued cleanup.
+  await new Promise(resolve => setImmediate(resolve));
+  await new Promise(resolve => setImmediate(resolve));
+  await f.frame({ type: "user", uuid: "worker-notice", origin: { kind: "task-notification" } });
+  const response = await f.loadContract("after-background");
+  assert.equal(JSON.parse(response.mcp_response.result.content[0].text).ok, true);
+  assert.equal(f.checkpoints.length, 0, "Worker completion is not the main answer's checkpoint");
+  await f.frame({ type: "result", subtype: "success", result: "Worker evidence checked." });
+  await f.conversation.wait();
+  assert.equal(f.checkpoints.length, 1);
+  assert.equal(f.checkpoints[0].final.text, "Worker evidence checked.");
+  assert.equal(f.entry.command, null, "The actual final still releases application authority");
+});
+
 test("Claude supplied completion retains the original waiter when a reserved successor is rejected before dispatch", { timeout: 10_000 }, async t => {
   const f = await suppliedCommonFixture(t);
   await sendCommon(f, "unreplaced-first");
@@ -1223,3 +1691,840 @@ test("Claude Stop cancels configuration that has not started its native process"
   await assert.rejects(preparing, /stopped|closing/);
   assert.equal(f.processes.length, 0, "Stopped configuration must not launch Claude later");
 });
+
+// The application has persisted dispatch intent, but the native guard has not
+// written anything. Its rejection must clear that intent, not trap Retry forever.
+test("Claude supplied runtime records rejection when the native turn ends before the pipe write", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { representation: "native" });
+  let rejected = 0;
+  let sent = 0;
+  f.behavior.initialize = native => {
+    const send = native.client.send;
+    native.client.send = (...args) => { sent += 1; return send(...args); };
+  };
+  await assert.rejects(f.conversation.send({
+    messageId: "stopped-before-write", text: "Do the work",
+    onPromptSending() { f.entry.nativeTurn.stop(); },
+    onPromptRejected() { rejected += 1; }
+  }), error => error.delivery === "not-sent");
+  assert.equal(sent, 0);
+  assert.equal(rejected, 1);
+  assert.equal(f.messages.length, 0);
+});
+
+test("only natural completion marks a rejected steer eligible for ordinary Send; Stop and cancellation do not", async () => {
+  for (const ending of ["complete", "stop", "cancel"]) {
+    const f = fixture();
+    await f.send();
+    if (ending === "complete") await f.turn.receive({ type: "result", subtype: "success", result: "Done" });
+    else if (ending === "stop") f.turn.stop();
+    else await f.turn.interrupt(f.client);
+    let writes = 0;
+    f.client.send = async () => { writes += 1; };
+    await assert.rejects(f.send("late"), error => {
+      assert.equal(error.delivery, "not-sent");
+      assert.equal(error.code, ending === "complete" ? "conversation_steer_turn_finished" : "assistant_claude_turn_failed");
+      assert.equal(error.statusCode, ending === "complete" ? 409 : undefined);
+      return true;
+    });
+    assert.equal(writes, 0);
+    f.turn.stop();
+  }
+});
+
+test("interruption before a late steer distinguishes completed work from Stop, cancellation and idle state", async () => {
+  for (const ending of ["complete", "stop", "cancel", "idle", "steering"]) {
+    const f = fixture();
+    await f.send();
+    let firstInterrupt;
+    if (ending === "complete" || ending === "idle") {
+      await f.turn.receive({ type: "result", subtype: "success", result: "Done" });
+      if (ending === "idle") f.turn.reset();
+    } else if (ending === "stop") f.turn.stop();
+    else if (ending === "cancel") await f.turn.interrupt(f.client);
+    else {
+      const began = Promise.withResolvers();
+      f.client.interrupt = async () => { began.resolve(); };
+      firstInterrupt = f.turn.interruptGeneration(f.client).catch(() => {});
+      await began.promise;
+    }
+    let interrupts = 0;
+    f.client.interrupt = async () => { interrupts += 1; };
+    await assert.rejects(f.turn.interruptGeneration(f.client), error => {
+      assert.equal(error.delivery, "not-sent");
+      assert.equal(error.code, ending === "complete" ? "conversation_steer_turn_finished" : "assistant_claude_turn_failed");
+      assert.equal(error.statusCode, ending === "complete" ? 409 : undefined);
+      return true;
+    });
+    assert.equal(interrupts, 0);
+    f.turn.stop();
+    await firstInterrupt;
+  }
+});
+
+test("folded internal command preserves the original published answer owner", async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send();
+  await f.frame({ type: "command_lifecycle", command_uuid: "internal-notification", state: "started" });
+  await f.frame({ type: "command_lifecycle", command_uuid: "internal-notification", state: "completed" });
+  await f.frame({ type: "result", subtype: "success", result: "The user's answer" });
+  await f.frame({ type: "command_lifecycle", command_uuid: claudeNativeMessageId("request"), state: "completed" });
+  assert.equal(f.entry.turn.active, false);
+  assert.equal(f.final()?.text, "The user's answer");
+});
+
+
+test("failed interruption reports definite non-delivery after the original process cleanup", async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send("original-input");
+  let writes = 0;
+  f.entry.process.client.send = async () => { writes++; };
+  f.entry.process.client.interrupt = async () => { throw new Error("Interrupt was not acknowledged"); };
+  await assert.rejects(f.send("goal-input"), error => error.delivery === "not-sent" &&
+    error.message === "Interrupt was not acknowledged");
+  assert.equal(writes, 0);
+  assert.equal(f.entry.process, null, "The original stop owner still proves cleanup before returning");
+});
+
+test("interrupt confirmation timeout is a recoverable typed failure, not a generic server error", async () => {
+  const { turn, send, client } = fixture();
+  await send();
+  await assert.rejects(turn.interruptGeneration(client, { timeoutMs: 5 }), error =>
+    error.code === "assistant_claude_interrupt_timeout" && error.statusCode === 503 && /not sent/.test(error.message));
+  turn.stop();
+});
+
+
+test("failed cleanup after interrupt failure retains the cleanup error and execution custody", async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send("original-input");
+  const native = f.entry.process;
+  const originalStop = native.stop;
+  native.client.interrupt = async () => { throw new Error("Interrupt was not acknowledged"); };
+  native.stop = async () => ({ scopeEmpty: false, exited: false });
+  try {
+    await assert.rejects(f.send("goal-input"), error => error.code === "claude_stop_unconfirmed" &&
+      error.delivery !== "not-sent");
+    assert.equal(f.entry.process, native);
+    assert.ok(f.entry.executionId);
+  } finally { native.stop = originalStop; }
+});
+
+for (const stage of ["preparation", "native-ready"]) test(`cancelled Claude goal cannot dispatch after ${stage}`, { timeout: 5_000 }, async t => {
+  const controller = new AbortController();
+  const f = await suppliedCommonFixture(t, { tools: false, signal: controller.signal });
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  let sends = 0;
+  if (stage === "preparation") f.binding.prepareInput = async input => {
+    entered.resolve(); await release.promise; return input;
+  };
+  f.behavior.initialize = async native => {
+    const send = native.client.send;
+    native.client.send = (...args) => { sends++; return send(...args); };
+    if (stage === "native-ready") { entered.resolve(); await release.promise; }
+  };
+  const operation = f.conversation.updateGoal({ action: "set", objective: "Finish the checks", messageId: "stopped-goal",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  void operation.catch(() => {});
+  await entered.promise;
+  controller.abort(new Error("The person stopped this goal"));
+  release.resolve();
+  await assert.rejects(operation, error => error.delivery === "not-sent" && /goal command was stopped before delivery/.test(error.message));
+  assert.equal(sends, 0, "No cancelled goal reaches the native input");
+  assert.equal((await f.binding.transcript.readConversationLog()).length, 0, "An unsent goal has no accepted receipt");
+});
+
+test("raw Claude goal cancellation during native preparation prevents its write", { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  const controller = new AbortController();
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  let sends = 0;
+  f.behavior.initialize = async native => {
+    native.client.send = async () => { sends++; };
+    entered.resolve(); await release.promise;
+  };
+  const operation = f.owner.updateGoal(f.entry, { action: "set", objective: "Finish the checks" }, { signal: controller.signal });
+  void operation.catch(() => {});
+  await entered.promise;
+  controller.abort(new Error("Goal stopped"));
+  release.resolve();
+  await assert.rejects(operation, error => error.delivery === "not-sent");
+  assert.equal(sends, 0);
+});
+
+test("aborting an admitted Claude goal preserves its receipt and final output", { timeout: 5_000 }, async t => {
+  const controller = new AbortController();
+  const f = await suppliedCommonFixture(t, { tools: false, signal: controller.signal });
+  const result = await f.conversation.updateGoal({ action: "set", objective: "Finish the checks", messageId: "admitted-goal",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  assert.equal(result.status, "accepted");
+  controller.abort(new Error("The person stopped this goal"));
+  await f.frame({ type: "result", subtype: "success", result: "Work already delivered" });
+  await f.conversation.wait();
+  const log = await f.binding.transcript.readConversationLog();
+  assert.equal(log.flatMap(turn => turn.messages).filter(message => message.messageId === "admitted-goal").length, 1);
+  assert.equal(f.entry.turn.state, "completed");
+});
+
+test("Claude goal cancellation at the final native write preserves definite non-delivery", { timeout: 5_000 }, async t => {
+  const controller = new AbortController();
+  const f = await suppliedCommonFixture(t, { tools: false, signal: controller.signal });
+  let sends = 0;
+  f.behavior.initialize = async native => { native.client.send = async () => { sends++; }; };
+  f.setBeforeState((_entry, event) => { if (event.state === "starting") controller.abort(new Error("Stopped at write boundary")); });
+  await assert.rejects(f.conversation.updateGoal({ action: "set", objective: "Finish the checks", messageId: "write-stopped-goal",
+    expectedSegmentId: `claude:${f.conversationId}` }), error => error.delivery === "not-sent");
+  assert.equal(sends, 0);
+  assert.equal((await f.binding.transcript.readConversationLog()).length, 0);
+});
+
+for (const action of ["set", "resume"]) for (const finishCount of [1, 2]) test(`Claude goal re-admits a definite finished-turn race once, action=${action}, finishes=${finishCount}`, { timeout: 5_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  let preparations = 0;
+  let writes = 0;
+  f.behavior.initialize = async native => {
+    const send = native.client.send;
+    native.client.send = async (...args) => { writes++; return send(...args); };
+  };
+  f.setBeforeState(async (_entry, event) => {
+    // A resumed native process can finish its previous generation during the
+    // host's asynchronous new-input checkpoint, before this input is written.
+    if (event.state === "starting" && ++preparations <= finishCount) {
+      await f.frame({ type: "result", subtype: "success", result: "Previous work finished" });
+    }
+  });
+  let expectedGoalId;
+  if (action === "resume") {
+    const directory = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+    await mkdir(directory, { recursive: true });
+    await writeFile(path.join(directory, `${f.conversationId}.jsonl`), `${JSON.stringify({ type: "attachment",
+      timestamp: "2026-10-16T00:00:00.000Z", attachment: { type: "goal_status", condition: "Finish the checks", met: false } })}\n`);
+    expectedGoalId = (await f.conversation.readGoal()).id;
+  }
+  const input = { action, objective: "Finish the checks", messageId: "racing-goal", expectedGoalId,
+    expectedSegmentId: `claude:${f.conversationId}` };
+  const pending = f.conversation.updateGoal(input);
+  if (finishCount === 2) {
+    await assert.rejects(pending, error => error.code === "conversation_steer_turn_finished" && error.delivery === "not-sent");
+    assert.equal(writes, 0);
+  } else {
+    assert.equal((await pending).status, "accepted");
+    assert.equal(writes, 1, "The same goal is written only after definite non-delivery");
+    await f.frame({ type: "result", subtype: "success", result: "Checks finished" });
+    await f.conversation.wait();
+    assert.equal((await f.conversation.updateGoal(input)).duplicate, true);
+    const log = await f.binding.transcript.readConversationLog();
+    assert.equal(log.flatMap(turn => turn.messages).filter(message => message.messageId === input.messageId).length, 1);
+  }
+  assert.equal(preparations, 2, "Only one re-admission is allowed");
+});
+
+for (const action of ["set", "resume"]) test(`Claude goal preparation failure permits a safe same-message retry, action=${action}`, { timeout: 5_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  let expectedGoalId;
+  if (action === "resume") {
+    const directory = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+    await mkdir(directory, { recursive: true });
+    await writeFile(path.join(directory, `${f.conversationId}.jsonl`), `${JSON.stringify({ type: "attachment",
+      timestamp: "2026-10-16T00:00:00.000Z", attachment: { type: "goal_status", condition: "Finish the checks", met: false } })}\n`);
+    expectedGoalId = (await f.conversation.readGoal()).id;
+  }
+  const input = { action, objective: "Finish the checks", messageId: "preparation-failed-goal", expectedGoalId,
+    expectedSegmentId: `claude:${f.conversationId}` };
+  let writes = 0;
+  let failPreparation = true;
+  f.behavior.initialize = native => {
+    const send = native.client.send;
+    native.client.send = (...args) => { writes++; return send(...args); };
+    if (failPreparation) throw new Error("Claude preparation stopped before dispatch");
+  };
+  await assert.rejects(f.conversation.updateGoal(input), error =>
+    error.delivery === "not-sent" && /preparation stopped/.test(error.message));
+  assert.equal(writes, 0, "Preparation failed before the authored command reached the native pipe");
+  assert.equal(await f.binding.transcript.hasMessage(input.messageId), false);
+  while (f.entry.command) { f.testSignal.throwIfAborted(); await delay(1); }
+  failPreparation = false;
+  assert.equal((await f.conversation.updateGoal(input)).status, "accepted");
+  assert.equal(writes, 1, "Retry sends the same authored command exactly once");
+  assert.equal(await f.binding.transcript.hasMessage(input.messageId), true);
+  await f.frame({ type: "result", subtype: "success", result: "Checks finished" });
+  await f.conversation.wait();
+});
+
+test("Claude goal does not re-admit uncertain native delivery", { timeout: 5_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  let writes = 0;
+  f.behavior.initialize = async native => {
+    native.client.send = async () => { writes++; throw Object.assign(new Error("Receipt unknown"), { delivery: "uncertain" }); };
+  };
+  await assert.rejects(f.conversation.updateGoal({ action: "set", objective: "Finish the checks",
+    messageId: "uncertain-goal", expectedSegmentId: `claude:${f.conversationId}` }),
+  error => error.delivery === "uncertain");
+  assert.equal(writes, 1);
+});
+
+test("Claude goal re-admission preserves Stop during rejected dispatch cleanup", { timeout: 5_000 }, async t => {
+  const controller = new AbortController();
+  const f = await suppliedCommonFixture(t, { tools: false, signal: controller.signal });
+  let preparations = 0;
+  let writes = 0;
+  f.behavior.initialize = async native => {
+    const send = native.client.send;
+    const stop = native.stop;
+    native.client.send = async (...args) => { writes++; return send(...args); };
+    native.stop = async () => { controller.abort(new Error("The person stopped this goal")); return stop(); };
+  };
+  f.setBeforeState(async (_entry, event) => {
+    if (event.state === "starting") {
+      preparations++;
+      await f.frame({ type: "result", subtype: "success", result: "Previous work finished" });
+    }
+  });
+  await assert.rejects(f.conversation.updateGoal({ action: "set", objective: "Finish the checks",
+    messageId: "race-stopped-goal", expectedSegmentId: `claude:${f.conversationId}` }), /person stopped/);
+  assert.equal(preparations, 1);
+  assert.equal(writes, 0);
+});
+
+for (const observation of ["read", "ensureReady", "recover", "wait"]) test(`Claude ${observation} preserves its own pending startup lease`, { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  let stops = 0;
+  f.behavior.initialize = async native => {
+    const stop = native.stop;
+    native.stop = async () => { stops++; return stop(); };
+    entered.resolve();
+    await release.promise;
+  };
+  const starting = f.owner.ensureProcess(f.entry);
+  void starting.catch(() => {});
+  try {
+    await entered.promise;
+    assert.ok(f.entry.executionId);
+    assert.equal(f.entry.process, null);
+    if (observation === "recover") await f.owner.recover([f.entry]);
+    else if (observation === "wait") await waitForClaudeConversationTurn({ state: f.entry,
+      stop: reason => f.entry.nativeTurn.stopProcess(reason), read: () => f.owner.read(f.entry) });
+    else await f.owner[observation](f.entry);
+    assert.equal(stops, 0, "A live startup's retained cleanup handle is not an orphaned execution");
+  } finally { release.resolve(); }
+  await starting;
+  assert.ok(f.entry.process);
+  await f.owner.close(f.entry);
+  assert.equal(stops, 1, "Explicit close still proves cleanup through the original owner");
+});
+
+test("Claude failed startup no longer exempts retained cleanup from reconciliation", { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  let stops = 0;
+  f.behavior.initialize = async native => {
+    const stop = native.stop;
+    native.stop = async () => { stops++; return stop(); };
+    throw new Error("Initialization failed with cleanup still owned");
+  };
+  await assert.rejects(f.owner.ensureProcess(f.entry), /Initialization failed/);
+  await f.owner.recover([f.entry]);
+  assert.equal(stops, 1);
+  assert.equal(f.entry.executionId, "");
+});
+
+test("Claude cancellation acknowledges its exact no-goal command receipt without waiting for a sentinel", { timeout: 5000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  await f.conversation.updateGoal({ action: "set", objective: "Finish checks", messageId: "cancel-impossible-goal",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  const file = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"), `${f.conversationId}.jsonl`);
+  await appendFile(file, JSON.stringify({ type: "attachment", timestamp: "2026-10-16T18:08:11.407Z",
+    attachment: { type: "goal_status", condition: "Finish checks", met: false, failed: true } }) + "\n");
+  const blocked = await f.conversation.readGoal();
+  assert.equal(blocked.status, "blocked");
+  f.behavior.clearWithoutGoalSentinel = true;
+  await f.conversation.updateGoal({ action: "cancel", expectedGoalId: blocked.id,
+    expectedSegmentId: `claude:${f.conversationId}`, messageId: "clear-impossible-goal" });
+  assert.equal(await f.conversation.readGoal(), null);
+  const history = await readClaudeHistory({ configRoot: f.context.workdir, workdir: f.context.workdir, conversationId: f.conversationId });
+  assert.equal(history.goalCommandId, claudeNativeMessageId("clear-impossible-goal"));
+});
+
+test("Claude goal retains a native impossible evaluation as blocked until explicit Resume", async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  await f.conversation.updateGoal({ action: "set", objective: "Finish checks", messageId: "impossible-goal",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  const initial = await f.conversation.readGoal();
+  const file = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"), `${f.conversationId}.jsonl`);
+  const failed = { type: "attachment", timestamp: "2026-10-16T10:19:52.997Z",
+    attachment: { type: "goal_status", condition: "Finish checks", met: false, failed: true,
+      reason: "The remaining checks require credentials from the user." } };
+  await writeFile(file, JSON.stringify({ ...failed, parent_tool_use_id: "nested" }) + "\n", { flag: "a" });
+  assert.equal((await f.conversation.readGoal()).status, "active", "a nested failure cannot stop the parent goal");
+  await writeFile(file, JSON.stringify(failed) + "\n", { flag: "a" });
+  const blocked = await f.conversation.readGoal();
+  assert.equal(blocked.status, "blocked");
+  assert.equal(blocked.id, initial.id);
+  assert.equal(blocked.objective, initial.objective);
+  assert.equal(blocked.reason, failed.attachment.reason);
+  await f.owner.close(f.entry);
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "blocked", "shutdown preserves native failure");
+  await f.conversation.updateGoal({ action: "resume", expectedGoalId: blocked.id,
+    expectedSegmentId: `claude:${f.conversationId}`, messageId: "resume-impossible-goal" });
+  assert.equal((await f.conversation.readGoal()).status, "active", "explicit Resume establishes a new native goal attachment");
+});
+
+test("Claude goal retains native loop-limit blocking across reads and clears it only on new native goal progress", async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  await f.conversation.updateGoal({ action: "set", objective: "Finish checks", messageId: "blocked-goal",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  const initial = await f.conversation.readGoal();
+  const file = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"), `${f.conversationId}.jsonl`);
+  const append = async frame => writeFile(file, JSON.stringify(frame) + "\n", { flag: "a" });
+  const content = "A hook blocked the turn from ending 9 consecutive times — overriding and ending turn. For Stop/SubagentStop hooks, check stop_hook_active in the input and return success while it's true.";
+  await append({ type: "attachment", timestamp: "2026-10-16T10:19:52.997Z",
+    attachment: { type: "goal_status", condition: "Finish checks", met: false, reason: "Six checks require credentials." } });
+  await append({ type: "assistant", uuid: "quoted-warning", message: { content: [{ type: "text", text: content }] } });
+  await append({ type: "system", subtype: "informational", parent_tool_use_id: "nested", content });
+  assert.equal((await f.conversation.readGoal()).status, "active", "quoted and nested notices cannot block the parent goal");
+  await append({ type: "system", subtype: "informational", timestamp: "2026-10-16T10:19:53.008Z", content });
+  const blocked = await f.conversation.readGoal();
+  assert.equal(blocked.status, "blocked");
+  assert.equal(blocked.id, initial.id, "blocking preserves the original goal identity");
+  assert.match(blocked.reason, /Six checks require credentials/);
+  assert.match(blocked.reason, /Resolve the blocker/);
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "blocked", "all consumers use the original native history owner");
+  await f.owner.close(f.entry);
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "blocked", "process shutdown cannot convert native blocking to a pause");
+  await append({ type: "attachment", timestamp: "2026-10-16T10:20:00.000Z",
+    attachment: { type: "goal_status", condition: "Finish checks", met: true, reason: "Checks passed." } });
+  await append({ type: "system", subtype: "informational", timestamp: "2026-10-16T10:20:01.000Z", content });
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "complete", "a later hook failure cannot reopen completed work");
+  await f.conversation.updateGoal({ action: "set", objective: "Next checks", messageId: "next-goal",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  assert.equal((await f.conversation.readGoal()).status, "active", "new goal attachment supersedes the earlier block");
+});
+
+for (const action of ["set", "resume"]) test(`Claude ${action} waits for its exact delayed goal attachment`, { timeout: 5000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  const directory = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  await writeFile(path.join(directory, `${f.conversationId}.jsonl`), JSON.stringify({ type: "attachment", uuid: "previous-marker",
+    timestamp: "2026-10-16T00:00:00.000Z", attachment: { type: "goal_status", condition: "Finish the checks", met: action === "set", sentinel: false } }) + "\n");
+  const previous = await f.conversation.readGoal();
+  const attached = Promise.withResolvers();
+  f.behavior.beforeGoalAttachment = () => attached.promise;
+  let finished = false;
+  const updating = f.conversation.updateGoal({ action, objective: "Finish the checks", expectedGoalId: previous.id,
+    messageId: "delayed-goal", expectedSegmentId: `claude:${f.conversationId}` }).then(result => { finished = true; return result; });
+  while (!(await f.binding.transcript.hasMessage("delayed-goal"))) await delay(1);
+  await delay(20);
+  assert.equal(finished, false, "Admission must not return the previous goal as the command's result");
+  attached.resolve();
+  assert.equal((await updating).status, "accepted");
+  const current = await f.owner.readGoal(f.entry);
+  assert.equal(current.goalCommandId, claudeNativeMessageId("delayed-goal"));
+  assert.notEqual(current.goal.createdAt, Date.parse("2026-10-16T00:00:00.000Z") / 1000);
+  assert.equal(current.goal.status, "active");
+});
+
+test("Claude goal attachment timeout retains accepted delivery instead of returning an older goal", { timeout: 5000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  const attached = Promise.withResolvers();
+  f.behavior.beforeGoalAttachment = () => attached.promise;
+  await assert.rejects(f.owner.updateGoal(f.entry, { action: "set", objective: "Finish checks", messageId: "timeout-goal" },
+    { attachmentTimeoutMs: 10 }), { code: "assistant_claude_goal_attachment_pending", delivery: "accepted" });
+  attached.resolve();
+  await f.behavior.goalAttachmentWork;
+  assert.equal((await f.owner.readGoal(f.entry)).goalCommandId, claudeNativeMessageId("timeout-goal"));
+});
+
+test("Stop after Claude goal admission aborts attachment waiting without losing the accepted receipt", { timeout: 5000 }, async t => {
+  const controller = new AbortController();
+  const f = await suppliedCommonFixture(t, { tools: false, signal: controller.signal });
+  const attached = Promise.withResolvers();
+  f.behavior.beforeGoalAttachment = () => attached.promise;
+  const updating = f.conversation.updateGoal({ action: "set", objective: "Finish checks", messageId: "stopped-attaching-goal",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  const rejected = assert.rejects(updating, /abort|stopped/iu);
+  while (!(await f.binding.transcript.hasMessage("stopped-attaching-goal"))) await delay(1);
+  controller.abort(new Error("The goal was stopped"));
+  await rejected;
+  assert.equal(await f.binding.transcript.hasMessage("stopped-attaching-goal"), true);
+  attached.resolve();
+  await f.behavior.goalAttachmentWork;
+});
+
+test("Claude goal command proof survives only evaluations of its own condition", { timeout: 5000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  await f.conversation.updateGoal({ action: "set", objective: "Finish checks", messageId: "condition-proof",
+    expectedSegmentId: `claude:${f.conversationId}` });
+  const file = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"), `${f.conversationId}.jsonl`);
+  const append = condition => appendFile(file, JSON.stringify({ type: "attachment", timestamp: new Date().toISOString(),
+    attachment: { type: "goal_status", condition, met: false } }) + "\n");
+  await append("Finish checks");
+  assert.equal((await f.owner.readGoal(f.entry)).goalCommandId, claudeNativeMessageId("condition-proof"));
+  await append("A different condition");
+  const changed = await f.owner.readGoal(f.entry);
+  assert.equal(changed.goal.objective, "A different condition");
+  assert.equal(changed.goalCommandId, null, "an old command cannot prove a different goal");
+});
+
+for (const action of ["steer", "set", "resume"]) test(`Claude ${action} uses targeted Send now without cancelling background workers`, async t => {
+  const f = await publishedClaudeFixture(t);
+  if (action === "resume") await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish checks", messageId: "first" });
+  else await f.send("first");
+  await f.frame({ type: "system", subtype: "task_started", task_id: "live-worker" });
+  const native = f.entry.process;
+  const send = native.client.send;
+  native.client.supportsSendNow = () => true;
+  let stops = 0;
+  native.client.interrupt = async () => { stops++; throw Error("A steer must not send Stop"); };
+  native.client.send = async (message, input) => {
+    assert.equal(input.sendNow, true);
+    // Native 2.1.289 may end the foreground generation before consuming the
+    // queued goal. Its background task remains alive throughout this sequence.
+    await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
+    await f.frame({ type: "result", subtype: "error_during_execution", is_error: true,
+      terminal_reason: "aborted_tools", user_message_uuid: claudeNativeMessageId("first") });
+    assert.equal(f.entry.nativeTurn.read().active, true, "Old result cannot finish a queued input or its worker");
+    await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "started" });
+    await send(message, input);
+  };
+  if (action === "steer") await f.send("next");
+  else {
+    const goal = (await f.owner.readGoal(f.entry)).goal;
+    await f.owner.updateGoal(f.entry, { action, objective: "Finish checks", messageId: "next",
+      ...(action === "resume" ? { threadId: f.conversationId, createdAt: goal.createdAt } : {}) });
+    assert.equal((await f.owner.readGoal(f.entry)).goal.status, "active");
+  }
+  assert.equal(stops, 0);
+  assert.equal(f.processes.length, 1, "No process replacement");
+  await f.frame({ type: "result", subtype: "success", result: "New instruction accepted" });
+  assert.equal(f.entry.nativeTurn.read().active, true, "Retained worker still owns activity");
+  await f.frame({ type: "system", subtype: "task_notification", task_id: "live-worker", status: "completed" });
+  assert.equal(f.entry.nativeTurn.read().active, true, "The main model still needs to consume the worker result");
+  await f.frame({ type: "result", subtype: "success", result: "Worker result checked" });
+  assert.equal(f.entry.nativeTurn.read().active, false, "The main response settles the completed worker's turn");
+});
+
+test("Claude context inspection reuses the native owner and reports the selected model's current usage", async t => {
+  const f = await publishedClaudeFixture(t);
+  const requests = [];
+  let usage = { model: "claude-opus", totalTokens: 12345, maxTokens: 1000000, autoCompactThreshold: 967000 };
+  f.behavior.initialize = native => {
+    native.client.request = async request => {
+      requests.push(request);
+      return request.subtype === "get_context_usage" ? usage : {};
+    };
+  };
+  const first = await f.owner.readContextUsage(f.entry);
+  assert.deepEqual(first, { model: "claude-opus", usedTokens: 12345, windowTokens: 967000 });
+  usage = { model: "claude-haiku", totalTokens: 54321, maxTokens: 200000, autoCompactThreshold: 167000 };
+  assert.deepEqual(await f.owner.readContextUsage(f.entry), { model: "claude-haiku", usedTokens: 54321, windowTokens: 167000 });
+  assert.equal(f.processes.length, 1);
+  assert.equal(f.entry.turn, null);
+  assert.equal(f.messages.length, 0);
+  assert.equal(requests.filter(value => value.subtype === "get_context_usage").length, 2);
+});
+
+test("Claude context inspection refuses unavailable usage and honours cancellation before preparation", async t => {
+  const f = await publishedClaudeFixture(t);
+  const controller = new AbortController();
+  controller.abort(new Error("cancelled context inspection"));
+  await assert.rejects(f.owner.readContextUsage(f.entry, { signal: controller.signal }), /cancelled context inspection/);
+  assert.equal(f.processes.length, 0);
+  let usage;
+  f.behavior.initialize = native => { native.client.request = async request => request.subtype === "get_context_usage" ? usage : {}; };
+  for (const invalid of [undefined, {}, { totalTokens: -1, maxTokens: 200000 }, { totalTokens: "1", maxTokens: 200000 },
+    { totalTokens: 1, maxTokens: 0 }, { totalTokens: 1, maxTokens: 200000, autoCompactThreshold: -1 }]) {
+    usage = invalid;
+    await assert.rejects(f.owner.readContextUsage(f.entry), /context usage is unavailable/);
+  }
+  assert.equal(f.messages.length, 0);
+});
+
+
+test("bound Main history budget transfers more than 30 complete messages through the original Claude sender", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false, representation: "native" });
+  const history = Array.from({ length: 80 }, (_, index) => ({
+    id: `history-${index}`, version: `v${index}`, role: index % 2 ? "assistant" : "user", text: `${index}:` + "visible text ".repeat(200)
+  }));
+  f.binding.transcript.history = async () => history;
+  await f.binding.state.write({ lastEngine: "codex", engines: { codex: { seen: {} } } });
+  let reads = 0;
+  f.binding.maximumHistoryBytes = async ({ engineId, returning, context, signal, input }) => {
+    reads++;
+    assert.equal(engineId, "claude");
+    assert.equal(returning, false);
+    assert.equal(context.actor.id, "owner");
+    assert.equal(signal.aborted, false);
+    assert.equal(input.message, "Prepare the question.");
+    return 300_000;
+  };
+  const sent = [];
+  f.behavior.initialize = native => {
+    const send = native.client.send;
+    native.client.send = (message, ...args) => { sent.push(message); return send(message, ...args); };
+  };
+  await sendCommon(f, "full-history");
+  assert.equal(reads, 1);
+  assert.ok(sent[0].length > 128_000);
+  for (const message of history) assert.ok(sent[0].includes(JSON.stringify(message.text)), message.id);
+  await f.frame({ type: "result", subtype: "success", result: "Received." });
+  await f.conversation.wait();
+  await sendCommon(f, "ordinary-follow-up");
+  assert.equal(reads, 1, "Unchanged history must not prepare another budget lookup");
+  assert.equal(sent[1], "Prepare the question.");
+});
+
+test("bound Main cannot dispatch or retain a pending prompt when its history budget is unavailable", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false, representation: "native" });
+  f.binding.transcript.history = async () => [{ id: "earlier", version: "v1", role: "user", text: "Earlier work." }];
+  await f.binding.state.write({ lastEngine: "codex", engines: { codex: { seen: {} } } });
+  f.binding.maximumHistoryBytes = async () => { throw new Error("Current native context usage unavailable"); };
+  await assert.rejects(f.conversation.send({ messageId: "no-budget", text: "Continue" }), /Current native context usage unavailable/u);
+  assert.equal(f.processes.length, 0);
+  assert.equal(f.messages.length, 0);
+  assert.equal((await f.binding.state.read())?.engines?.claude?.pending, undefined);
+});
+
+
+for (const retention of [{ action: "pause", status: "paused" }, { action: "block", status: "blocked", reason: "The human must supply the approval code." }])
+for (const background of [false, true])
+test(`Claude common runtime saves a successful self-${retention.action} tool receipt and admits the next request, background=${background}`, { timeout: 5_000 }, async t => {
+  let effects = 0;
+  const f = await suppliedCommonFixture(t, { async executeTool() {
+    effects++;
+    const native = await f.runtime.open({ id: "lesson", context: f.toolContext, representation: "native" });
+    const goal = await native.readGoal();
+    const result = await native.updateGoal({ action: retention.action, reason: retention.reason, threadId: f.conversationId,
+      createdAt: goal.goal.createdAt, objective: goal.goal.objective });
+    assert.equal(result.goal.status, retention.status);
+    return {};
+  } });
+  const directory = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  await writeFile(path.join(directory, `${f.conversationId}.jsonl`), JSON.stringify({
+    type: "attachment", uuid: "common-self-pause-goal", timestamp: "2026-10-17T02:00:00.000Z",
+    attachment: { type: "goal_status", condition: "Finish the assigned checks", sentinel: true, met: false }
+  }) + "\n");
+  const original = await f.owner.readGoal(f.entry);
+  const receipt = await sendCommon(f, "common-self-pause");
+  await f.loadContract();
+  if (background) {
+    await f.frame({ type: "system", subtype: "task_started", task_id: "pause-worker" });
+    await f.frame({ type: "result", subtype: "success", result: "Waiting for the worker checkpoint." });
+    await f.frame({ type: "system", subtype: "background_tasks_changed", tasks: [] });
+    await f.frame({ type: "system", subtype: "task_updated", task_id: "pause-worker", patch: { status: "completed" } });
+    await new Promise(resolve => setImmediate(resolve));
+    await f.frame({ type: "system", subtype: "task_notification", task_id: "pause-worker", status: "completed" });
+    await f.frame({ type: "user", uuid: "pause-worker-notice", origin: { kind: "task-notification" } });
+    await f.loadContract("after-worker-contract");
+  }
+  const native = f.entry.process;
+  const input = { actionId: "lesson.inspect", version: 1, input: {} };
+  await f.frame({ type: "assistant", uuid: "self-pause-tool-use", message: { content: [
+    { type: "tool_use", id: "pause-self", name: "mcp__application__assistant_action_execute", input }
+  ] } });
+  const response = await native.options.onControlRequest({ subtype: "mcp_message", server_name: "application",
+    message: { jsonrpc: "2.0", id: "pause-self", method: "tools/call", params: {
+      name: "assistant_action_execute", arguments: input, _meta: { "claudecode/toolUseId": "pause-self" }
+    } }
+  }, { signal: new AbortController().signal });
+  assert.equal(JSON.parse(response.mcp_response.result.content[0].text).ok, true);
+  assert.equal(f.entry.process, native, "The returning native tool still owns its connection");
+  await f.frame({ type: "user", message: { content: [{ type: "tool_result", tool_use_id: "pause-self", is_error: false }] } });
+  await f.conversation.wait();
+  assert.equal(effects, 1);
+  const saved = await f.storage.read("lesson", transaction => transaction.readTurn(receipt.turnId));
+  const call = saved.metadata.applicationTools.find(call => call.id.endsWith("pause-self"));
+  assert.equal(call.status, "complete", "The native process stopping must not discard its tool receipt");
+  assert.equal(call.result.ok, true);
+  assert.equal(f.entry.process, null);
+  assert.equal(f.entry.command, null);
+  const retained = await f.owner.readGoal(f.entry);
+  assert.equal(retained.goal.status, retention.status);
+  assert.equal(retained.goal.createdAt, original.goal.createdAt);
+  assert.equal(retained.goal.objective, original.goal.objective);
+  const next = await sendCommon(f, "after-self-pause");
+  assert.equal(next.status, "accepted");
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, retention.status);
+  assert.deepEqual(f.behavior.nativeInputs.slice(-2), ["/goal clear", "Prepare the question."]);
+  assert.equal((await readClaudeHistory({ configRoot: f.context.workdir, workdir: f.context.workdir,
+    conversationId: f.conversationId })).goal, null, "The native checker is disarmed, not merely labelled paused");
+  await f.frame({ type: "result", subtype: "success", result: "Next request completed." });
+  await f.conversation.wait();
+});
+
+for (const retention of [{ action: "pause", status: "paused" }, { action: "block", status: "blocked", reason: "An approval code is required." }])
+for (const ending of ["receipt", "receipt timeout", "human Pause"])
+test(`Claude self-${retention.action} delivers its real control response before draining its process: ${ending}`, { timeout: 5_000 }, async t => {
+  const f = await claudeSuppliedToolFixture(t);
+  const delivered = Promise.withResolvers();
+  const wire = [];
+  let stream;
+  f.behavior.initialize = native => {
+    const original = native.client;
+    stream = new Duplex({ read() {}, write(chunk, _encoding, callback) {
+      const frame = JSON.parse(String(chunk));
+      wire.push(frame);
+      Promise.resolve().then(async () => {
+        if (frame.type === "user") await original.send(frame.message.content, { messageId: frame.uuid });
+        if (frame.type === "control_response") delivered.resolve(frame);
+        if (frame.type === "control_request") {
+          assert.ok(["interrupt", "apply_flag_settings", "set_model"].includes(frame.request.subtype));
+          this.push(JSON.stringify({ type: "control_response", response: { subtype: "success", request_id: frame.request_id } }) + "\n");
+          if (frame.request.subtype === "interrupt") this.push(JSON.stringify({ type: "result", subtype: "success", terminal_reason: "aborted_streaming" }) + "\n");
+        }
+      }).then(() => callback(), callback);
+    } });
+    native.client = createClaudeJsonClient({ stream, onEvent: native.options.onEvent, onControlRequest: native.options.onControlRequest,
+      onFailure: native.options.onFailure });
+    const stop = native.stop;
+    native.stop = async () => { native.client.close(); return stop(); };
+  };
+  const directory = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  await writeFile(path.join(directory, `${f.conversationId}.jsonl`), JSON.stringify({
+    type: "attachment", uuid: "self-pause-goal", timestamp: "2026-10-17T02:00:00.000Z",
+    attachment: { type: "goal_status", condition: "Finish the assigned checks", sentinel: true, met: false }
+  }) + "\n");
+  const original = await f.owner.readGoal(f.entry);
+  const effects = [];
+  f.tools.execute = async (_input, options) => {
+    assert.equal(options.messageId, "pause-at-checkpoint");
+    effects.push("pause");
+    const result = await f.owner.updateGoal(f.entry, {
+      action: retention.action, reason: retention.reason, threadId: f.conversationId,
+      createdAt: original.goal.createdAt, objective: original.goal.objective
+    });
+    effects.push("paused");
+    return { ok: true, status: result.goal.status };
+  };
+  const running = f.owner.run(f.control, f.command("pause-at-checkpoint"), f.options);
+  void running.catch(() => {});
+  while (!f.accepted.length) {
+    t.signal.throwIfAborted();
+    await new Promise(resolve => setImmediate(resolve));
+  }
+  await f.nativeTool("pause-self");
+  if (ending === "receipt timeout") t.mock.timers.enable({ apis: ["setTimeout"] });
+  const native = f.entry.process;
+  stream.push(JSON.stringify({ type: "control_request", request_id: "pause-control", request: {
+    subtype: "mcp_message", server_name: "application", message: { jsonrpc: "2.0", id: "pause-self", method: "tools/call",
+      params: { name: "inspect_lesson", arguments: { attemptId: "saved-attempt" }, _meta: { "claudecode/toolUseId": "pause-self" } } }
+  } }) + "\n");
+  const response = await delivered.promise;
+  assert.equal(response.response.subtype, "success");
+  assert.deepEqual(JSON.parse(response.response.response.mcp_response.result.content[0].text), { ok: true, status: retention.status });
+  assert.equal(f.entry.process, native, "A successful write alone is not the CLI's tool receipt");
+  assert.equal(wire.some(frame => frame.request?.subtype === "interrupt"), false, "No interrupt overtakes the tool response");
+  await f.frame({ type: "user", message: { content: [{ type: "tool_result", tool_use_id: "unrelated-tool" }] } });
+  assert.equal(f.entry.process, native);
+  await assert.rejects(f.call("pause-self"), /retired input/, "No more application effects after the retained stop");
+  if (ending === "receipt") {
+    stream.push(JSON.stringify({ type: "user", session_id: f.conversationId,
+      message: { content: [{ type: "tool_result", tool_use_id: "pause-self", is_error: false }] } }) + "\n");
+  } else if (ending === "human Pause") {
+    await f.owner.updateGoal(f.entry, { ...original.goal, action: "pause" });
+  } else t.mock.timers.tick(30_000);
+  await running;
+  if (ending === "receipt timeout") assert.match(f.entry.turn.error, /did not acknowledge its goal tool response/);
+  assert.deepEqual(effects, ["pause", "paused"]);
+  assert.equal(f.entry.process, null, "Pause proves native process cleanup before releasing its handle");
+  assert.equal(f.entry.command, null, "The enclosing tool/turn owner drains without a self-wait");
+  assert.equal(f.entry.turn.active, false);
+  const retained = await f.owner.readGoal(f.entry);
+  assert.equal(retained.goal.status, ending === "human Pause" ? "paused" : retention.status);
+  assert.equal(f.entry.goalToolStop, null);
+  assert.equal(retained.goal.createdAt, original.goal.createdAt);
+  assert.equal(retained.goal.objective, original.goal.objective);
+});
+
+
+for (const retention of [{ action: "pause", status: "paused" }, { action: "block", status: "blocked", reason: "A new human approval code is required." }])
+test(`Claude ${retention.action} survives ordinary messages and owner recreation; only Resume restores the goal`, { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish every check", messageId: "lifecycle-set" });
+  const original = (await f.owner.readGoal(f.entry)).goal;
+  await f.owner.updateGoal(f.entry, { ...original, action: retention.action, reason: retention.reason });
+  assert.equal(f.entry.process, null);
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, retention.status);
+  await f.send("ordinary-after-pause");
+  assert.deepEqual(f.behavior.nativeInputs.slice(-2), ["/goal clear", "Explain"]);
+  assert.equal((await readClaudeHistory({ configRoot: f.context.workdir, workdir: f.context.workdir, conversationId: f.conversationId })).goal, null);
+  assert.deepEqual((await f.owner.readGoal(f.entry)).goal, { ...original, status: retention.status, ...(retention.reason ? { reason: retention.reason } : {}) });
+  await f.frame({ type: "result", subtype: "success", result: "Ordinary answer" });
+  await f.owner.close(f.entry);
+  await f.reopen();
+  assert.deepEqual((await f.owner.readGoal(f.entry)).goal, { ...original, status: retention.status, ...(retention.reason ? { reason: retention.reason } : {}) });
+  f.behavior.clearWithoutGoalSentinel = true;
+  await f.send("ordinary-after-restart");
+  assert.deepEqual(f.behavior.nativeInputs.slice(-2), ["/goal clear", "Explain"]);
+  await f.frame({ type: "result", subtype: "success", result: "Still ordinary" });
+  await f.owner.updateGoal(f.entry, { action: "resume", ...original, messageId: "lifecycle-resume" });
+  assert.equal(f.entry.pausedGoal, null);
+  assert.equal(f.entry.blockedGoal, null);
+  const resumed = (await f.owner.readGoal(f.entry)).goal;
+  assert.equal(resumed.status, "active");
+  assert.equal(resumed.objective, original.objective);
+  await f.owner.updateGoal(f.entry, { action: "pause", ...resumed });
+  await f.owner.updateGoal(f.entry, { action: "cancel", ...resumed, messageId: "lifecycle-cancel" });
+  assert.equal((await f.owner.readGoal(f.entry)).goal, null);
+  assert.equal(f.entry.pausedGoal, null);
+  assert.equal(f.entry.blockedGoal, null);
+});
+
+
+test("Claude refuses ordinary input when the paused native goal could not be cleared, then permits a safe retry", { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish every check", messageId: "refused-set" });
+  const goal = (await f.owner.readGoal(f.entry)).goal;
+  await f.owner.updateGoal(f.entry, { action: "pause", ...goal });
+  f.behavior.initialize = native => {
+    native.client.send = async (message, input) => {
+      assert.equal(message, "/goal clear");
+      await native.options.onEvent({ type: "result", subtype: "error_during_execution", is_error: true,
+        local_command: "goal", user_message_uuid: input.messageId });
+    };
+  };
+  await assert.rejects(f.send("ordinary-refused"), error => error.delivery === "not-sent");
+  assert.equal(f.entry.process, null);
+  assert.deepEqual((await f.owner.readGoal(f.entry)).goal, { ...goal, status: "paused" });
+  f.behavior.initialize = null;
+  await f.send("ordinary-refused");
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "paused");
+  assert.deepEqual(f.behavior.nativeInputs.slice(-2), ["/goal clear", "Explain"]);
+  await f.frame({ type: "result", subtype: "success", result: "Ordinary retry" });
+});
+
+
+test("Pausing an idle Claude goal retires its warm process before the next ordinary message", { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish all checks", messageId: "idle-goal" });
+  await f.frame({ type: "result", subtype: "success", result: "Waiting for a prerequisite" });
+  const goal = (await f.owner.readGoal(f.entry)).goal;
+  assert.ok(f.entry.process);
+  assert.equal(f.entry.turn.active, false);
+  await f.owner.updateGoal(f.entry, { action: "pause", ...goal });
+  assert.equal(f.entry.process, null);
+  await f.send("ordinary-after-idle-pause");
+  assert.deepEqual(f.behavior.nativeInputs.slice(-2), ["/goal clear", "Explain"]);
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "paused");
+  await f.frame({ type: "result", subtype: "success", result: "Ordinary answer" });
+});
+
+
+test("Claude Block refuses absent reasons and stale identity before interrupting", { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish checks", messageId: "block-validation" });
+  const goal = (await f.owner.readGoal(f.entry)).goal;
+  const process = f.entry.process;
+  for (const input of [{ reason: "" }, { reason: "x".repeat(1001) }, { reason: "Missing code", createdAt: goal.createdAt + 1 }]) {
+    await assert.rejects(f.owner.updateGoal(f.entry, { ...goal, action: "block", ...input }), {
+      code: "conversation_invalid_goal", delivery: "not-sent"
+    });
+    assert.equal(f.entry.process, process);
+    assert.equal((await f.owner.readGoal(f.entry)).goal.status, "active");
+    assert.equal(f.entry.blockedGoal, null);
+  }
+});