@jskit-ai/assistant-core 0.2.7 → 0.2.8

package/test/apiConversationDriver.test.js

@@ -1,73 +1,252 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { checkTexts } from "@jskit-ai/agent/server";
 import { createApiConversationDriver } from "../src/server/conversation/providers/api.js";
 
+const CHECKS = checkTexts("the app");
 const frame = (delta, finish_reason) => `data: ${JSON.stringify({ choices: [{ index: 0, delta, finish_reason }] })}\n\n`;
 const schema = tool => ({ type: "function", function: { name: tool.name, parameters: tool.parameters } });
-function fixture({ response, execute, descriptors = [{ name: "action_execute", parameters: { type: "object" } }],
-  authorize = () => {}, limits } = {}) {
-  const requests = [], executions = [], messages = [];
+const lastText = body => body.messages.at(-1).content;
+
+// One step of a streamed reply: words, an action call or both. Calls the engine
+// makes without streaming (accounts, checks, summaries) answer with `once`.
+function fixture({ reply = () => ({ text: "Done." }), once = () => "Done.", execute, failure,
+  descriptors = [{ name: "action_execute", parameters: { type: "object" } }], authorize = () => {}, limits } = {}) {
+  const requests = [], streamed = [], executions = [], messages = [], order = [];
   let accepted = false;
   const driver = createApiConversationDriver({ limits, connections: { resolve: async () => {
     await authorize();
     return { providerId: "test", model: "exact-model", sdkPackage: "@ai-sdk/openai-compatible",
       apiKey: "test", baseURL: "http://test.invalid/v1" };
   } }, fetch: (_url, request) => {
-    requests.push(JSON.parse(request.body));
-    const value = response(requests.length);
-    return new Response(frame(value.call ? { tool_calls: [{ index: 0, id: `call_${requests.length}`,
-      function: { name: value.call, arguments: "{}" } }] } : { content: value.text }, value.call ? "tool_calls" : "stop"),
-    { headers: { "content-type": "text/event-stream" } });
+    const body = JSON.parse(request.body);
+    requests.push(body);
+    order.push("model");
+    if (failure) return failure(requests.length, request);
+    if (!body.stream) {
+      return Response.json({ choices: [{ index: 0, message: { role: "assistant", content: once(body) }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
+    }
+    streamed.push(body);
+    const value = reply(streamed.length, body, request);
+    if (value instanceof Promise) return value;
+    const call = value.call ? frame({ tool_calls: [{ index: 0, id: value.id || `call_${streamed.length}`,
+      function: { name: value.call, arguments: JSON.stringify(value.input || {}) } }] }, "tool_calls") : "";
+    return new Response((value.text ? frame({ content: value.text }, call ? undefined : "stop") : "") + call,
+      { headers: { "content-type": "text/event-stream" } });
   } });
-  return { requests, executions, messages, run: (text = "Complete the task.") => driver.run({
+  return { requests, streamed, executions, messages, order, run: (text = "Complete the task.", options = {}) => driver.run({
     configuration: { systemPrompt: "Use the supplied actions.", integrationId: "assistant" },
     context: { subjectId: "owner" }, input: { messageId: "request", text }, history: [],
-    signal: new AbortController().signal, beforeDispatch: async () => {}, accept: async () => { accepted = true; },
+    signal: new AbortController().signal, beforeDispatch: async () => {}, accept: async () => { accepted = true; order.push("accept"); },
     onMessage: async message => { messages.push(message); },
-    tools: { descriptors, schemas: descriptors.map(schema), maximumArgumentBytes: 32768,
+    tools: descriptors && { descriptors, schemas: descriptors.map(schema), maximumArgumentBytes: 32768,
       async execute(input) {
-        assert.equal(accepted, true, "Preflight and ordinary actions require prior admission");
+        assert.equal(accepted, true, "Actions require prior admission");
         executions.push(input);
         return execute?.(input, executions.length) ?? { ok: true, result: { sequence: executions.length } };
       }
-    }
+    },
+    ...options
   }) };
 }
 
-// Original assistant-runtime exhaustion assertions, using the actual API driver
-// and confirmed provider framing instead of its former private loop harness.
-test("the API owner preserves sixteen tool rounds and three recovery passes", async () => {
-  const f = fixture({ response: round => round <= 16 ? { call: "action_execute" } : { text: "Let me prepare the answer." } });
+test("each step streams as reply-N, a step with actions ends as commentary and the last step answers", async () => {
+  const f = fixture({ reply: round => round === 1 ? { text: "Checking the bookings.", call: "action_execute" } : { text: "You have 3 bookings." } });
+  const result = await f.run();
+  assert.deepEqual(f.messages.map(({ id, role, complete }) => [id, role, complete]), [
+    ["reply-1", "assistant", false], ["reply-1", "commentary", true], ["reply-2", "assistant", false], ["reply-2", "assistant", true]
+  ]);
+  // The answer leaves out the words already shown as commentary.
+  assert.equal(f.messages.at(-1).text, "You have 3 bookings.");
+  const quiet = fixture({ reply: round => round === 1 ? { text: "Checking the bookings.", call: "action_execute" } : { text: " " } });
+  await quiet.run();
+  assert.equal(quiet.messages.at(-1).text, "Checking the bookings.", "Commentary that is all there is stays the answer");
+  assert.equal(f.streamed[1].messages.find(message => message.role === "tool").content, JSON.stringify({ sequence: 1 }));
+  assert.deepEqual(result, { metadata: {} });
+});
+
+test("a step's words complete as commentary before any of its actions runs, and only once", async () => {
+  const shownBefore = [];
+  const f = fixture({ reply: round => round === 1 ? { text: "Checking the bookings.", call: "action_execute" } : { text: "You have 3 bookings." },
+    execute: () => { shownBefore.push(f.messages.map(({ id, role, text, complete }) => [id, role, text, complete]).at(-1)); } });
+  await f.run();
+  assert.deepEqual(shownBefore, [["reply-1", "commentary", "Checking the bookings.", true]]);
+  assert.deepEqual(f.messages.map(({ id, role, complete }) => [id, role, complete]), [
+    ["reply-1", "assistant", false], ["reply-1", "commentary", true], ["reply-2", "assistant", false], ["reply-2", "assistant", true]
+  ]);
+});
+
+test("a step's words past the progress or output limit fail the reply before any of its actions runs", async () => {
+  for (const [limits, error] of [
+    [{ maxApiToolProgressCharacters: 21 }, /Application tool progress text exceeds the configured API limit/],
+    [{ maxOutputCharacters: 21 }, /The assistant exceeded the configured response limit/]
+  ]) {
+    const f = fixture({ limits, reply: () => ({ text: "Checking the bookings.", call: "action_execute" }) });
+    await assert.rejects(f.run(), error);
+    assert.deepEqual(f.executions, [], "Nothing runs");
+    assert.equal(f.requests.length, 1, "Nothing else is asked of the model");
+  }
+  const bounded = fixture({ limits: { maxApiToolProgressCharacters: 22 },
+    reply: round => round === 1 ? { text: "Checking the bookings.", call: "action_execute" } : { text: "You have 3 bookings." } });
+  await bounded.run();
+  assert.equal(bounded.executions.length, 1, "Progress at its limit runs");
+});
+
+test("every action goes through the application receipt with a per-step id and its arguments", async () => {
+  const f = fixture({ reply: round => round < 3 ? { call: "action_execute", id: "call_0", input: { round } } : { text: "Both are saved." },
+    once: () => JSON.stringify({ unsupported: [] }) });
   await f.run();
-  assert.equal(f.executions.length, 16);
-  assert.equal(f.requests.length, 19);
-  assert.deepEqual(f.messages.filter(message => message.complete && message.role === "assistant").map(message => message.text),
-    ["Limit reached. Start a new conversation."]);
-  assert.equal(new Set(f.messages.filter(message => message.complete).map(message => message.id)).size, 4,
-    "Recovery commentary and the final answer retain independent identities");
-});
-
-test("clock preflight is admitted before execution and precedes model inference", async () => {
-  const descriptors = [{ name: "workspace_clock", parameters: { type: "object", properties: {} }, preflight: ["current-time"] }];
-  const f = fixture({ descriptors, response: () => ({ text: "It is Tuesday." }),
-    execute: () => ({ ok: true, result: { timeZone: "Australia/Perth" } }) });
+  assert.deepEqual(f.executions, [
+    { id: "reply-1:call_0", name: "action_execute", arguments: JSON.stringify({ round: 1 }) },
+    { id: "reply-2:call_0", name: "action_execute", arguments: JSON.stringify({ round: 2 }) }
+  ]);
+  const failed = fixture({ reply: round => round === 1 ? { call: "action_execute" } : { text: "It could not run." },
+    execute: () => ({ ok: false, error: { code: "action_failed", message: "Not allowed" } }) });
+  await failed.run();
+  assert.equal(failed.streamed[1].messages.find(message => message.role === "tool").content,
+    JSON.stringify({ error: { code: "action_failed", message: "Not allowed" } }), "A failed action reaches the model as its error");
+});
+
+test("admission precedes every model call, the state note gives the time, and a denied connection calls nothing", async () => {
+  const f = fixture();
   await f.run("What day is it today?");
-  assert.deepEqual(f.executions.map(call => call.name), ["workspace_clock"]);
-  assert.equal(f.requests[0].messages.some(message => message.role === "tool" && /Australia\/Perth/.test(message.content)), true);
-  const denied = fixture({ descriptors, authorize: () => { throw new Error("Connection access revoked"); } });
-  await assert.rejects(denied.run("What time is it now?"), /Connection access revoked/);
-  assert.deepEqual(denied.executions, []);
+  assert.deepEqual(f.order, ["accept", "model"]);
+  assert.deepEqual(f.executions, [], "No action runs before the model asks for one");
+  assert.match(f.requests[0].messages[0].content, /^Use the supplied actions\.\n\nCurrent state, from the system\. It is the truth; earlier messages may be out of date:\n- The time: .+ UTC\. The person may be in another time zone\.$/u);
+  const denied = fixture({ authorize: () => { throw new Error("Connection access revoked"); } });
+  await assert.rejects(denied.run(), /Connection access revoked/);
   assert.deepEqual(denied.requests, []);
-  const bounded = fixture({ descriptors, limits: { maxHistoryCharacters: 10 } });
-  await assert.rejects(bounded.run("What time is it now?"), /history limit/);
-  assert.deepEqual(bounded.executions, []);
+  let calls = 0;
+  const revoked = fixture({ authorize: () => { if (++calls > 1) throw new Error("Connection access revoked"); },
+    reply: () => ({ call: "action_execute" }) });
+  await assert.rejects(revoked.run(), /Connection access revoked/);
+  assert.equal(revoked.requests.length, 1, "Each later model call authorizes the connection again");
+  assert.equal(revoked.executions.length, 1);
 });
 
 test("unknown tool outcomes never enter ordinary failure recovery or request another action", async () => {
-  const f = fixture({ response: () => ({ call: "action_execute" }), execute: () => {
+  const f = fixture({ reply: () => ({ call: "action_execute" }), execute: () => {
     throw Object.assign(new Error("Inspect the interrupted action"), { code: "conversation_tool_outcome_unknown" });
   } });
   await assert.rejects(f.run(), { code: "conversation_tool_outcome_unknown" });
   assert.equal(f.executions.length, 1);
   assert.equal(f.requests.length, 1);
 });
+
+test("cancelling ends the reply with the signal's reason and no answer", async () => {
+  const controller = new AbortController();
+  const f = fixture({ reply: (_round, _body, request) => {
+    queueMicrotask(() => controller.abort(Object.assign(new Error("Stopped by the person"), { code: "stopped" })));
+    return new Promise((_resolve, reject) => request.signal.addEventListener("abort", () => reject(request.signal.reason), { once: true }));
+  } });
+  await assert.rejects(f.run("Work on it.", { signal: controller.signal }), { code: "stopped" });
+  assert.equal(f.requests.length, 1);
+  assert.equal(f.messages.some(message => message.complete), false);
+});
+
+test("raw markup in a reply carries on once, told that nothing in it ran", async () => {
+  const f = fixture({ reply: () => ({ text: "<invoke name=\"action_execute\"></invoke>" }) });
+  const result = await f.run();
+  assert.equal(f.streamed.length, 2, "The check sends the reply back once");
+  assert.equal(lastText(f.streamed[1]), CHECKS.markup);
+  assert.equal(f.messages.some(message => message.complete && message.role === "assistant"), false, "People never see the markup");
+  assert.equal(result.metadata.check, "markup");
+});
+
+test("a reply that stops at announcing its next step carries on once", async () => {
+  const f = fixture({ reply: round => ({ text: round === 1 ? "Let me check that." : "Here is the result: 3 bookings." }) });
+  await f.run();
+  assert.equal(f.streamed.length, 2);
+  assert.equal(lastText(f.streamed[1]), CHECKS.stoppedShort);
+  assert.equal(f.streamed[1].messages.some(message => message.content === "Let me check that."), false, "Its closing words are dropped");
+  assert.deepEqual(f.messages.filter(message => message.complete).map(message => [message.id, message.text]),
+    [["reply-2", "Here is the result: 3 bookings."]]);
+});
+
+test("a claim no action supports carries on once with what was claimed", async () => {
+  const f = fixture({ reply: round => round === 1 ? { text: "I've created the booking." } : round === 2 ? { call: "action_execute" } : { text: "The booking is in." },
+    once: body => body.messages[0].content.startsWith("You check an assistant's reply") ? JSON.stringify({ unsupported: ["I've created the booking"] }) : "" });
+  const result = await f.run();
+  assert.equal(f.requests.filter(body => !body.stream).length, 1, "One claim check");
+  assert.equal(lastText(f.streamed[1]), CHECKS.unsupported(["I've created the booking"]));
+  assert.equal(f.executions.length, 1);
+  assert.equal(f.messages.at(-1).text, "The booking is in.");
+  assert.equal(result.metadata.check, "unsupported");
+});
+
+test("at the step limit the reply ends with the engine's account of where it got to", async () => {
+  const account = "I looked twice and stopped there; say the word and I'll carry on.";
+  const f = fixture({ limits: { maxSteps: 2 }, reply: () => ({ call: "action_execute" }), once: () => account });
+  const result = await f.run();
+  assert.equal(f.executions.length, 2);
+  const [summing] = f.requests.filter(body => !body.stream);
+  assert.match(summing.messages[0].content, /^You are the assistant, a personal assistant bot\. You were working on the person's request but stopped early because I reached the most steps I take in one go\./u);
+  assert.deepEqual(f.messages.filter(message => message.complete && message.role === "assistant").map(message => [message.id, message.text]),
+    [["reply-3", account]]);
+  assert.deepEqual(result, { metadata: { unfinished: "I reached the most steps I take in one go" } });
+});
+
+test("the engine's own account ends the reply and is not sent back as stopping short", async () => {
+  // An empty answer to the account call leaves the engine's fallback account, which ends "…and I'll pick it up…".
+  const f = fixture({ limits: { maxSteps: 2 }, reply: () => ({ call: "action_execute" }), once: () => "" });
+  const result = await f.run();
+  assert.equal(f.executions.length, 2, "No second pass runs more actions after the step limit");
+  assert.equal(f.streamed.some(body => lastText(body) === CHECKS.stoppedShort), false);
+  const answers = f.messages.filter(message => message.complete && message.role === "assistant");
+  assert.equal(answers.length, 1);
+  assert.match(answers[0].text, /^I stopped before finishing, because I reached the most steps I take in one go\. Ask me to carry on/u);
+  assert.deepEqual(result, { metadata: { unfinished: "I reached the most steps I take in one go" } });
+});
+
+test("a provider failure before anything was done is the reply's error, after the engine's retries", async () => {
+  const f = fixture({ failure: () => new Response('{"error":{"message":"Capacity unavailable"}}',
+    { status: 429, headers: { "content-type": "application/json", "retry-after-ms": "0" } }) });
+  await assert.rejects(f.run(), /Capacity unavailable/);
+  assert.equal(f.requests.length, 7, "Six retries, then the error");
+  assert.equal(f.messages.length, 0);
+});
+
+test("a long history is compacted: the summary and its last turn are saved, and only later turns are read", async () => {
+  const turns = Array.from({ length: 6 }, (_, index) => ({ turnId: String(index + 1).padStart(6, "0"),
+    user: { role: "user", messageId: `m${index}`, text: `Question ${index} ${"x".repeat(4000)}` },
+    assistant: { role: "assistant", text: `Answer ${index}` }, messages: [] }));
+  const saved = [], phases = [];
+  const f = fixture({ descriptors: null, limits: { contextTokens: 10_000 }, once: () => "The person asked six long questions." });
+  await f.run("Next question", { history: turns, summary: "Earlier: hello.",
+    saveSummary: async value => { saved.push(value); }, onEvent: async event => { phases.push(event.phase); } });
+  assert.equal(saved.length, 1);
+  assert.equal(saved[0].text, "The person asked six long questions.");
+  const summarizing = f.requests.find(body => !body.stream);
+  assert.match(summarizing.messages.at(-1).content, /The summary so far, of everything before the messages below:\n<<summary>>\nEarlier: hello\./u);
+  const kept = turns.slice(turns.findIndex(turn => turn.turnId === saved[0].throughTurnId) + 1);
+  assert.ok(kept.length > 0 && kept.length < turns.length);
+  const [request] = f.streamed;
+  assert.match(request.messages[0].content, /Summary of the earlier part of this conversation[^]*The person asked six long questions\./u);
+  assert.deepEqual(request.messages.filter(message => message.role === "user").map(message => message.content),
+    [...kept.map(turn => turn.user.text), "Next question"]);
+  assert.deepEqual(phases, ["compacting", "working"]);
+});
+
+test("history replays each recorded action under the provider's own call id", async () => {
+  const f = fixture({ descriptors: null });
+  const call = { id: "reply-2:toolu_01", name: "action_execute", arguments: JSON.stringify({ day: "today" }),
+    result: { ok: true, result: { bookings: 3 } } };
+  await f.run("And tomorrow?", { history: [{ turnId: "000001", user: { role: "user", messageId: "m1", text: "Bookings today?" },
+    assistant: { role: "assistant", text: "You have 3." }, metadata: { applicationTools: [call] }, messages: [] }] });
+  const [request] = f.requests;
+  assert.deepEqual(request.messages.filter(message => message.tool_calls).flatMap(message => message.tool_calls.map(({ id }) => id)), ["toolu_01"]);
+  assert.deepEqual(request.messages.filter(message => message.role === "tool").map(message => [message.tool_call_id, message.content]),
+    [["toolu_01", JSON.stringify({ bookings: 3 })]]);
+});
+
+test("a short history is read whole with its stored summary, and nothing is saved", async () => {
+  const saved = [];
+  const f = fixture({ descriptors: null });
+  await f.run("Next question", { summary: "Earlier: hello.", saveSummary: async value => { saved.push(value); },
+    history: [{ turnId: "000003", user: { role: "user", messageId: "m3", text: "Hi" }, assistant: { role: "assistant", text: "Hello" }, messages: [] }] });
+  assert.deepEqual(saved, []);
+  assert.equal(f.requests.length, 1);
+  assert.match(f.requests[0].messages[0].content, /Summary of the earlier part of this conversation[^]*Earlier: hello\./u);
+  assert.deepEqual(f.requests[0].messages.slice(1).map(message => message.content), ["Hi", "Hello", "Next question"]);
+});

package/test/assistantBoundedToolLoop.test.js

@@ -25,7 +25,7 @@ function boundedTools(execute) {
   const actions = createActionCatalogue();
   actions.register({ contributorId: "bounded.tools", domain: "bounded", actions: [{
     id: "bounded.read", version: 1, kind: "query", channels: ["automation"], surfaces: ["app"],
-    permission: { require: "none" }, idempotency: "none",
+    permission: { require: "none" },
     input: { schema: createSchema({ value: { type: "string", enum: ["1", "2", "3", "4"], required: true } }), mode: "replace" },
     output: { schema: createSchema({ prompt: { type: "string", required: true } }), mode: "replace" },
     execute({ value }, context) { return execute({ value: Number(value) }, context); }

package/test/claudeConversationSession.test.js

@@ -222,8 +222,8 @@ test("native replacement saves preparation before close and retries the same ine
   assert.equal(successor.binding.sent, false);
   assert.equal(successor.binding.executionId, "");
   assert.equal(nativeIds.size, 1, "Opening a successor handle must not start a native process");
-  await assert.rejects(f.conversation.send({ messageId: "early", text: "Too early" }), { code: "conversation_replacement_pending" });
-  await assert.rejects(f.conversation.replace({ ...operation, briefing: "Changed" }), { code: "conversation_replacement_pending" });
+  await assert.rejects(f.conversation.send({ messageId: "early", text: "Too early" }), { code: "conversation_replacement_pending_before_send" });
+  await assert.rejects(f.conversation.replace({ ...operation, briefing: "Changed" }), { code: "conversation_replacement_unfinished" });
   await f.first.close();
   failCommit = false;
   const resumed = await f.runtime().open({ id: "conversation" });
@@ -686,7 +686,7 @@ function applicationActions(execute) {
   const actions = createActionCatalogue();
   actions.register({ contributorId: "test.tools", domain: "numbers", actions: [{
     id: "numbers.read", version: 1, kind: "query", channels: ["automation"], surfaces: ["app"],
-    permission: { require: "all", permissions: ["numbers.read"] }, idempotency: "none",
+    permission: { require: "all", permissions: ["numbers.read"] },
     input: { schema: createSchema({}), mode: "replace" },
     output: { schema: createSchema({ value: { type: "number", required: true } }), mode: "replace" }, execute
   }] });
@@ -1177,7 +1177,7 @@ test("Claude native goal commands use ordinary admission, pause retains the goal
   const goal = await f.conversation.readGoal();
   assert.equal(goal.status, "active");
   assert.equal((await f.conversation.updateGoal(start)).duplicate, true);
-  await assert.rejects(f.conversation.updateGoal({ ...start, objective: "Different" }), { code: "conversation_message_conflict" });
+  await assert.rejects(f.conversation.updateGoal({ ...start, objective: "Different" }), { code: "conversation_message_id_content_conflict" });
   const action = { expectedSegmentId: segmentId, expectedGoalId: goal.id };
   await assert.rejects(f.conversation.updateGoal({ ...action, action: "pause", expectedGoalId: "old-goal" }), /goal changed/u);
   await assert.rejects(f.conversation.updateGoal({ ...action, action: "cancel" }), /messageId/u);
@@ -1245,7 +1245,7 @@ test("Claude rejects reserved goals and waits for ordinary Send to deliver a rep
   await f.conversation.replace({ operationId: "renew-goal", reason: "renewal", expectedSegmentId: state.segmentId });
   state = await f.conversation.read();
   const goal = { action: "set", objective: "Tests pass", messageId: "goal-after-renewal", expectedSegmentId: state.segmentId };
-  await assert.rejects(f.conversation.updateGoal(goal), { code: "conversation_replacement_briefing_pending" });
+  await assert.rejects(f.conversation.updateGoal(goal), { code: "conversation_briefing_before_goal" });
   await f.conversation.wait();
   assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1);
   await f.conversation.send({ messageId: "catch-up", text: "Continue" });
@@ -2374,7 +2374,7 @@ test("completed Claude native-tool tracking propagates its receipt write failure
     assert.equal(saved.metadata.runtime.nativeToolAttempt, false);
     assert.equal(attempts, 1, "The awaited native callback does not swallow or repeat a failed receipt write");
     await assert.rejects(f.prepare({ messageId: receipt.messageId, turnId: receipt.turnId }),
-      error => error.code === "conversation_completed_response_unavailable");
+      error => error.code === "conversation_completed_response_no_receipt");
     assert.equal(f.effects(), 0);
   } finally { await f.close(); }
 });
@@ -2448,7 +2448,7 @@ test("completed Claude wake exclusions retain all product fingerprints only afte
     const state = await f.conversation.wait();
     assert.equal(state.status, "ready");
     assert.deepEqual(state.conversationLog.map(turn => turn.user.messageId), ["batch-a", "batch-b"]);
-    const { claudeNativeMessageId } = await import("../src/server/conversation/claudeTurn.js");
+    const { claudeNativeMessageId } = await import("../src/server/conversation/claudeHistory.js");
     const nativeMessageId = claudeNativeMessageId(receipt.messageId);
     const frames = (await f.trace()).filter(row => row.frame?.type === "user" && row.frame.uuid === nativeMessageId);
     assert.equal(frames.length, 1, "The original Claude ID mapper identifies exactly one actual admitted native input");
@@ -2489,7 +2489,7 @@ test("completed Claude retained wake exclusions cannot change on a same-ID retry
     assert.deepEqual(retained.runtime.request.seen, before.runtime.request.seen);
     assert.equal(retained.runtime.request.message, before.runtime.request.message);
     await assert.rejects(f.conversation.wake({ messageId: "lost-exclusions", text: "lost" }, options),
-      error => error.code === "conversation_message_conflict");
+      error => error.code === "conversation_message_id_exclusions_conflict");
     assert.deepEqual((await f.storage.read("conversation", tx => tx.readMetadata())).runtime.request, retained.runtime.request);
     assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1);
     await assert.rejects(f.conversation.wake({ messageId: "different-exclusions", text: "Read a number" }, { excludedMessageIds: ["batch-a"] }),
@@ -2503,7 +2503,7 @@ test("completed Claude retained wake exclusions cannot change on a same-ID retry
     });
     const old = await f.storage.read("conversation", tx => tx.readMetadata());
     await assert.rejects(f.conversation.wake({ messageId: "old-exclusions", text: "Read a number" }, { excludedMessageIds: ["batch-a"] }),
-      error => error.code === "conversation_message_conflict");
+      error => error.code === "conversation_message_id_exclusions_conflict");
     assert.deepEqual((await f.storage.read("conversation", tx => tx.readMetadata())).runtime.request, old.runtime.request);
     assert.equal(f.effects(), 0);
   } finally { await f.close(); }
@@ -2661,8 +2661,12 @@ test("completed Claude prepared reply refuses foreign targets, existing finals a
     });
     const prepared = await f.prepare(receipt);
     const before = await f.storage.read("conversation", tx => tx.readMetadata());
-    for (const turnId of ["missing", receipt.turnId, populated.turnId, consumed.turnId, owned.turnId]) {
-      await assert.rejects(prepared.publishReply({ turnId }), error => error.code === "conversation_tool_receipt_conflict");
+    for (const [turnId, code] of [
+      ["missing", "conversation_completed_reply_no_target"], [receipt.turnId, "conversation_completed_reply_no_target"],
+      [populated.turnId, "conversation_reply_target_used"], [consumed.turnId, "conversation_reply_target_used"],
+      [owned.turnId, "conversation_completed_reply_no_target"]
+    ]) {
+      await assert.rejects(prepared.publishReply({ turnId }), error => error.code === code);
     }
     assert.equal((await f.storage.read("conversation", tx => tx.readTurn(populated.turnId))).assistant.text, "Unassociated final");
     assert.equal((await f.storage.read("conversation", tx => tx.readTurn(consumed.turnId))).assistant, null);

package/test/claudeInstructionResume.test.js

@@ -7,7 +7,7 @@ import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 import test from "node:test";
-import { createClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
+import { createClaudeConversationTurn } from "../src/server/conversation/claudeNativeTurn.js";
 
 const execute = promisify(execFile);
 

package/test/claudeProcess.test.js

@@ -46,7 +46,7 @@ async function fixture(t, body) {
   t.after(() => rm(directory, { recursive: true, force: true }));
   const command = join(directory, "claude-fixture.mjs");
   await writeFile(command, `#!${process.execPath}\n${body}`, { mode: 0o700 });
-  return { command, workdir: directory };
+  return { command, workdir: directory, env: process.env };
 }
 
 test("standalone Claude startup uses the supplied execution host and carries its native protocol", { skip: process.platform === "win32" }, async (t) => {
@@ -122,7 +122,7 @@ test("Claude model configuration maps background calls and resets external setti
 });
 
 test("Claude status reads native JSON and returns only public account details", async () => {
-  const status = await readClaudeCodeAuthStatus({ credentialHome: { home: "/home/fixture-json" }, commandRunner: async (input) => {
+  const status = await readClaudeCodeAuthStatus({ env: process.env, credentialHome: { home: "/home/fixture-json" }, commandRunner: async (input) => {
     assert.deepEqual(input.args, ["auth", "status", "--json"]);
     assert.equal(input.timeout, 30_000);
     assert.equal(input.credentialHome.home, "/home/fixture-json");
@@ -137,7 +137,7 @@ test("Claude signed-out JSON is normal while failed and malformed status respons
   // Reads of one account share an entry, so each response gets its own account.
   let account = 0;
   const readStatus = (result) => readClaudeCodeAuthStatus({
-    credentialHome: { home: `/home/fixture-signed-out-${account += 1}` }, commandRunner: async () => result
+    env: process.env, credentialHome: { home: `/home/fixture-signed-out-${account += 1}` }, commandRunner: async () => result
   });
   const signedOut = { ok: false, exitCode: 1, stdout: JSON.stringify({ loggedIn: false, authMethod: "none" }) };
   assert.deepEqual(await readStatus(signedOut), {
@@ -322,7 +322,7 @@ test("Claude preserves the execution host's failed-start identity and cleanup pr
       async start() { throw failure; },
       async stop() { stops += 1; return { scopeEmpty: true }; }
     };
-    await assert.rejects(createClaudeCodeProcess({ execution }), error => {
+    await assert.rejects(createClaudeCodeProcess({ execution, env: process.env }), error => {
       assert.equal(error, failure);
       assert.equal(error.executionId, "admitted-execution");
       assert.equal(error.stopProof, stopProof);
@@ -380,7 +380,7 @@ test("Claude observes parent exit after initialization even while a child retain
     done();
   } });
   let failures = 0;
-  const native = await createClaudeCodeProcess({ execution: {
+  const native = await createClaudeCodeProcess({ env: process.env, execution: {
     async start() { return { id: "parent-exit", stdin, stdout, exited: exited.promise }; },
     async stop() { return { scopeEmpty: true }; }
   }, onFailure(error) { failures++; failed.resolve(error); } });
@@ -405,7 +405,7 @@ test("Claude reports a task-limit exit that arrives after its stream ended", { t
     stdout.write(JSON.stringify({ type: "control_response", response: { subtype: "success", request_id: frame.request_id, response: {} } }) + "\n");
     done();
   } });
-  const native = await createClaudeCodeProcess({ execution: {
+  const native = await createClaudeCodeProcess({ env: process.env, execution: {
     async start() { return { id: "task-limit", stdin, stdout, exited: exited.promise }; },
     async stop() { return { scopeEmpty: true }; }
   }, onFailure(error) { failed.resolve(error); } });
@@ -429,7 +429,7 @@ test("Claude host startup budget allows slow initialization and still bounds fai
       requested.resolve(JSON.parse(chunk.toString())); done();
     } });
     const stops = [];
-    const pending = createClaudeCodeProcess({ initializationTimeoutMs: 90_000, execution: {
+    const pending = createClaudeCodeProcess({ env: process.env, initializationTimeoutMs: 90_000, execution: {
       async start() { return { id: "cold-start", stdin, stdout }; },
       async stop(id) { stops.push(id); return { scopeEmpty: true }; }
     } });
@@ -475,7 +475,7 @@ test("Claude initialization rejects confirmed execution exit before half-open pr
         return { scopeEmpty: cleanup === "verified" };
       }
     };
-    const pending = createClaudeCodeProcess({ execution });
+    const pending = createClaudeCodeProcess({ execution, env: process.env });
     let failure;
     void pending.catch(error => { failure = error; });
     try {
@@ -509,7 +509,7 @@ test("Claude initialization preserves rejected execution observation and exact c
   const stdin = new Writable({ write(_chunk, _encoding, done) { requested.resolve(); done(); } });
   const failure = new Error("Execution observation failed");
   const stops = [];
-  const pending = createClaudeCodeProcess({ execution: {
+  const pending = createClaudeCodeProcess({ env: process.env, execution: {
     async start() { return { id: "observed-startup", stdin, stdout, exited: exited.promise }; },
     async stop(id) { stops.push(id); return { scopeEmpty: true }; }
   } });

package/test/claudeTurn.test.js

@@ -3,9 +3,9 @@ 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";
+import { runClaudeRenewalTurn, waitForClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
+import { createClaudeConversationTurn } from "../src/server/conversation/claudeNativeTurn.js";
+import { claudeNativeMessageId, readClaudeHistory } from "../src/server/conversation/claudeHistory.js";
 
 function fixture() {
   const events = [];
@@ -664,6 +664,19 @@ test("renewal refuses changed or unrelated successor history before native work
   assert.match(f.events.at(-1)[1], /will not be submitted again/);
 });
 
+test("a refusal hands the caller's createError its message and its own code", async () => {
+  const createError = (message, { code }) => Object.assign(new Error(message), { code, builtByCaller: true });
+  const f = renewalFixture();
+  await assert.rejects(runClaudeRenewalTurn(f.conversation, { ...f.input, expectedThreadId: "different" }, { createError }),
+    { message: /expected native history/, code: "conversation_claude_renewal_history_mismatch", builtByCaller: true });
+  f.history.userIds.push("unrelated");
+  await assert.rejects(runClaudeRenewalTurn(f.conversation, { ...f.input, requireFreshHistory: true }, { createError }),
+    { message: /unrelated messages/, code: "conversation_claude_renewal_unrelated_history", builtByCaller: true });
+  const state = { process: {}, turn: { active: true }, completion: Promise.withResolvers() };
+  await assert.rejects(waitForClaudeConversationTurn({ state, async interrupt() {} }, {}, { defaultTimeoutMs: 5, createError }),
+    { message: /within the time limit/, code: "conversation_claude_turn_timeout", builtByCaller: true });
+});
+
 test("renewal dispatches once with the original schema and waits before confirmed cleanup", async () => {
   const f = renewalFixture();
   const outputSchema = { type: "object" };
@@ -1451,7 +1464,7 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, hostDe
   const actions = createActionCatalogue();
   actions.register({ contributorId: "lesson", domain: "lesson", actions: [{
     id: "lesson.inspect", version: 1, kind: "query", channels: ["automation"], surfaces: ["app"],
-    permission: { require: "authenticated" }, idempotency: "none",
+    permission: { require: "authenticated" },
     input: { schema: createSchema({}), mode: "replace" },
     output: { schema: createSchema({}), mode: "replace" }, execute: executeTool
   }] });
@@ -1618,7 +1631,7 @@ for (const tools of [true, false]) test(`Claude supplied common runtime checkpoi
   assert.equal(typeof f.entry.command.finishIfCurrent, "function");
   if (tools) {
     await f.loadContract();
-    assert.throws(() => f.admissions.at(-1).assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+    assert.throws(() => f.admissions.at(-1).assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" });
   } else assert.equal(f.entry.command.tools, undefined);
   await f.frame({ type: "result", subtype: "success", result: "Where would you try the application?", uuid: "question-final" });
   await f.conversation.wait();
@@ -1655,7 +1668,7 @@ for (const worker of [false, true]) test(`Claude supplied common completion join
     await new Promise(resolve => setImmediate(resolve));
   }
   await f.loadContract("successor-contract");
-  assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+  assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" });
   await f.frame({ type: "result", subtype: "success", result: "The successor question", uuid: "successor-final" });
   if (worker) {
     assert.equal(f.checkpoints.length, 0, "Foreground completion cannot checkpoint live background work");
@@ -1668,7 +1681,7 @@ for (const worker of [false, true]) test(`Claude supplied common completion join
   assert.equal(f.checkpoints.length, 1);
   assert.equal(f.checkpoints[0].final.inputMessageId, claudeNativeMessageId("common-successor"));
   assert.equal(f.checkpoints[0].admission.messageId, "common-successor");
-  assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+  assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" });
 });
 
 for (const preceding of [null, "task_updated", "background_tasks_changed"])
@@ -1741,7 +1754,7 @@ for (const cancelled of [false, true]) test(`Claude supplied native settlement r
     assert.equal(f.entry.nativeTurn.read().active, false);
     assert.equal(f.entry.turn.active, true);
     assert.equal(f.checkpoints.length, 0, "Native queue does not await the reserved common admission");
-    assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+    assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" });
     if (cancelled) cancellation = f.conversation.cancel();
   } finally { held.resolve(); }
   await cancellation;

package/test/codexAccountChange.test.js

@@ -4,9 +4,11 @@ import { mkdir, mkdtemp, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { CodexAppServerAgentProvider, ensureCodexAppServerThread } from "../src/server/conversation/codexProvider.js";
+import { CodexAppServerAgentProvider } from "../src/server/conversation/codexProvider.js";
+import { ensureCodexAppServerThread } from "../src/server/conversation/codexProviderThreads.js";
 import { writeCodexAppServerMetadata } from "../src/server/conversation/codexProcess.js";
-import { createCodexAppServerProviderOwner, codexAppServerOwnedRuntimeKey, releaseSupersededCodexRuntime } from "../src/server/conversation/codexProviderOwner.js";
+import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
+import { codexAppServerOwnedRuntimeKey, releaseSupersededCodexRuntime } from "../src/server/conversation/codexRuntimeInventory.js";
 import { createCodexProviderSelection } from "../src/server/conversation/codexProviderSelection.js";
 import { createCodexRuntimeLifecycle } from "../src/server/conversation/codexRuntimeLifecycle.js";
 
@@ -261,7 +263,7 @@ test("recording a session's runtime for a new sign-in removes the previous sign-
   const running = await runtimeDirectory(root, "running", "running");
   const bind = superseded => ensureCodexAppServerThread({
     observeThread: async () => {},
-    provider: { ensureRuntime: async () => ({ runtimeDir: path.join(root, "codex-app-server-current") }),
+    provider: { ensureAvailable: async () => ({}), ensureRuntime: async () => ({ runtimeDir: path.join(root, "codex-app-server-current") }),
       startThread: async () => ({ id: "thread-1" }) },
     settings: async () => ({ threadSettings: {}, threadStartSettings: {} }),
     identity: { read: () => "", write: async () => ({ supersededRuntimeDir: superseded }) },