@jskit-ai/assistant-core 0.1.208 → 0.1.211

package/src/server/conversation/providers/opencodeDriver.js

@@ -14,6 +14,43 @@ import { validateConversationConfiguration, validateConnectionModel } from "../c
 const hash = value => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const nativeMessageId = id => `msg_jskit_${hash(id).slice(0, 40)}`;
 
+// Original standalone native-use validation and authored admission, shared by
+// explicitly supplied bound tools without transferring native process ownership.
+async function executeOpenCodeApplicationTool({ active, turn, target, sessionId, assertCurrent }, input, signal) {
+  if (!active?.tools || input.sessionId !== sessionId ||
+      [input.id, input.name, input.messageId].some(value => typeof value !== "string" || !value || value.length > 256)) {
+    throw new Error("This OpenCode tool call does not belong to the active conversation.");
+  }
+  if (!turn?.abortController) {
+    throw new Error("This OpenCode tool call does not belong to an admitted conversation.");
+  }
+  assertCurrent?.();
+  const observed = AbortSignal.any([signal, turn.abortController.signal]);
+  await turn.admission?.promise;
+  observed.throwIfAborted();
+  const messages = await target.server.client.messages(sessionId, { limit: 100 }, { signal: observed });
+  let message;
+  let owner;
+  for (const [nativeId, authored] of active.messageIds) {
+    message = openCodeRowsForInput(messages, nativeId).find(message => message.id === input.messageId && message.type === "assistant");
+    if (message) { owner = authored; break; }
+  }
+  const tool = message?.content.find(part => part.type === "tool" && part.callID === input.id);
+  if (!tool || tool.tool !== input.name || !isDeepStrictEqual(tool.state?.input, input.input)) {
+    throw new Error("OpenCode's application call does not match an admitted native tool use.");
+  }
+  if (!owner.committed) throw new Error("This OpenCode tool call has no durable authored admission.");
+  await owner.committed;
+  observed.throwIfAborted();
+  assertCurrent?.(true, owner);
+  try {
+    return await active.tools.execute({ id: input.id, name: input.name, arguments: JSON.stringify(input.input) }, { signal: observed, messageId: owner.messageId });
+  } catch (error) {
+    if (!assertCurrent || assertCurrent(false, owner)) turn.abortController.abort(error);
+    throw error;
+  }
+}
+
 /** Uses the application's authorized API connection; native state stays server-side. */
 export function createOpenCodeConversationDriver({ connections, host = {}, limits = {} } = {}) {
   if (!host.conversation && typeof connections?.resolve !== "function") throw new TypeError("OpenCode conversations require an authorized AI connection resolver.");
@@ -167,10 +204,12 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
         let current;
         let disposed = false;
         let cleanupFailure;
+        let toolBridge;
         async function interrupt(context) {
           try {
             const acquired = await supplied.acquire(context || current?.context);
             const value = await supplied.owner.interruptPreparedTurn(await supplied.preparation.interruption(acquired.options));
+            if (toolBridge) { await toolBridge.close(); toolBridge = null; }
             if (cleanupFailure) {
               await reportFailure(cleanupFailure, { recovered: true });
               cleanupFailure = null;
@@ -184,16 +223,61 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
             throw error;
           }
         }
-        async function send({ input, context, signal, beforeDispatch, accept }) {
+        async function send(command) {
+          const { input, context, signal, beforeDispatch, accept } = command;
           signal.throwIfAborted();
           const acquired = await supplied.acquire(context);
-          const prepared = await supplied.preparation.message({ ...input.nativeMessage, onPromptSending: beforeDispatch }, acquired.options);
-          const value = await supplied.owner.sendPreparedMessage(prepared, acquired.options);
+          const active = current;
+          if (active?.tools) signal.throwIfAborted();
+          if (active?.tools && !toolBridge) {
+            toolBridge = await createOpenCodeToolBridge({ schemas: active.tools.schemas,
+              maxArgumentBytes: active.tools.maximumArgumentBytes, execute(input, signal) {
+                const turn = supplied.owner.turns.get(acquired.key);
+                const target = supplied.owner.processes.get(acquired.key);
+                return executeOpenCodeApplicationTool({ active: current, turn, target,
+                  sessionId: target?.upstreamSessionId,
+                  assertCurrent(throwFailure = true, authored) {
+                    const owned = !disposed && current === active && active.turn === turn && turn?.active &&
+                      (!authored || active.messageIds.get(turn.inputMessageId) === authored) &&
+                      supplied.owner.turns.get(acquired.key) === turn && supplied.owner.processes.get(acquired.key) === target;
+                    if (!owned && throwFailure) throw new Error("This OpenCode tool call belongs to a retired native turn.");
+                    return owned;
+                  }
+                }, input, signal);
+              }
+            });
+          }
+          const options = active?.tools ? { ...acquired.options, applicationTools: toolBridge.configuration } : acquired.options;
+          let prepared;
+          const dispatch = active?.tools ? async identity => {
+            await beforeDispatch(identity);
+            signal.throwIfAborted();
+            active.turn = supplied.owner.turns.get(acquired.key);
+            active.messageIds.set(prepared.input.id, { messageId: input.messageId, committed: command.deliveryCommitted });
+          } : beforeDispatch;
+          prepared = await supplied.preparation.message({ ...input.nativeMessage, onPromptSending: dispatch }, options);
+          if (active?.tools && prepared.application?.monitor) {
+            const monitor = prepared.application.monitor;
+            const create = monitor.create;
+            prepared.application = { ...prepared.application, monitor: { ...monitor,
+              create(...args) {
+                const projection = create(...args);
+                const finalResponse = projection.finalResponse;
+                return { ...projection, finalResponse: { ...finalResponse,
+                  async beforeRecovery(completion) {
+                    active.messageIds.set(finalResponse.recoveryMessageId, active.messageIds.get(completion.inputMessageId));
+                    await finalResponse.beforeRecovery?.(completion);
+                  }
+                } };
+              }
+            } };
+          }
+          const value = await supplied.owner.sendPreparedMessage(prepared, options);
           const delivered = { value, completion: value.conversationTurn ? supplied.owner.monitors.get(acquired.key) : null };
           if (value.delivered === true && value.conversationTurn) {
             if (current) current.delivery = delivered;
             await accept({ nativeResult: { value }, conversationTurn: value.conversationTurn, nativeTurnId: value.turn?.id });
-          }
+          } else if (active?.tools) active.messageIds.delete(prepared.input.id);
           return delivered;
         }
         return Object.freeze({
@@ -205,7 +289,8 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
           },
           async run(command) {
             if (disposed || current) throw new Error("This OpenCode conversation is closed or already working.");
-            const active = { context: command.context, failure: Promise.withResolvers() };
+            const active = { context: command.context, failure: Promise.withResolvers(),
+              ...(command.tools ? { tools: command.tools, messageIds: new Map() } : {}) };
             let failure;
             active.failure.promise.catch(error => { failure = error; });
             current = active;
@@ -248,6 +333,7 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
             } finally {
               command.signal.removeEventListener("abort", abort);
               await cancellation?.catch(() => {});
+              if (toolBridge) { await toolBridge.close(); toolBridge = null; }
               if (current === active) current = null;
             }
           },
@@ -260,6 +346,7 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
             try {
               const result = await disposeNative({ native: supplied, options });
               if (result?.ok === false) throw Object.assign(new Error(result.error || "OpenCode cleanup could not be confirmed."), result);
+              if (toolBridge) { await toolBridge.close(); toolBridge = null; }
               disposed = true;
               return result;
             } catch (error) {
@@ -388,38 +475,8 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
           toolBridge = await createOpenCodeToolBridge({
             schemas: current.tools.schemas, maxArgumentBytes: current.tools.maximumArgumentBytes,
             async execute(input, signal) {
-              const active = current;
-              if (!active?.tools || input.sessionId !== binding.sessionId ||
-                  [input.id, input.name, input.messageId].some(value => typeof value !== "string" || !value || value.length > 256)) {
-                throw new Error("This OpenCode tool call does not belong to the active conversation.");
-              }
-              const turn = facilities.runtime.turns.get(binding.directory);
-              if (!turn?.abortController) {
-                throw new Error("This OpenCode tool call does not belong to an admitted conversation.");
-              }
-              const observed = AbortSignal.any([signal, turn.abortController.signal]);
-              await turn.admission?.promise;
-              observed.throwIfAborted();
-              const messages = await native.server.client.messages(binding.sessionId, { limit: 100 }, { signal: observed });
-              let message;
-              let owner;
-              for (const [nativeId, authored] of active.messageIds) {
-                message = openCodeRowsForInput(messages, nativeId).find(message => message.id === input.messageId && message.type === "assistant");
-                if (message) { owner = authored; break; }
-              }
-              const tool = message?.content.find(part => part.type === "tool" && part.callID === input.id);
-              if (!tool || tool.tool !== input.name || !isDeepStrictEqual(tool.state?.input, input.input)) {
-                throw new Error("OpenCode's application call does not match an admitted native tool use.");
-              }
-              if (!owner.committed) throw new Error("This OpenCode tool call has no durable authored admission.");
-              await owner.committed;
-              observed.throwIfAborted();
-              try {
-                return await active.tools.execute({ id: input.id, name: input.name, arguments: JSON.stringify(input.input) }, { signal: observed, messageId: owner.messageId });
-              } catch (error) {
-                turn.abortController.abort(error);
-                throw error;
-              }
+              return executeOpenCodeApplicationTool({ active: current,
+                turn: facilities.runtime.turns.get(binding.directory), target: native, sessionId: binding.sessionId }, input, signal);
             }
           });
         }

package/src/server/conversation/runtime.js

@@ -50,6 +50,10 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
   if (!Number.isSafeInteger(maximumToolCalls) || maximumToolCalls < 1) throw new TypeError("Invalid application tool-call limit.");
   const maximumInput = limits.maxInputCharacters ?? 32_000;
   if (!Number.isSafeInteger(maximumInput) || maximumInput < 1) throw new TypeError("Invalid conversation input limit.");
+  const maximumFinalReply = limits.maxFinalReplyCharacters ?? Infinity;
+  if (limits.maxFinalReplyCharacters !== undefined && (!Number.isSafeInteger(maximumFinalReply) || maximumFinalReply < 1)) {
+    throw new TypeError("Invalid conversation final reply limit.");
+  }
   const maximumContinuity = limits.maxContinuityCharacters ?? 128_000;
   if (!Number.isSafeInteger(maximumContinuity) || maximumContinuity < 1) throw new TypeError("Invalid conversation continuity limit.");
   const maximumAttachmentBytes = limits.maxAttachmentBytes ?? 8 * 1024 * 1024;
@@ -371,6 +375,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
 
   async function initialize(entry, configuration, requestedEngine) {
     if (entry.conversation) {
+      entry.applicationTools = boundApplicationTools(entry.conversation);
       entry.engine = entry.conversation.engine;
       if (requestedEngine && requestedEngine !== entry.engine) throw failure("The selected native engine changed.", "conversation_engine_mismatch");
       entry.driver = createDriver(entry.engine, entry.host);
@@ -434,6 +439,15 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     entry.provider = await openProvider(entry, entry.driver, binding, entry.segmentId);
   }
 
+  function boundApplicationTools(conversation) {
+    const facilities = conversation.applicationTools;
+    if (facilities === undefined) return null;
+    if (!catalog || conversation.commands || conversation.native?.scoped || typeof facilities?.prepareContext !== "function") {
+      throw new TypeError("Bound application tools require a catalogue, an admitted conversation and a server-owned context mapper.");
+    }
+    return { storage: createReentrantConversationStorage(facilities.storage), prepareContext: facilities.prepareContext };
+  }
+
   async function perform(entry, active, configuration) {
     const { driver, engine, segmentId } = entry;
     const initial = active.request;
@@ -445,15 +459,39 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     const rejectionSaves = new Map();
     let toolWork = Promise.resolve();
     let toolFailure;
+    const applicationTools = entry.applicationTools;
+    const toolStorage = applicationTools?.storage || storage;
+
+    async function saveTools(transaction, request, calls) {
+      if (entry.conversation) {
+        const saved = await transaction.readTurn(request.turnId);
+        if (submittedMessage(saved || {})?.messageId !== request.input.messageId) {
+          throw new Error("The application tool receipt does not belong to this authored request.");
+        }
+      }
+      await transaction.updateTurnMetadata(request.turnId, { applicationTools: calls });
+    }
 
     function prepareTools(request) {
-      if (!catalog || entry.conversation) return;
+      if (!catalog || entry.conversation && !applicationTools) return;
       request.tools = createConversationTools({ catalog, context: request.context, signal: active.controller.signal,
+        ...(applicationTools ? { prepareContext() {
+          if (!request.accepted) throw new Error("The application tool does not belong to an admitted message.");
+          return applicationTools.prepareContext(request.context, Object.freeze({ conversationId: entry.id,
+            turnId: request.turnId, messageId: request.input.messageId, nativeTurnId: request.nativeTurnId,
+            nativeThreadId: request.nativeThreadId, origin: request.input.origin,
+            assertCurrent() {
+              active.controller.signal.throwIfAborted();
+              if (entry.active !== active || current !== request || !request.accepted || request.finished) {
+                throw failure("This application tool's admitted message is no longer current.", "conversation_tool_request_retired");
+              }
+            } }));
+        } } : {}),
         maximumCalls: maximumToolCalls, discoveryOnly: driver.toolDiscovery === true,
         authorize: () => access(request.context, entry.id, "tool", entry),
         save: calls => {
           if (!request.accepted) throw new Error("The engine requested an application tool before admitting the message.");
-          return storage.write(entry.id, transaction => transaction.updateTurnMetadata(request.turnId, { applicationTools: calls }));
+          return toolStorage.write(entry.id, transaction => saveTools(transaction, request, calls));
         },
         emit: event => emit(entry, { ...event, turnId: request.turnId })
       });
@@ -612,6 +650,10 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       await setPhase(entry, "working", request.turnId);
       if (request.sealed) return;
       const messageId = `${request.turnId}:${message.id}`;
+      if (message.role === "assistant" && message.complete && message.text.length > maximumFinalReply) {
+        if (request.answer?.messageId === messageId) request.answer = null;
+        throw new Error("The assistant exceeded the configured final reply limit.");
+      }
       const previous = request.answer?.messageId === messageId ? request.answer : request.progress.get(messageId);
       const outputOwner = message.outputId && messageOwners.get(message.outputId) || request;
       const outputId = previous?.outputId || (message.outputId ? `${outputOwner.turnId}:${message.outputId}` : "");
@@ -715,6 +757,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
           async accept(native) {
             if (entry.conversation) nativeResult = native.nativeResult;
             if (native?.nativeTurnId) active.nativeTurnId = native.nativeTurnId;
+            request.nativeThreadId = threadId;
             await admit(request, undefined, { nativeDelivery: true, conversationTurn: native?.conversationTurn });
             admitted.resolve(entry.conversation ? nativeResult.value
               : { ok: true, delivered: true, messageId: request.input.messageId, threadId });
@@ -970,8 +1013,13 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       : status === "cancelled" ? "Work stopped." : problem?.message || active.steerError || initial.recovered?.error || "");
     entry.saveProgress = async () => {
       if (entry.conversation) {
-        // Native output, checkpoints and receipt durability are already owned
-        // by the original run owner and sender; do not annotate old rows.
+        if (applicationTools) await toolStorage.write(entry.id, async transaction => {
+          for (const request of active.requests.values()) {
+            if (request.accepted && request.tools?.records().length) await saveTools(transaction, request, request.tools.records());
+          }
+        });
+        // Only opted-in application receipts are saved above. Native output,
+        // checkpoints and status remain with the original run owner and sender.
         entry.error = error;
         entry.storageFailure = null;
         entry.saveProgress = null;
@@ -1342,6 +1390,13 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     }
     const metadata = { runtime: await readState(entry) };
     if (metadata.runtime.replacement) throw failure("Finish the native replacement before recovering output.", "conversation_replacement_pending");
+    const savedRequests = [...metadata.runtime.predecessors, metadata.runtime].filter(segment => segment.request?.messageId === messageId);
+    if (!existing && savedRequests.length && savedRequests.every(segment =>
+      ["codex", "claude", "opencode"].includes(segment.engine) && segment.request.attempted === false && !segment.request.inspectionOnly &&
+      isDeepStrictEqual(segment.request, savedRequests[0].request))) {
+      await access(context, entry.id, "inspectDelivery", entry);
+      return { status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message." };
+    }
     const request = existing ? submittedMessage(existing) : metadata.runtime.request;
     if (!request || request.messageId !== messageId || !entry.provider.inspectAdmission) return receipt || { status: "unknown", messageId };
     const pending = metadata.runtime.request?.messageId === messageId ? metadata.runtime.request : null;
@@ -1415,13 +1470,17 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         }
         const nativeReplies = (native.messages || []).filter(message => message.role === "assistant");
         const outputId = nativeReplies.length === 1 && nativeReplies[0].outputId;
-        if (replies.length) await transaction.replaceAssistant(turn.turnId, { messageId: turn.assistant?.messageId || `${turn.turnId}:assistant`,
+        const replyText = replies.join("\n\n");
+        const oversizedReply = replyText.length > maximumFinalReply;
+        if (replies.length && !oversizedReply) await transaction.replaceAssistant(turn.turnId, { messageId: turn.assistant?.messageId || `${turn.turnId}:assistant`,
           ...(!turn.assistant?.outputId && outputId ? { outputId: `${turn.turnId}:${outputId}` } : {}),
-          role: "assistant", text: replies.join("\n\n"), at: submittedMessage(turn).at });
+          role: "assistant", text: replyText, at: submittedMessage(turn).at });
         const unknownTool = turn.metadata.applicationTools?.some(call => !call.result || call.status === "unknown");
-        const status = ["cancelled", "failed"].includes(runtime.status) ? runtime.status : unknownTool ? "interrupted" : native.status || "interrupted";
+        const retainedFailure = ["cancelled", "failed"].includes(runtime.status);
+        const status = retainedFailure ? runtime.status : oversizedReply ? "failed" : unknownTool ? "interrupted" : native.status || "interrupted";
         const { error: previousError, ...saved } = runtime;
         const error = unknownTool ? "Native output was recovered, but an application tool has no verified result. Inspect its target before requesting another execution."
+          : oversizedReply ? retainedFailure && (previousError || native.error) || "The assistant exceeded the configured final reply limit."
           : status === "complete" ? "" : previousError || native.error || "Delivery was confirmed from native history. Completion was not confirmed; this request was not replayed.";
         await transaction.updateTurnMetadata(turn.turnId, { runtime: { ...saved, status,
           ...(request.goal || goalRequest ? { goalMessageId: messageId } : {}),
@@ -1531,6 +1590,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       }
       const next = await entry.host.conversation({ id: entry.id, context });
       entry.conversation = next;
+      entry.applicationTools = boundApplicationTools(next);
       entry.engine = next.engine;
       entry.driver = createDriver(entry.engine, entry.host);
       const current = await readState(entry);

package/src/server/conversation/tools.js

@@ -3,7 +3,7 @@ import { isDeepStrictEqual } from "node:util";
 const unknownOutcome = "The application operation did not return a verified result. Inspect its target before requesting another execution.";
 
 /** One turn's application calls. Native/API adapters only transport these calls. */
-export function createConversationTools({ catalog, context, signal: turnSignal, previousCalls = [], authorize, save, emit,
+export function createConversationTools({ catalog, context, prepareContext, signal: turnSignal, previousCalls = [], authorize, save, emit,
   maximumCalls = 32, discoveryOnly = false, transient = false, propagateErrors = false }) {
   if (transient !== true && [authorize, save, emit].some(hook => typeof hook !== "function")) {
     throw new TypeError("Conversation tools require authorization, durable save and event facilities.");
@@ -11,6 +11,7 @@ export function createConversationTools({ catalog, context, signal: turnSignal,
   if (transient === true && previousCalls.length) {
     throw new TypeError("Transient application tools cannot restore a previous execution.");
   }
+  if (prepareContext !== undefined && typeof prepareContext !== "function") throw new TypeError("Application tool context requires a server-owned mapper.");
   const toolSet = catalog.resolveToolSet(context, { discoveryOnly });
   const calls = new Map(structuredClone(previousCalls).map(call => [call.id, call]));
   let pending = Promise.resolve();
@@ -27,6 +28,7 @@ export function createConversationTools({ catalog, context, signal: turnSignal,
 
   async function run({ id, name, arguments: argumentsText }, signal) {
     await authorize?.();
+    let executionContext = prepareContext ? await prepareContext() : context;
     signal.throwIfAborted();
     if (typeof id !== "string" || !id || id.length > 256 || typeof name !== "string" || !name || name.length > 256 ||
         typeof argumentsText !== "string") throw new TypeError("An application tool requires its call id, name and JSON arguments.");
@@ -52,6 +54,7 @@ export function createConversationTools({ catalog, context, signal: turnSignal,
     await emit?.({ type: "tool", call: structuredClone(call) });
     try {
       await authorize?.();
+      if (prepareContext) executionContext = await prepareContext();
       signal.throwIfAborted();
     } catch (error) {
       call.status = "not-executed";
@@ -61,7 +64,7 @@ export function createConversationTools({ catalog, context, signal: turnSignal,
     }
     let failed = false;
     let failure;
-    call.result = await catalog.executeToolCall({ toolName: name, argumentsText, toolSet, context: { ...context, signal },
+    call.result = await catalog.executeToolCall({ toolName: name, argumentsText, toolSet, context: { ...executionContext, signal },
       ...(propagateErrors ? { onFailure(error) { failed = true; failure = error; } } : {}) });
     call.status = !call.result.ok && call.result.error?.status >= 500 ? "unknown" : "complete";
     // Keep the result in memory as well: retrySave can persist it after a failed

package/src/server/conversation/transcript.js

@@ -44,7 +44,7 @@ export function createConversationTranscript({ storage, clock = () => new Date()
     return ids.length ? transaction.readTurn(ids.at(-1)) : null;
   }
 
-  async function append(scope, role, { text = "", messageId = "", at = "", attachments = [], turnMetadata = null, requireOpenTurn = false, outputId = "" } = {}) {
+  async function append(scope, role, { text = "", messageId = "", at = "", attachments = [], data, turnMetadata = null, requireOpenTurn = false, outputId = "" } = {}) {
     const messageText = normalizeText(text);
     const id = normalizeText(messageId);
     if (!messageText && !(role === "user" && Array.isArray(attachments) && attachments.length)) return null;
@@ -61,7 +61,7 @@ export function createConversationTranscript({ storage, clock = () => new Date()
       await transaction.appendMessage(turnId, {
         role, text: messageText, messageId: id, at: createdAt.toISOString(),
         ...(["assistant", "commentary", "thinking"].includes(role) && normalizeText(outputId) ? { outputId: normalizeText(outputId) } : {}),
-        ...(role === "user" ? { attachments, turnMetadata } : {})
+        ...(role === "user" ? { attachments, turnMetadata, ...(data !== undefined ? { data: structuredClone(data) } : {}) } : {})
       });
       return transaction.readTurn(turnId);
     });

package/src/server/hosts/openCodeProcess.js

@@ -9,6 +9,7 @@ export {
   ensureOpenCodeSession,
   limitOpenCodeModelOutput,
   openCodeApplicationToolSchemas,
+  openCodeConversationAgent,
   openCodeConversationAgents,
   openCodeEnvironmentForDirectory,
   openCodeEnvironmentForSession,

package/test/claudeConversationSession.test.js

@@ -1277,3 +1277,52 @@ for (const change of ["model", "effort"]) test(`Claude honors a consumer's fresh
   assert.match(restoredPrompt, /Continue after the change/);
   assert.match(restoredPrompt, /Continue after restart/);
 });
+
+for (const maxFinalReplyCharacters of [12, 11]) {
+  test("Claude recovered reply enforces configured final limit of " + maxFinalReplyCharacters, async t => {
+    const f = await fixture(t, { limits: { maxFinalReplyCharacters } });
+    await assert.rejects(f.conversation.send({ messageId: "bounded-lost", text: "lost" }));
+    assert.equal((await f.conversation.read()).status, "unconfirmed");
+    const receipt = await f.conversation.inspectDelivery({ messageId: "bounded-lost" });
+    assert.equal(receipt.status, "accepted", "A reply rejection must retain the proven user admission");
+    assert.equal(receipt.recovered, true);
+    const state = await f.conversation.read();
+    const turn = state.conversationLog[0];
+    assert.equal(turn.user.text, "lost");
+    assert.equal(turn.metadata.runtime.status, maxFinalReplyCharacters === 12 ? "interrupted" : "failed");
+    assert.equal(turn.assistant?.text, maxFinalReplyCharacters === 12 ? "Answer: lost" : undefined);
+    if (maxFinalReplyCharacters === 11) assert.match(state.error, /final reply limit/);
+    assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1, "Recovery cannot repeat inference");
+  });
+}
+
+for (const savedStatus of ["cancelled", "failed", "unknown-tool", "interrupted"]) {
+  test("Claude oversized recovery preserves " + savedStatus + " evidence", async t => {
+    const limits = { maxFinalReplyCharacters: 13 };
+    const f = await fixture(t, { limits });
+    await f.conversation.send(input);
+    assert.equal((await f.conversation.wait()).conversationLog[0].assistant.text, "Answer: Hello");
+    await f.first.close();
+    await f.storage.write("conversation", async tx => {
+      const turn = await tx.readTurn("000001");
+      await tx.replaceAssistant(turn.turnId, { ...turn.assistant, text: "" });
+      await tx.updateTurnMetadata(turn.turnId, { runtime: { ...turn.metadata.runtime,
+        status: savedStatus === "unknown-tool" ? "interrupted" : savedStatus,
+        error: savedStatus === "unknown-tool" ? "" : "Exact prior " + savedStatus + " cause." },
+        ...(savedStatus === "unknown-tool" ? { applicationTools: [{ id: "unresolved-tool", status: "unknown" }] } : {}) });
+    });
+    limits.maxFinalReplyCharacters = 11;
+    const reopened = await f.runtime().open({ id: "conversation" });
+    const receipt = await reopened.inspectDelivery({ messageId: input.messageId });
+    assert.equal(receipt.status, "accepted");
+    const state = await reopened.read();
+    assert.equal(state.conversationLog[0].metadata.runtime.status, ["unknown-tool", "interrupted"].includes(savedStatus) ? "failed" : savedStatus);
+    assert.notEqual(state.conversationLog[0].assistant?.text, "Answer: Hello");
+    if (savedStatus === "unknown-tool") {
+      assert.match(state.error, /application tool has no verified result.*Inspect its target/);
+      assert.deepEqual(state.conversationLog[0].metadata.applicationTools, [{ id: "unresolved-tool", status: "unknown" }]);
+    } else if (savedStatus === "interrupted") assert.match(state.error, /final reply limit/);
+    else assert.equal(state.error, "Exact prior " + savedStatus + " cause.");
+    assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1);
+  });
+}