@jskit-ai/assistant-core 0.2.7 → 0.2.8

package/test/conversationReplacement.test.js

@@ -71,7 +71,7 @@ test("renewal preserves logical history and receipts while subsequent inference
   const retry = await f.conversation.replace(operation);
   assert.equal(retry.duplicate, true);
   assert.equal(retry.segmentId, result.segmentId);
-  await assert.rejects(f.conversation.replace({ ...operation, briefing: "Different" }), { code: "conversation_replacement_conflict" });
+  await assert.rejects(f.conversation.replace({ ...operation, briefing: "Different" }), { code: "conversation_replacement_operation_conflict" });
 });
 
 test("completed historical branch markers retain history filtering and admission receipts", async t => {
@@ -105,8 +105,8 @@ test("unfinished historical Undo operations require offline inspection without c
     saved.runtime.replacement = { request: { ...operation, operation: "replace" }, reason: "renewal", engine: "api",
       configuration, segmentId: "historical-successor", seen: {}, ...patch };
     await f.storage.write("one", transaction => transaction.writeMetadata(saved));
-    await assert.rejects(f.conversation.replace(operation), { code: "conversation_rewind_inspection_required" });
-    await assert.rejects(f.runtime().open({ id: "one" }), { code: "conversation_rewind_inspection_required" });
+    await assert.rejects(f.conversation.replace(operation), { code: "conversation_rewind_inspection_before_replace" });
+    await assert.rejects(f.runtime().open({ id: "one" }), { code: "conversation_rewind_inspection_before_open" });
     assert.deepEqual(await f.storage.read("one", transaction => transaction.readMetadata()), saved);
     assert.equal((await f.conversation.read()).conversationLog.length, 1);
     assert.equal(f.requests.length, 1);
@@ -120,8 +120,8 @@ test("an interrupted replacement blocks sending and resumes exactly once after a
   f.state.failCommit = true;
   await assert.rejects(f.conversation.replace(operation), /Storage offline/);
   assert.equal((await f.conversation.read()).status, "replacement-pending");
-  await assert.rejects(f.conversation.send({ text: "Too early", messageId: "early" }), { code: "conversation_replacement_pending" });
-  await assert.rejects(f.conversation.configure({ systemPrompt: "Too early" }), { code: "conversation_replacement_pending" });
+  await assert.rejects(f.conversation.send({ text: "Too early", messageId: "early" }), { code: "conversation_replacement_pending_before_send" });
+  await assert.rejects(f.conversation.configure({ systemPrompt: "Too early" }), { code: "conversation_replacement_pending_before_settings" });
   await f.first.close();
   f.state.failCommit = false;
   const resumed = await f.runtime().open({ id: "one" });
@@ -137,11 +137,11 @@ test("an interrupted replacement blocks sending and resumes exactly once after a
 test("invalid, stale and forbidden replacement requests do not alter the conversation", async t => {
   const f = await fixture(t);
   const operation = await f.replacement();
-  await assert.rejects(f.conversation.replace({ ...operation, expectedSegmentId: "stale" }), { code: "conversation_replacement_conflict" });
-  await assert.rejects(f.conversation.replace({ ...operation, reason: "rewind" }), { code: "conversation_invalid_replacement" });
-  await assert.rejects(f.conversation.replace({ ...operation, reason: "rewind", throughTurnId: "missing" }), { code: "conversation_invalid_replacement" });
-  await assert.rejects(f.conversation.replace({ ...operation, reason: "rewind", throughTurnId: null }), { code: "conversation_invalid_replacement" });
-  await assert.rejects(f.conversation.replace({ ...operation, throughTurnId: null }), { code: "conversation_invalid_replacement" });
+  await assert.rejects(f.conversation.replace({ ...operation, expectedSegmentId: "stale" }), { code: "conversation_predecessor_changed" });
+  await assert.rejects(f.conversation.replace({ ...operation, reason: "rewind" }), { code: "conversation_replacement_request_invalid" });
+  await assert.rejects(f.conversation.replace({ ...operation, reason: "rewind", throughTurnId: "missing" }), { code: "conversation_replacement_request_invalid" });
+  await assert.rejects(f.conversation.replace({ ...operation, reason: "rewind", throughTurnId: null }), { code: "conversation_replacement_request_invalid" });
+  await assert.rejects(f.conversation.replace({ ...operation, throughTurnId: null }), { code: "conversation_replacement_request_invalid" });
   await assert.rejects(f.conversation.replace({ ...operation, engine: "missing" }), /does not yet support/);
   f.state.allowed = false;
   await assert.rejects(f.conversation.replace(operation), { code: "conversation_forbidden" });
@@ -167,7 +167,7 @@ test("host scope belongs to a conversation and cannot be changed through another
   const host = { workdir: "/application/one", env: { HOME: "/accounts/one" } };
   const one = await f.first.open({ id: "scoped-one", host, configuration });
   const two = await f.first.open({ id: "scoped-two", host: { workdir: "/application/two" }, configuration });
-  await assert.rejects(f.first.open({ id: "scoped-one", host: { workdir: "/application/other" } }), { code: "conversation_host_mismatch" });
+  await assert.rejects(f.first.open({ id: "scoped-one", host: { workdir: "/application/other" } }), { code: "conversation_host_scope_mismatch" });
   await one.send({ messageId: "one", text: "One" });
   await two.send({ messageId: "two", text: "Two" });
   assert.equal((await one.wait()).conversationLog.length, 1);
@@ -196,7 +196,7 @@ test("interrupted OpenCode integration selection retries the original fresh bind
   assert.notEqual(pending.runtime.replacement.binding.directory, metadata.runtime.binding.directory);
   assert.equal((await f.conversation.read()).status, "replacement-pending");
   await assert.rejects(f.conversation.send({ messageId: "premature", text: "Too early" }),
-    { code: "conversation_replacement_pending" });
+    { code: "conversation_replacement_pending_before_send" });
   await f.first.close();
   f.state.failCommit = false;
   const reopened = await f.runtime().open({ id: "one" });
@@ -230,7 +230,7 @@ test("interrupted fresh native selection retains its consumer policy and success
   assert.notEqual(pending.runtime.replacement.binding.directory, original.runtime.binding.directory);
   assert.equal((await f.conversation.read()).status, "replacement-pending");
   await assert.rejects(f.conversation.send({ messageId: "too-early", text: "Wait for the change" }),
-    { code: "conversation_replacement_pending" });
+    { code: "conversation_replacement_pending_before_send" });
   await f.first.close();
   f.state.failCommit = false;
   const reopened = await f.runtime().open({ id: "one" });

package/test/conversationRuntime.test.js

@@ -4,7 +4,7 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { createConversationHookBridge, createConversationRuntime } from "../src/server/conversation/index.js";
-import { createClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
+import { createClaudeConversationTurn } from "../src/server/conversation/claudeNativeTurn.js";
 import { createCodexConversationAdapter } from "../src/server/conversation/providers/codex.js";
 import { createOpenCodeConversationAdapter } from "../src/server/conversation/providers/opencode.js";
 import { readPersistentConversation } from "../src/server/conversation/providers/scoped.js";
@@ -97,7 +97,7 @@ test("saved persistent history projects receipts and pages without native observ
   assert.equal(result.page.conversationLog[0].user.receipt, false);
   assert.deepEqual(calls.map(([kind]) => kind), ["log", "page"]);
   await runtime.close();
-  await assert.rejects(runtime.projectStoredPersistentConversation(options), { code: "conversation_closed" });
+  await assert.rejects(runtime.projectStoredPersistentConversation(options), { code: "conversation_runtime_closed" });
 });
 
 test("a standalone Claude consumer reuses, updates and replaces processes without changing native history", async () => {
@@ -197,7 +197,11 @@ function codexHost({ readInstructions } = {}) {
     verifyEnvironment: async () => {},
     publishGoal: (threadId, goal) => requests.push({ method: "host.goal", input: { threadId, goal } }),
     recordInterruption: (threadId, turnId) => requests.push({ method: "host.recordInterruption", input: { threadId, turnId } }),
-    prepareResume: async (id, params) => { requests.push({ method: "host.prepareResume", input: { id } }); return params; }
+    prepareResume: async (id, params) => { requests.push({ method: "host.prepareResume", input: { id } }); return params; },
+    prepareParameters: () => undefined,
+    beforeResume: async () => {},
+    onRecoveryFailure: () => {},
+    log: () => {}
   });
   return { runtime, state, requests, client };
 }
@@ -725,8 +729,8 @@ test("a deleted logical conversation retires its open entry without opening anot
     const handle = await runtime.open({ id: "session", context: { chat: "one" } });
     await handle.subscribe(() => {});
     assert.deepEqual(await runtime.retireOpenConversation({ namespace: "temporary-one", sessionId: "session" }), { retired: true });
-    await assert.rejects(handle.read(), { code: "conversation_closed" });
-    await assert.rejects(handle.subscribe(() => {}), { code: "conversation_closed" });
+    await assert.rejects(handle.read(), { code: "conversation_handle_closed" });
+    await assert.rejects(handle.subscribe(() => {}), { code: "conversation_handle_closed" });
     assert.deepEqual(await runtime.retireOpenConversation({ namespace: "temporary-one", sessionId: "session" }), { retired: false },
       "an absent entry is already retired; nothing is opened to retire it");
     assert.deepEqual(await runtime.retireOpenConversation({ namespace: "temporary-two", sessionId: "session" }), { retired: false });

package/test/conversationSession.test.js

@@ -29,7 +29,7 @@ async function fixture(t, options = {}) {
     authorize: ({ context: actor, conversationId, operation }) => state.allowed && actor === context && ["one", "two"].includes(conversationId) &&
       (options.authorize?.({ operation, context: actor, conversationId }) ?? true),
     fetch: (url, init) => { requests.push(JSON.parse(init.body)); return options.fetch?.(url, init) || response(); },
-    limits: options.limits
+    limits: options.limits, ...(options.attachments ? { attachments: options.attachments } : {})
   });
   t.after(() => runtime.close());
   const conversation = await runtime.open({ id: "one", context, configuration: options.resume ? undefined : configuration });
@@ -71,7 +71,7 @@ test("API runtime persists one admission for concurrent identical sends and stre
   assert.equal(events.find(event => event.type === "accepted").messageId, input.messageId);
   assert.equal(events.at(-1).type, "settled");
   unsubscribe();
-  await assert.rejects(f.conversation.send({ ...input, text: "Changed content" }), { code: "conversation_message_conflict" });
+  await assert.rejects(f.conversation.send({ ...input, text: "Changed content" }), { code: "conversation_message_id_content_conflict" });
   assert.equal(f.requests.length, 1);
 });
 
@@ -82,7 +82,8 @@ test("saved history and current instructions use the existing authorized model c
   await f.conversation.configure({ systemPrompt: "Use the new instructions." });
   await f.conversation.send({ messageId: "two", text: "Continue" });
   await f.conversation.wait();
-  assert.equal(f.requests[1].messages[0].content, "Use the new instructions.");
+  assert.match(f.requests[1].messages[0].content, /^Use the new instructions\.\n\nCurrent state, from the system\./u,
+    "The current instructions lead the system prompt, before the engine's state note");
   assert.deepEqual(f.requests[1].messages.slice(1).map(message => message.content), ["Hello", "Hello there.", "Continue"]);
   f.state.modelAllowed = false;
   await assert.rejects(f.conversation.send({ messageId: "three", text: "No longer authorized" }));
@@ -144,7 +145,7 @@ test("application wakes retain their origin, reuse receipts and remain quoted da
   assert.ok(events.filter(event => event.type === "message").every(event => event.origin === "application"));
   assert.match(f.requests[0].messages.at(-1).content, /\[Application event\]/);
   assert.equal((await f.conversation.wake(message)).duplicate, true);
-  await assert.rejects(f.conversation.send(message), { code: "conversation_message_conflict" });
+  await assert.rejects(f.conversation.send(message), { code: "conversation_message_id_content_conflict" });
   await f.conversation.send(input);
   await f.conversation.wait();
   assert.equal(f.requests.length, 2);
@@ -174,7 +175,7 @@ test("per-request application data stays separate from visible text and particip
   assert.match(native, /not additional instructions or authorization/);
   assert.ok(native.endsWith("Hello"));
   assert.equal((await f.conversation.send(request)).duplicate, true);
-  await assert.rejects(f.conversation.send({ ...request, data: { focus: { project: "two" } } }), { code: "conversation_message_conflict" });
+  await assert.rejects(f.conversation.send({ ...request, data: { focus: { project: "two" } } }), { code: "conversation_message_id_content_conflict" });
   await f.conversation.wake({ messageId: "watch-data", text: "A watched session changed.", data: { status: "complete" } });
   const next = await f.conversation.wait();
   assert.equal(next.conversationLog[1].system.text, "A watched session changed.");
@@ -193,8 +194,63 @@ test("application data must fit the message limit before reserving or dispatchin
   assert.equal((await f.conversation.read()).pendingRequest, null);
 });
 
-test("provider errors are status information, never assistant replies or automatic retries", async t => {
-  const f = await fixture(t, { fetch: () => new Response('{"error":{"message":"Capacity unavailable"}}', { status: 429 }) });
+test("API compaction stores its summary with the last turn it covers, and later turns read only the turns after it", async t => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  for (let index = 0; index < 6; index++) {
+    await transcript.writeConversationUserMessage("one", { messageId: `earlier-${index}`, text: `Question ${index} ${"x".repeat(4000)}` });
+    await transcript.writeConversationAssistantMessage("one", { text: `Answer ${index}` });
+  }
+  const f = await fixture(t, { storage, limits: { contextTokens: 10_000 }, fetch: (_url, init) => JSON.parse(init.body).stream ? undefined
+    : Response.json({ choices: [{ index: 0, message: { role: "assistant", content: "Six long questions so far." }, finish_reason: "stop" }] }) });
+  const phases = [];
+  await f.conversation.subscribe(event => { if (event.type === "phase") phases.push(event.phase); });
+  await f.conversation.send(input);
+  const first = await f.conversation.wait();
+  assert.equal(first.conversationLog.at(-1).assistant.text, "Hello there.");
+  assert.ok(phases.includes("compacting"));
+  const summary = await storage.read("one", transaction => transaction.readSummary());
+  assert.equal(summary.text, "Six long questions so far.");
+  const turnIds = first.conversationLog.map(turn => turn.turnId);
+  const after = turnIds.slice(turnIds.indexOf(summary.throughTurnId) + 1);
+  assert.ok(after.length >= 2 && after.length < turnIds.length);
+  const seen = (await storage.read("one", transaction => transaction.readMetadata())).runtime.seen;
+  await f.conversation.send({ messageId: "two", text: "Continue" });
+  const second = await f.conversation.wait();
+  const last = f.requests.at(-1);
+  assert.match(last.messages[0].content, /Summary of the earlier part of this conversation[^]*Six long questions so far\./u);
+  assert.deepEqual(last.messages.filter(message => message.role === "user").map(message => message.content),
+    [...second.conversationLog.filter(turn => after.includes(turn.turnId)).map(turn => turn.user.text), "Continue"]);
+  assert.deepEqual(await storage.read("one", transaction => transaction.readSummary()), summary, "A short remainder is not compacted again");
+  const later = (await storage.read("one", transaction => transaction.readMetadata())).runtime.seen;
+  assert.ok(Object.keys(seen).every(id => Object.hasOwn(later, id)), "Versions saved before the summary still stand");
+});
+
+test("API history sends files again only within the newest 20 messages; older turns name theirs", async t => {
+  const resolved = [];
+  const attachments = { async resolve({ attachmentIds }) {
+    resolved.push([...attachmentIds]);
+    return { attachments: attachmentIds.map(attachmentId => ({ attachmentId, fileName: `${attachmentId}.txt`, size: 4 })),
+      content: attachmentIds.map(attachmentId => ({ type: "text", text: `Bytes of ${attachmentId}` })) };
+  } };
+  const f = await fixture(t, { attachments });
+  const send = async message => { await f.conversation.send(message); await f.conversation.wait(); };
+  await send({ messageId: "old", text: "Old file", attachmentIds: ["old"] });
+  for (let index = 0; index < 10; index++) await send({ messageId: `m${index}`, text: `Message ${index}` });
+  await send({ messageId: "recent", text: "Recent file", attachmentIds: ["recent"] });
+  resolved.length = 0;
+  await send({ messageId: "last", text: "Last" });
+  assert.deepEqual(resolved, [["recent"]], "Only the recent turn's file is read again");
+  const messages = f.requests.at(-1).messages;
+  assert.deepEqual(messages.find(message => Array.isArray(message.content) && message.content[0].text === "Old file").content,
+    [{ type: "text", text: "Old file" }, { type: "text", text: "(Files attached to this message, no longer shown: old.txt.)" }]);
+  assert.deepEqual(messages.find(message => Array.isArray(message.content) && message.content[0].text === "Recent file").content,
+    [{ type: "text", text: "Recent file" }, { type: "text", text: "Bytes of recent" }]);
+});
+
+test("provider errors before anything was done are status information after the engine's retries, never assistant replies", async t => {
+  const f = await fixture(t, { fetch: () => new Response('{"error":{"message":"Capacity unavailable"}}',
+    { status: 429, headers: { "content-type": "application/json", "retry-after-ms": "0" } }) });
   const receipt = await f.conversation.send(input);
   assert.equal(receipt.status, "accepted");
   const result = await f.conversation.wait();
@@ -202,7 +258,7 @@ test("provider errors are status information, never assistant replies or automat
   assert.equal(result.conversationLog[0].metadata.runtime.status, "failed");
   assert.match(result.error, /Capacity unavailable/);
   assert.equal((await f.conversation.send(input)).duplicate, true);
-  assert.equal(f.requests.length, 1);
+  assert.equal(f.requests.length, 7, "The engine tries a failed call again six times, then the turn fails");
 });
 
 test("cancellation aborts inference and leaves another conversation usable", async t => {
@@ -297,7 +353,7 @@ test("native creation authorizes its parent scope and uses only the configured o
   assert.equal(acquisitions, 1);
 
   await runtime.close();
-  await assert.rejects(runtime.createNativeConversation(request), { code: "conversation_closed" });
+  await assert.rejects(runtime.createNativeConversation(request), { code: "conversation_handle_closed" });
   assert.equal(accesses.length, 2);
   assert.equal(hostCalls, 1);
   assert.equal(acquisitions, 1);
@@ -358,9 +414,9 @@ test("native detached execution separates admitted context from host-approved or
   await entered.promise;
   await runtime.close();
   preparing.resolve();
-  await assert.rejects(pending, { code: "conversation_closed" });
+  await assert.rejects(pending, { code: "conversation_runtime_closed" });
   assert.deepEqual(calls.slice(6), ["authorize", "host"]);
-  await assert.rejects(runtime.runNativeDetachedConversation(request), { code: "conversation_closed" });
+  await assert.rejects(runtime.runNativeDetachedConversation(request), { code: "conversation_handle_closed" });
   assert.equal(calls.length, 8);
 });
 
@@ -492,8 +548,8 @@ test("native readiness authorizes its configured owner and rejects closure durin
   await preparation.entered.promise;
   await runtime.close();
   preparation.finished.resolve();
-  await assert.rejects(pending, { code: "conversation_closed" });
-  await assert.rejects(runtime.ensureNativeConversation(request), { code: "conversation_closed" });
+  await assert.rejects(pending, { code: "conversation_runtime_closed" });
+  await assert.rejects(runtime.ensureNativeConversation(request), { code: "conversation_handle_closed" });
   assert.deepEqual([hostCalls, acquisitions, accounts, saves], [2, 1, 1, 1]);
   assert.equal(owner.entries.size, 1, "Readiness did not create a retained runtime handle to dispose.");
 });
@@ -651,7 +707,7 @@ test("native invalidation preserves synchronous fences and failures without open
 });
 
 test("renewal proof cleanup preserves OpenCode failure, consumption and retry through the configured owner", async t => {
-  const owner = createOpenCodeSharedRuntime();
+  const owner = createOpenCodeSharedRuntime({});
   const calls = [];
   const id = "renewal-session";
   const requestContext = { sessionId: id };
@@ -910,9 +966,9 @@ test("renewal authorizes the existing session without opening a conversation or
     assert.equal(await runtime[method](request), result);
     assert.deepEqual(calls.slice(3), ["authorize", "host", "prepare", "acquire", "native"]);
     closeDuringPreparation = true;
-    await assert.rejects(runtime[method](request), { code: "conversation_closed" });
+    await assert.rejects(runtime[method](request), { code: "conversation_runtime_closed" });
     assert.deepEqual(calls.slice(8), ["authorize", "host"]);
-    await assert.rejects(runtime[method](request), { code: "conversation_closed" });
+    await assert.rejects(runtime[method](request), { code: "conversation_handle_closed" });
     assert.deepEqual(calls.slice(8), ["authorize", "host"]);
   });
 });
@@ -1124,7 +1180,7 @@ test("disposed handles cannot alter the next owner of the same conversation", as
   const next = await f.runtime.open({ id: "one", context });
   for (const run of [() => f.conversation.read(), () => f.conversation.send(input), () => f.conversation.dispose(),
     () => f.conversation.configure({ systemPrompt: "Stale" }), () => f.conversation.subscribe(() => {})]) {
-    await assert.rejects(run(), { code: "conversation_closed" });
+    await assert.rejects(run(), { code: "conversation_handle_closed" });
   }
   await next.send(input);
   assert.equal((await next.wait()).conversationLog.length, 1);
@@ -1162,11 +1218,11 @@ test("a saved running turn is marked interrupted and its accepted message is not
 
 test("limits and unsupported operations fail explicitly without silently changing the request", async t => {
   const f = await fixture(t, { limits: { maxOutputCharacters: 3 } });
-  await assert.rejects(f.conversation.send({ ...input, attachments: [{ id: "one" }] }), { code: "conversation_unsupported" });
-  await assert.rejects(f.conversation.send({ ...input, steer: true }), { code: "conversation_unsupported" });
+  await assert.rejects(f.conversation.send({ ...input, attachments: [{ id: "one" }] }), { code: "conversation_attachment_ids_only" });
+  await assert.rejects(f.conversation.send({ ...input, steer: true }), { code: "conversation_steering_unsupported" });
   assert.equal(await f.conversation.readGoal(), null);
   await assert.rejects(f.conversation.updateGoal({ action: "set", messageId: "goal", objective: "Keep working",
-    expectedSegmentId: (await f.conversation.read()).segmentId }), { code: "conversation_unsupported" });
+    expectedSegmentId: (await f.conversation.read()).segmentId }), { code: "conversation_goals_unsupported" });
   await f.conversation.send(input);
   const result = await f.conversation.wait();
   assert.equal(result.conversationLog[0].assistant, null);
@@ -1276,7 +1332,7 @@ test("native settings authorize their scope and reject replaced or closed host p
   await gate.entered.promise;
   await runtime.close();
   gate.finished.resolve();
-  await assert.rejects(pending, { code: "conversation_closed" });
-  await assert.rejects(runtime.updateNativeConversationSettings(request), { code: "conversation_closed" });
+  await assert.rejects(pending, { code: "conversation_runtime_closed" });
+  await assert.rejects(runtime.updateNativeConversationSettings(request), { code: "conversation_handle_closed" });
   assert.deepEqual([acquisitions, updates], [1, 1]);
 });

package/test/conversationTools.test.js

@@ -5,6 +5,7 @@ import { createActionCatalogue } from "@jskit-ai/kernel/server/actions";
 import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 import { createServiceToolCatalog } from "../src/server/lib/serviceToolCatalog.js";
 import { createConversationTools } from "../src/server/conversation/tools.js";
+import { checkTexts } from "@jskit-ai/agent/server";
 
 const configuration = { systemPrompt: "Use the available application operations when needed.", integrationId: "assistant" };
 const context = { actor: { id: "owner" }, surface: "app", applicationId: "test", subjectId: "owner" };
@@ -19,7 +20,7 @@ function actionCatalog(execute) {
   const actions = createActionCatalogue();
   actions.register({ contributorId: "test.tools", domain: "test", actions: [{
     id: "numbers.add", version: 1, kind: "command", channels: ["automation"], surfaces: ["app"],
-    permission: { require: "authenticated" }, idempotency: "none",
+    permission: { require: "authenticated" },
     input: { schema: createSchema({ left: { type: "number", required: true }, right: { type: "number", required: true } }), mode: "replace" },
     output: { schema: createSchema({ total: { type: "number", required: true } }), mode: "replace" }, execute
   }] });
@@ -73,6 +74,8 @@ test("API tools use authorized action contracts, save results and resume the sam
 
 // Carried from assistant-runtime's original split-tag lifecycle case. Only the
 // action name/arguments and confirmed API framing adapt to the common fixture.
+// A call written out as text never runs: the reply carries on once, told so, and
+// the model then calls the action itself.
 test("split internal tags and tool arguments never become common answer deltas", async t => {
   const f = await fixture(t, { response: (_body, round, name) => round === 1 ? new Response([
     "<th", "ink>private reasoning", "</thi", "nk>", "<｜DSML｜function_",
@@ -80,31 +83,35 @@ test("split internal tags and tool arguments never become common answer deltas",
     "</｜DSML｜invoke></｜DSML｜function_calls>"
   ].map(content => frame({ content })).join("") + frame({}, "stop"), {
     headers: { "content-type": "text/event-stream" }
-  }) : response({ text: "The search is complete." }) });
+  }) : round === 2 ? response({ name }) : response({ text: "The search is complete." }) });
   await f.conversation.send(message);
   const result = await f.conversation.wait();
   assert.deepEqual(f.observed.executions, [{ left: 2, right: 3 }]);
+  assert.equal(f.observed.requests[1].messages.at(-1).content, checkTexts("the app").markup);
   assert.deepEqual(f.observed.events.filter(event => event.type === "message" && event.status !== "complete")
     .map(event => event.text), ["The search is complete."]);
   assert.equal(result.conversationLog[0].assistant.text, "The search is complete.");
 });
 
-test("text-encoded calls in separate responses retain separate durable receipts", async t => {
+test("text-encoded calls never run or reach the person, even when written again after the check", async t => {
   const f = await fixture(t, { response: (_body, round, name) => round < 3 ? new Response(frame({ content:
     `<function_calls><invoke name="${name}">${round === 1 ? call.arguments : '{"left":4,"right":5}'}</invoke></function_calls>`
   }) + frame({}, "stop"), { headers: { "content-type": "text/event-stream" } }) : response() });
   await f.conversation.send(message);
   const result = await f.conversation.wait();
-  assert.deepEqual(f.observed.executions, [{ left: 2, right: 3 }, { left: 4, right: 5 }]);
-  assert.equal(result.error, "");
-  assert.equal(new Set(result.conversationLog[0].metadata.applicationTools.map(call => call.id)).size, 2);
+  assert.deepEqual(f.observed.executions, []);
+  assert.equal(f.observed.requests.length, 2, "The check sends the reply back once");
+  assert.equal(f.observed.requests[1].messages.at(-1).content, checkTexts("the app").markup);
+  assert.deepEqual(result.conversationLog[0].metadata.applicationTools, []);
+  assert.equal(f.observed.events.some(event => event.type === "message" && /invoke|function_calls/u.test(event.text)), false);
 });
 
 test("text-encoded calls still require confirmed completion and raw-output limits", async t => {
   for (const oversized of [false, true]) {
     const f = await fixture(t, { limits: oversized ? { maxOutputCharacters: 100 } : {},
       response: (_body, _round, name) => new Response(frame({ content:
-        (oversized ? `<think>${"private".repeat(50)}</think>` : "") +
+        // Inline <think> reasoning is reasoning, bounded by tokens; the limit counts reply text.
+        (oversized ? "Working on it. ".repeat(10) : "") +
         `<function_calls><invoke name="${name}">${call.arguments}</invoke></function_calls>`
       }) + (oversized ? frame({}, "stop") : ""), { headers: { "content-type": "text/event-stream" } }) });
     await f.conversation.send(message);
@@ -186,18 +193,13 @@ test("the runtime applies application tool policy to schemas and an unsolicited
   assert.equal(result.conversationLog[0].metadata.runtime.status, "complete");
   assert.equal(result.error, "");
   assert.equal(result.conversationLog[0].assistant.text, "The total is five.");
-  const refusal = { ok: false, error: { code: "assistant_tool_unknown", message: "Unknown tool." } };
-  const recorded = result.conversationLog[0].metadata.applicationTools[0];
-  assert.equal(result.conversationLog[0].metadata.applicationTools.length, 1);
-  assert.equal(recorded.id, call.id);
-  assert.equal(recorded.name, f.name);
-  assert.equal(recorded.arguments, call.arguments);
-  assert.equal(recorded.status, "complete");
-  assert.deepEqual(recorded.result, refusal);
+  // The engine answers a call to a tool it was not given as a tool error; no
+  // application receipt is made, since nothing could run.
+  assert.deepEqual(result.conversationLog[0].metadata.applicationTools, []);
   const feedback = f.observed.requests[1].messages.filter(message => message.role === "tool");
   assert.equal(feedback.length, 1);
   assert.equal(feedback[0].tool_call_id, call.id);
-  assert.deepEqual(JSON.parse(feedback[0].content), { error: refusal.error });
+  assert.match(feedback[0].content, new RegExp(`unavailable tool '${f.name}'`, "u"));
 });
 
 test("incomplete model tool streams cannot execute application actions", async t => {
@@ -211,7 +213,7 @@ test("incomplete model tool streams cannot execute application actions", async t
 });
 
 test("tool limits bound continuation even when the model keeps requesting actions", async t => {
-  const f = await fixture(t, { limits: { maxToolCalls: 2 }, response: (_body, round, name) => response({ name, id: `call_${round}` }) });
+  const f = await fixture(t, { limits: { maxToolCalls: 2, maxSteps: 5 }, response: (_body, round, name) => response({ name, id: `call_${round}` }) });
   await f.conversation.send(message);
   const result = await f.conversation.wait();
   assert.equal(f.observed.executions.length, 2);
@@ -219,6 +221,25 @@ test("tool limits bound continuation even when the model keeps requesting action
   assert.match(result.error, /tool-call limit/);
 });
 
+test("by default the step limit stays within the action-call limit, so the model gives its own account", async t => {
+  const account = "I added the numbers twice and stopped there.";
+  const answer = content => Response.json({ id: "once", object: "chat.completion", created: 0, model: "exact-model",
+    choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: "stop" }] });
+  const f = await fixture(t, { limits: { maxToolCalls: 2 }, response: (body, round, name) => {
+    if (body.stream) return response({ name, id: `call_${round}` });
+    return /^You check an assistant's reply/u.test(body.messages[0].content) ? answer('{"unsupported": []}') : answer(account);
+  } });
+  await f.conversation.send(message);
+  const result = await f.conversation.wait();
+  assert.equal(f.observed.executions.length, 2);
+  assert.deepEqual(f.observed.requests.map(body => body.stream === true), [true, true, false, false],
+    "Two steps, then the engine's account of where it got to and its check of that account's claims");
+  assert.match(f.observed.requests[2].messages[0].content, /stopped early because I reached the most steps/u);
+  assert.equal(result.error, "");
+  assert.equal(result.conversationLog[0].metadata.runtime.status, "complete");
+  assert.equal(result.conversationLog[0].assistant.text, account);
+});
+
 test("cancel waits for an admitted application action to settle and saves its result", async t => {
   const entered = Promise.withResolvers(), complete = Promise.withResolvers();
   const f = await fixture(t, { execute: () => { entered.resolve(); return complete.promise; } });
@@ -732,7 +753,7 @@ test("bound admission current guard fences a held host effect after steering or
   await f.conversation.send({ messageId: "guard-steer", text: "A new instruction.", steer: true });
   await f.currentCommand(1);
   boundary.resolve();
-  await assert.rejects(held, { code: "conversation_tool_request_retired" });
+  await assert.rejects(held, { code: "conversation_application_tool_message_stale" });
   await f.tools().execute({ id: "guard-contract", name: "assistant_action_contract",
     arguments: JSON.stringify({ actionId: "numbers.add", version: 1 }) });
   const current = f.observed.mappings.at(-1).admission;
@@ -740,7 +761,7 @@ test("bound admission current guard fences a held host effect after steering or
   assert.equal(current.messageId, "guard-steer");
   f.finish.resolve();
   await f.conversation.wait();
-  assert.throws(() => current.assertCurrent(), { code: "conversation_tool_request_retired" });
+  assert.throws(() => current.assertCurrent(), { code: "conversation_application_tool_message_stale" });
   assert.equal(f.observed.executions.length, 1, "Inspecting current authority must not dispatch or repeat work");
 });
 
@@ -826,7 +847,7 @@ test("bound admission completion guard retains only its latest successful native
       const original = f.observed.mappings[0].admission;
       assert.equal(typeof original.assertCompletionCurrent, "function");
       assert.equal(JSON.parse(JSON.stringify(original)).assertCompletionCurrent, undefined);
-      assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" },
+      assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" },
         "A working native turn cannot authorize completion");
       if (boundary === "stopped") {
         await f.conversation.cancel();
@@ -839,16 +860,16 @@ test("bound admission completion guard retains only its latest successful native
       }
       f.finish.resolve();
       await f.conversation.wait();
-      assert.throws(() => original.assertCurrent(), { code: "conversation_tool_request_retired" },
+      assert.throws(() => original.assertCurrent(), { code: "conversation_application_tool_message_stale" },
         "Native settlement never restores live tool authority");
       if (boundary === "steered") {
-        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" });
         return;
       }
       original.assertCompletionCurrent();
       if (boundary === "closed") {
         await f.runtime.close();
-        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" });
       } else if (boundary === "rejected-successor") {
         f.binding.prepareInput = async () => { throw new Error("The newer input was rejected before native dispatch."); };
         await assert.rejects(f.conversation.send({ messageId: "unaccepted-successor", text: "Never admitted." }),
@@ -865,7 +886,7 @@ test("bound admission completion guard retains only its latest successful native
         const receipt = await f.conversation.send({ messageId: "recovered-successor", text: "An original recovered native receipt." });
         assert.equal(receipt.recovered, true);
         await f.conversation.wait();
-        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" },
+        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" },
           "Verified recovered admission also retires the previous completion receipt");
       } else if (boundary.startsWith("successor-")) {
         const gate = Promise.withResolvers();
@@ -878,11 +899,11 @@ test("bound admission completion guard retains only its latest successful native
           await f.conversation.send({ messageId: "accepted-successor", text: "A genuinely accepted later input." });
           await f.currentCommand(1);
           if (boundary === "successor-active") {
-            assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+            assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" });
             gate.resolve();
           }
           await f.conversation.wait();
-          assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" },
+          assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_native_completion_message_stale" },
             "A later accepted receipt stays current after its active slot clears");
         } finally { gate.resolve(); }
       }

package/test/fileConversationStorage.test.js

@@ -19,13 +19,19 @@ async function fixture(t) {
 test("file conversations satisfy the shared storage contract and survive a new process", async (t) => {
   const f = await fixture(t);
   const { scope, transcript } = await verifyConversationStorageContract(f.storage, { runtime: true });
-  const expected = await transcript.readConversationLog(scope);
+  const log = await transcript.readConversationLog(scope);
+  const expected = { log, summary: await f.storage.read(scope, transaction => transaction.readSummary()),
+    after: await transcript.readConversationLog(scope, { afterTurnId: log[0].turnId }) };
+  assert.ok(expected.summary);
+  assert.deepEqual(expected.after, log.slice(1));
   const { stdout } = await promisify(execFile)(process.execPath, ["--input-type=module", "-e", `
     import { createFileConversationStorage } from ${JSON.stringify(new URL("../src/server/conversation/fileStorage.js", import.meta.url).href)};
     import { createConversationTranscript } from ${JSON.stringify(new URL("../src/server/conversation/transcript.js", import.meta.url).href)};
     const storage = createFileConversationStorage({ directory: process.argv[1] });
     const transcript = createConversationTranscript({ storage });
-    process.stdout.write(JSON.stringify(await transcript.readConversationLog(process.argv[2])));
+    const log = await transcript.readConversationLog(process.argv[2]);
+    process.stdout.write(JSON.stringify({ log, summary: await storage.read(process.argv[2], transaction => transaction.readSummary()),
+      after: await transcript.readConversationLog(process.argv[2], { afterTurnId: log[0].turnId }) }));
   `, f.directory, scope]);
   assert.deepEqual(JSON.parse(stdout), expected);
   assert.equal((await readdir(f.directory)).some((name) => name.endsWith(".tmp")), false);
@@ -54,7 +60,8 @@ test("damaged or unsupported stored data fails explicitly and is never overwritt
   await f.transcript.writeConversationUserMessage("one", { text: "Saved" });
   const [filename] = await readdir(f.directory);
   const path = join(f.directory, filename);
-  for (const damaged of ["{", "null", '{"version":2}', '{"version":1,"scope":"other","turns":[]}']) {
+  for (const damaged of ["{", "null", '{"version":2}', '{"version":1,"scope":"other","turns":[]}',
+    '{"version":1,"scope":"one","turns":[],"summary":{"text":"Earlier","throughTurnId":"000009"}}']) {
     await writeFile(path, damaged);
     await assert.rejects(f.transcript.readConversationLog("one"), /Conversation storage/);
     await assert.rejects(f.transcript.writeConversationUserMessage("one", { text: "Do not replace" }), /Conversation storage/);

package/test/fixtures/codexHelperThreadLedger.js

@@ -1,8 +1,8 @@
 import {
   CODEX_HELPER_THREAD_LEDGER_SCHEMA_VERSION,
-  CODEX_HELPER_THREAD_LIFECYCLES,
-  createCodexHelperThreadLedgerOwner
-} from "../../src/server/conversation/codexHelperThreadLedger.js";
+  CODEX_HELPER_THREAD_LIFECYCLES
+} from "../../src/server/conversation/codexHelperThreadRecord.js";
+import { createCodexHelperThreadLedgerOwner } from "../../src/server/conversation/codexHelperThreadLedger.js";
 
 // This is the original test's resolved profile data, not application policy.
 // Public keeps and tests its original strict codec against its own catalogue.