@jskit-ai/assistant-core 0.1.211 → 0.1.213

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.211",
-    "@jskit-ai/http-runtime": "0.1.231",
-    "@jskit-ai/kernel": "0.1.233",
+    "@jskit-ai/assistant-core": "0.1.213",
+    "@jskit-ai/http-runtime": "0.1.233",
+    "@jskit-ai/kernel": "0.1.235",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.1.50",
-    "@jskit-ai/connectors-catalog": "0.1.50"
+    "@jskit-ai/connectors-core": "0.1.52",
+    "@jskit-ai/connectors-catalog": "0.1.52"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.211",
+  "version": "0.1.213",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -47,8 +47,8 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/resource-core": "0.1.175",
-    "@jskit-ai/resource-crud-core": "0.1.175",
+    "@jskit-ai/resource-core": "0.1.177",
+    "@jskit-ai/resource-crud-core": "0.1.177",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -57,8 +57,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.231",
-    "@jskit-ai/kernel": "0.1.233",
+    "@jskit-ai/http-runtime": "0.1.233",
+    "@jskit-ai/kernel": "0.1.235",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/server/conversation/claudeProcess.js

@@ -147,6 +147,10 @@ export function claudeCodeArguments({
     } : {} }));
     if (!applicationTools) args.push("--disallowedTools", "mcp__*");
     if (!toolFree) args.push("--tools", "Bash,Read,Edit,Write,Glob,Grep,NotebookEdit");
+  } else if (applicationTools) {
+    args.push("--mcp-config", JSON.stringify({ mcpServers: {
+      [CLAUDE_APPLICATION_TOOL_SERVER]: { type: "sdk", name: CLAUDE_APPLICATION_TOOL_SERVER }
+    } }));
   }
   if (outputSchema) args.push("--json-schema", JSON.stringify(outputSchema));
   return args;
@@ -318,8 +322,14 @@ export async function createClaudeCodeProcess({
     } } : {});
     return { client, initialization, executionId: native.id, stop };
   } catch (error) {
-    const proof = await stop();
-    error.stopProof = proof;
+    // A rejected start may already own an execution and its cleanup proof.
+    // Only a returned native handle transfers that cleanup to this owner.
+    if (native) {
+      error.executionId = native.id;
+      try { error.stopProof = await stop(); }
+      catch (cleanupError) { error.cleanupError = cleanupError; error.stopProof = { scopeEmpty: false }; }
+      if (error.stopProof?.scopeEmpty !== true) error.cleanupFailed = true;
+    }
     throw error;
   } finally {
     signal?.removeEventListener("abort", abort);

package/src/server/conversation/claudeTools.js

@@ -4,7 +4,7 @@ export const CLAUDE_APPLICATION_TOOL_SERVER = "application";
 
 // The CLI carries this SDK MCP exchange over its existing control pipe. There
 // is no listening socket or separate tool process. The shared executor owns effects.
-export async function claudeApplicationToolResponse(request, { schemas, turn, signal }) {
+export async function claudeApplicationToolResponse(request, { schemas, turn, signal, assertCurrent, onExecutionFailure }) {
   if (request?.subtype !== "mcp_message" || request.server_name !== CLAUDE_APPLICATION_TOOL_SERVER ||
       request.message?.jsonrpc !== "2.0") throw new Error("This Claude control request is not an application tool exchange.");
   const message = request.message;
@@ -31,7 +31,16 @@ export async function claudeApplicationToolResponse(request, { schemas, turn, si
           !isDeepStrictEqual(native.input, params.arguments || {})) {
         throw new Error("Claude's application call does not match an admitted native tool use. Update Claude if its tool identity is unavailable.");
       }
-      const value = await turn.tools.execute({ id, name: params.name, arguments: JSON.stringify(params.arguments || {}) }, { signal, messageId: native.messageId });
+      // Optional supplied-owner checks run after the unchanged native-use
+      // validation. Protocol/stale refusals are not owned executor failures.
+      assertCurrent?.(native);
+      let value;
+      try {
+        value = await turn.tools.execute({ id, name: params.name, arguments: JSON.stringify(params.arguments || {}) }, { signal, messageId: native.messageId });
+      } catch (error) {
+        onExecutionFailure?.(error, native);
+        throw error;
+      }
       result = { content: [{ type: "text", text: JSON.stringify(value) }], isError: value.ok === false };
       break;
     }

package/src/server/conversation/claudeTurn.js

@@ -149,8 +149,20 @@ export function createClaudeConversationOwner({
       phase: entry.turn.active && !entry.observationError ? text(entry.turn.phase) : "" } : null;
   }
 
+  function currentApplicationCommand(entry, command, owner = command?.nativeOwner) {
+    const native = entry?.nativeTurn.read();
+    return Boolean(owner && entry && !closing && !closingSessions.has(entry.context.key) &&
+      entries.get(entry.key) === entry && entry.command === command && command.entry === entry &&
+      command.admitted && !command.signal.aborted && !command.toolFailure &&
+      !entry.disposed && !entry.stopping && !entry.stopPending && !entry.observationError &&
+      entry.process === owner.process && entry.executionId === owner.executionId &&
+      entry.accountIdentity === owner.accountIdentity && entry.id === owner.threadId &&
+      entry.turn?.id === owner.turnId && entry.turn.active && native.turnId === owner.turnId && native.active);
+  }
+
   function readRetainedTurn(contextKey, conversationId, state) {
     const entry = entries.get(`${contextKey}\0${conversationId}`);
+    if (state.current) return currentApplicationCommand(entry, entry?.command) ? snapshot(entry) : null;
     const saved = state.saved;
     return state.nativeResult?.turn || (entry ? snapshot(entry) : saved?.turnId ? {
       id: saved.turnId, threadId: conversationId, state: saved.state,
@@ -158,6 +170,15 @@ export function createClaudeConversationOwner({
     } : null);
   }
 
+  // This lookup uses only the existing current entry and native receipt owner.
+  function readFinalAssistantResult(contextKey, conversationId = "", turnId = "") {
+    if (!text(contextKey) || !text(conversationId) || !text(turnId) || closing || closingSessions.has(contextKey)) return null;
+    const entry = entries.get(`${contextKey}\0${conversationId}`);
+    if (!entry || entry.disposed || entry.stopping || entry.observationError ||
+        entry.id !== conversationId || entry.context.key !== contextKey || entry.turn?.id !== turnId) return null;
+    return entry.nativeTurn.readFinalAssistantResult(conversationId, turnId);
+  }
+
   function readHistory(entry) {
     return readClaudeHistory({ configRoot, workdir: entry.nativeWorkdir, conversationId: entry.id });
   }
@@ -231,6 +252,7 @@ export function createClaudeConversationOwner({
     const account = preparation.account(entry);
     const identity = await account.identity;
     const providerId = account.providerId;
+    if (entry.accountIdentity !== identity) entry.nativeTurn.invalidateFinalAssistantResult();
     try {
       await bindClaudeConversationAccount(entry, { identity, providerId,
         stop: (entry, reason) => entry.nativeTurn.stopProcess(reason), save: saveAccount });
@@ -310,10 +332,27 @@ export function createClaudeConversationOwner({
         }
         await entry.nativeTurn.receive(frame);
       },
-      ...(store.releaseExecution ? {
+      ...(store.releaseExecution || entry.command?.tools ? {
         async onControlRequest(request, { signal }) {
           const active = entry.command;
-          const work = claudeApplicationToolResponse(request, { schemas: entry.toolSchemas || [], turn: active, signal });
+          const suppliedTools = !store.releaseExecution && active?.tools;
+          const owner = active?.nativeOwner;
+          const work = claudeApplicationToolResponse(request, { schemas: entry.toolSchemas || [], turn: active, signal,
+            ...(suppliedTools ? {
+              assertCurrent(native) {
+                if (!currentApplicationCommand(entry, active, owner) || active.nativeOwner !== owner ||
+                    native.messageId !== active.messageId) throw new Error("Claude's application call belongs to a retired input.");
+              },
+              onExecutionFailure(error, native) {
+                // Already-invoked old work retains its original result. Only
+                // this still-current authored input can fail this native run.
+                if (currentApplicationCommand(entry, active, owner) && active.nativeOwner === owner &&
+                    native.messageId === active.messageId) {
+                  active.toolFailure = error;
+                  active.failure.reject(error);
+                }
+              }
+            } : {}) });
           active?.toolWork.add(work);
           try { return await work; }
           finally { active?.toolWork.delete(work); }
@@ -331,13 +370,23 @@ export function createClaudeConversationOwner({
         await entry.nativeTurn.stopProcess(error.message);
       }
     }); } catch (error) {
+      if (error.executionId && error.stopProof?.scopeEmpty !== true && !entry.executionId) {
+        // Streaming startup can fail after host admission, before onStarted.
+        // Retain that custody through the same binding owner for Stop recovery.
+        error.cleanupFailed = true;
+        entry.executionId = error.executionId;
+        try {
+          await store.save(entry, { execution: true });
+          await onEvent(entry, { type: "execution", context, executionId: entry.executionId });
+        } catch (bindingError) { error.bindingError = bindingError; }
+      }
       if (store.releaseExecution && error.stopProof?.scopeEmpty) await store.releaseExecution(entry);
       throw error;
     }
     return entry.process;
   }
 
-  async function send(entry, input = {}, { renewal = false, command } = {}) {
+  async function send(entry, input = {}, { renewal = false, command, applicationCommand } = {}) {
     const message = command ? input.text : text(input.message || input.prompt);
     if (!command && !message) throw createError("Enter a message for Claude.");
     const context = entry.context;
@@ -386,8 +435,17 @@ export function createClaudeConversationOwner({
     entry.onEvent = context.onEvent;
     entry.lastMessageId = uuid;
     const actorMetadata = command ? undefined : await onEvent(entry, { type: "message-metadata", input, context });
+    const nativeOwner = applicationCommand ? { process: native, executionId: entry.executionId,
+      accountIdentity: entry.accountIdentity, threadId: entry.id, turnId: entry.turn.id } : null;
     let conversationTurn;
+    function deliveryResult() {
+      return { ok: true, delivered: true, deliveryMode: steering ? "steer" : "new_turn",
+        thread: { id: entry.id }, turn: snapshot(entry), workdir: context.workdir, conversationTurn };
+    }
     async function accept() {
+      // The new native ACK retires old effect custody while its canonical
+      // admission/commit is awaited; it cannot retag a delayed old failure.
+      if (applicationCommand) applicationCommand.active.nativeOwner = null;
       if (command) {
         if (!steering) await onEvent(entry, { type: "binding-admitted" });
         await command.accept();
@@ -401,6 +459,22 @@ export function createClaudeConversationOwner({
         if (admission) conversationTurn = await admission;
       }
       if (!command) await entry.nativeTurn.updateState("active");
+      if (applicationCommand && conversationTurn) {
+        const value = deliveryResult();
+        applicationCommand.active.delivery = { value, completion: entry.completion?.promise };
+        // The original canonical admission and publication precede Core's same
+        // accepted-request gate; native tools cannot race an unaccepted user.
+        await applicationCommand.accept({ nativeResult: { value }, conversationTurn, nativeTurnId: entry.turn?.id });
+        if (entry.process !== nativeOwner.process || entry.executionId !== nativeOwner.executionId ||
+            entry.accountIdentity !== nativeOwner.accountIdentity || entry.id !== nativeOwner.threadId ||
+            entry.turn?.id !== nativeOwner.turnId || entry.disposed || entry.stopping || entry.stopPending) {
+          throw new Error("Claude's admitted tools no longer belong to this native process.");
+        }
+        applicationCommand.active.nativeOwner = nativeOwner;
+        applicationCommand.active.messageId = messageId;
+        if (steering) applicationCommand.active.nativeToolCount = 0;
+        applicationCommand.active.admitted = true;
+      }
     }
     try {
       if (command) command.attempted = true;
@@ -411,8 +485,7 @@ export function createClaudeConversationOwner({
       if (!command) await entry.nativeTurn.stopProcess(error.message);
       throw error;
     }
-    return { ok: true, delivered: true, deliveryMode: steering ? "steer" : "new_turn",
-      thread: { id: entry.id }, turn: snapshot(entry), workdir: context.workdir, conversationTurn };
+    return deliveryResult();
   }
 
   async function startTurn(entry, input = {}) {
@@ -641,10 +714,19 @@ export function createClaudeConversationOwner({
     }
     command.signal.throwIfAborted();
     const entry = await acquire(command.context);
-    const value = await send(entry, { ...command.input.nativeMessage, onPromptSending: command.beforeDispatch });
+    const active = control.current;
+    const applicationCommand = active?.tools ? { active, accept: command.accept } : null;
+    if (applicationCommand) {
+      if (entry.disposed || entry.command && entry.command !== active) throw new Error("This Claude conversation is closed or already working.");
+      if (active.entry && active.entry !== entry) throw new Error("Claude's application tools belong to another native conversation.");
+      active.entry = entry;
+      entry.command = active;
+      entry.toolSchemas = active.tools.schemas;
+    }
+    const value = await send(entry, { ...command.input.nativeMessage, onPromptSending: command.beforeDispatch }, { applicationCommand });
     const completion = value.conversationTurn ? entry.completion?.promise : null;
     const delivered = { value, completion };
-    if (value.delivered === true && value.conversationTurn) {
+    if (!applicationCommand && value.delivered === true && value.conversationTurn) {
       if (control.current) control.current.delivery = delivered;
       await command.accept({ nativeResult: { value }, conversationTurn: value.conversationTurn, nativeTurnId: value.turn?.id });
     }
@@ -734,12 +816,29 @@ export function createClaudeConversationOwner({
     if (binding) {
       try {
         if (problem || signal.aborted) await (cancellation || entry.nativeTurn.stopProcess(problem?.message || "Work stopped."));
-      } catch (error) { problem = error; }
+      } catch (error) {
+        if (problem && error !== problem) error.cause ||= problem;
+        problem = error;
+      }
       finally {
         await Promise.allSettled([...active.toolWork]);
         if (entry?.command === active) entry.command = null;
       }
-    } else await cancellation?.catch(() => {});
+    } else {
+      await cancellation?.catch(() => {});
+      if (tools && active.entry) {
+        try {
+          if (problem || signal.aborted) await active.entry.nativeTurn.stopProcess(problem?.message || "Work stopped.");
+        } catch (error) {
+          if (problem && error !== problem) error.cause ||= problem;
+          problem = error;
+        }
+        finally {
+          await Promise.allSettled([...active.toolWork]);
+          if (active.entry.command === active) active.entry.command = null;
+        }
+      }
+    }
     if (control.current === active) control.current = null;
     if (problem) {
       if (binding && nativeDispatch.attempted && !nativeDispatch.admitted) problem.delivery = "uncertain";
@@ -748,7 +847,7 @@ export function createClaudeConversationOwner({
     if (!binding) return { value: delivered.value };
   }
 
-  return Object.freeze({ entries, closingSessions, get closing() { return closing; }, createAccountQueries, open, acquire, createConversation, snapshot, readRetainedTurn, readHistory, ensureReady, ensureProcess, stopForTerminal, prepareTerminal, send, startTurn,
+  return Object.freeze({ applicationToolsSupported: true, entries, closingSessions, get closing() { return closing; }, createAccountQueries, open, acquire, createConversation, snapshot, readRetainedTurn, readFinalAssistantResult, readHistory, ensureReady, ensureProcess, stopForTerminal, prepareTerminal, send, startTurn,
     interrupt, read, inspectAdmission, hasActiveTemporaryConversation, hasActiveConversation, retireConversationHistory, reconcileSessions, restoreSessionEntries, closeSession, closeProject, invalidateRuntimes, drain, forget, close, deleteConversation, recover, stopSelected, wait, stopConversation,
     readGoal, updateGoal, renewal, run, steer, cancel });
 }
@@ -773,6 +872,36 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
   let cancelling = false;
   let steering;
   let maximumOutput = 4 * 1024 * 1024;
+  let inputOwner = null;
+  let acceptedInput = null;
+  let publishedAssistant = null;
+  let finalAssistantResult = null;
+
+  function clearFinalAssistantResult() {
+    publishedAssistant = null;
+    finalAssistantResult = null;
+  }
+
+  function invalidateFinalAssistantResult() {
+    inputOwner = null;
+    acceptedInput = null;
+    clearFinalAssistantResult();
+  }
+
+  function currentReceiptOwner(owner) {
+    return Boolean(entry && owner && inputOwner === owner && acceptedInput === owner &&
+      owner.commandId === currentCommandId && entry.process && entry.process === owner.process &&
+      entry.executionId === owner.executionId && entry.accountIdentity === owner.accountIdentity &&
+      entry.turn?.id === turnId && !entry.stopping && !entry.stopPending && !entry.disposed &&
+      !entry.observationError && !entry.command?.toolWork.size && !entry.command?.toolFailure);
+  }
+
+  function readFinalAssistantResult(threadId, expectedTurnId) {
+    if (threadId !== conversationId || expectedTurnId !== turnId || !finalAssistantResult ||
+        active || stopped || cancelling || outcome?.status !== "completed" || outcome.error ||
+        inFlight.size || tasks.size || admissions.size || !currentReceiptOwner(acceptedInput)) return null;
+    return structuredClone(finalAssistantResult);
+  }
 
   function read() {
     return { turnId, active, text: result, phase, status: active ? "inProgress" : outcome?.status || "ready",
@@ -810,6 +939,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
   }
 
   async function stopProcess(reason = "") {
+    invalidateFinalAssistantResult();
     // Runtime bindings commit execution release before dropping the handle.
     // Retained host entries keep their original post-proof checkpoint order.
     const binding = Boolean(process.releaseExecution);
@@ -864,7 +994,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       if (binding) setState(state, event.error);
       else await updateState(state, event.error);
     }
-    await onEvent(event);
+    const published = await onEvent(event);
     if (event.type === "provider-event") {
       const frame = event.event;
       const change = frame.type === "active_goal" ? "goal" : frame.type === "rate_limit_event" ? "usage" : "";
@@ -874,6 +1004,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       if (event.source === "result") await onEvent({ type: "provider-update", change: "goal" });
       entry.completion?.resolve(binding ? event : readResult());
     }
+    return published;
   }
 
   function checkOutput(value, role = "assistant") {
@@ -884,7 +1015,16 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
 
   async function publishMessage(message) {
     messages.set(message.id, message);
-    await publish({ type: "message", message });
+    const owner = acceptedInput;
+    const completeAssistant = message.complete && message.role === "assistant";
+    if (completeAssistant) clearFinalAssistantResult();
+    const conversationTurn = await publish({ type: "message", message });
+    if (completeAssistant && message.text && currentReceiptOwner(owner) && !stopped && !cancelling &&
+        conversationTurn && typeof conversationTurn === "object" && !Array.isArray(conversationTurn)) {
+      publishedAssistant = { owner, itemId: message.id, outputId: message.outputId || message.id,
+        text: message.text, conversationTurn: structuredClone(conversationTurn) };
+    }
+    return conversationTurn;
   }
 
   async function receive(frame) {
@@ -908,9 +1048,12 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
           clearTimeout(pending.timer);
           try {
             await pending.accept();
+            if (inputOwner === pending.receiptOwner && !stopped && !cancelling) acceptedInput = pending.receiptOwner;
             admissions.delete(uuid);
             pending.resolve();
           } catch (error) {
+            acceptedInput = null;
+            clearFinalAssistantResult();
             pending.reject(error);
             throw error;
           }
@@ -988,12 +1131,22 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
         outcome && inFlight.size === 0 && tasks.size === 0) {
       active = false;
       phase = "";
-      await publish({ type: "settled", ...read(), source: frame.type });
+      const candidate = publishedAssistant;
+      finalAssistantResult = outcome.status === "completed" && !outcome.error && !stopped && !cancelling &&
+        admissions.size === 0 && candidate && currentReceiptOwner(candidate.owner) && candidate.text === result
+        ? { threadId: conversationId, turnId, inputMessageId: candidate.owner.commandId,
+          itemId: candidate.itemId, outputId: candidate.outputId, text: candidate.text,
+          conversationTurn: candidate.conversationTurn } : null;
+      try { await publish({ type: "settled", ...read(), source: frame.type }); }
+      catch (error) { clearFinalAssistantResult(); throw error; }
     }
   }
 
   function stop(reason = "Claude stopped before acknowledging the prompt.") {
     stopped = true;
+    inputOwner = null;
+    acceptedInput = null;
+    clearFinalAssistantResult();
     for (const pending of admissions.values()) {
       pending.reject(failure(reason));
     }
@@ -1008,12 +1161,13 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
 
   async function interrupt(client) {
     cancelling = true;
+    clearFinalAssistantResult();
     if (client) await client.interrupt();
     // The process host still must drain its owned scope and call stop().
   }
 
   return Object.freeze({
-    receive, read, stop, interrupt,
+    receive, read, stop, interrupt, readFinalAssistantResult, invalidateFinalAssistantResult,
     ...(entry ? { readResult, updateState, stopProcess } : {}),
     ...(instructions ? {
       prepare: instructions.prepare,
@@ -1024,6 +1178,9 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     begin({ id, maxOutputCharacters = 4 * 1024 * 1024 } = {}) {
       if (active) throw failure("This Claude turn is still working.");
       if (!id || !Number.isSafeInteger(maxOutputCharacters) || maxOutputCharacters < 1) throw new TypeError("Invalid Claude turn configuration.");
+      inputOwner = null;
+      acceptedInput = null;
+      clearFinalAssistantResult();
       turnId = id;
       maximumOutput = maxOutputCharacters;
       messages.clear();
@@ -1041,10 +1198,18 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       messages.clear();
       result = "";
       outcome = null;
+      inputOwner = null;
+      acceptedInput = null;
+      clearFinalAssistantResult();
     },
     async send(client, message, { messageId: uuid, accept, timeoutMs = 30_000 } = {}) {
       if (!active || stopped || cancelling) throw failure("Claude has no active turn for this message.");
       if (!uuid || typeof accept !== "function" || admissions.has(uuid)) throw new TypeError("A distinct message id and admission writer are required.");
+      clearFinalAssistantResult();
+      acceptedInput = null;
+      inputOwner = entry ? { commandId: uuid, process: entry.process, executionId: entry.executionId,
+        accountIdentity: entry.accountIdentity } : null;
+      const receiptOwner = inputOwner;
       const admitted = Promise.withResolvers();
       void admitted.promise.catch(() => {});
       inFlight.add(uuid);
@@ -1052,9 +1217,12 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
         failure("Claude has not acknowledged this prompt. Its delivery is uncertain.", "assistant_claude_admission_unknown"),
         { delivery: "uncertain" }
       )), timeoutMs);
-      admissions.set(uuid, { ...admitted, accept, timer });
+      admissions.set(uuid, { ...admitted, accept, timer, receiptOwner });
       try {
         await Promise.all([client.send(message, { messageId: uuid, sessionId: conversationId }), admitted.promise]);
+      } catch (error) {
+        if (inputOwner === receiptOwner) invalidateFinalAssistantResult();
+        throw error;
       } finally {
         clearTimeout(timer);
       }
@@ -1064,6 +1232,8 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       // Streaming user input otherwise queues behind the entire running turn.
       // Claude's supported steering path interrupts generation, then continues
       // the same native history with the new instruction.
+      acceptedInput = null;
+      clearFinalAssistantResult();
       steering = Promise.withResolvers();
       let timer;
       try {

package/src/server/conversation/openCodeRuntime.js

@@ -908,13 +908,17 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
 
   async function writeConversationProjection(sessionId, messages = null, {
     inputMessageId = "",
-    streaming = false
+    streaming = false,
+    captureFinalAssistantResult = false
   } = {}, projection) {
     let failure = "";
+    let finalAssistantResult = null;
     let providerApiFailure = false;
     const rows = (inputMessageId
       ? openCodeRowsForInput(messages, inputMessageId)
       : openCodeMessageRows(messages)).filter((message) => message?.type === "assistant");
+    const finalNativeMessage = captureFinalAssistantResult && !streaming
+      ? openCodeLastAssistantResult(rows, { readError: projection.readError }).message : null;
     for (const [index, message] of rows.entries()) {
       failure ||= projection.readError(message);
       providerApiFailure ||= openCodeProviderApiFailure(message.error);
@@ -967,9 +971,31 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         });
         projection.store.completeConversationStreamMessage(sessionId, messageId);
         await projection.publishTurn(turn);
+        if (message === finalNativeMessage && !projection.readError(message) &&
+            (message.time?.completed || message.finish) && turn) {
+          finalAssistantResult = { inputMessageId: text(inputMessageId), itemId: text(message.id),
+            text: assistantText, conversationTurn: turn };
+        }
       }
     }
-    return { failure, providerApiFailure };
+    return { failure, providerApiFailure, ...(captureFinalAssistantResult ? { finalAssistantResult } : {}) };
+  }
+
+  // Evidence belongs to the exact retained native turn. This read never creates,
+  // observes, resumes or projects a native conversation.
+  function readFinalAssistantResult(key, threadId = "", turnId = "") {
+    const turn = turns.get(key);
+    const result = turn?.finalAssistantResult;
+    const target = turn?.finalAssistantResultTarget;
+    if (!target || processes.get(key) !== target || target.abortController.signal.aborted ||
+        !turn.finalAssistantResultProcess || sharedProcess !== turn.finalAssistantResultProcess ||
+        target.upstreamSessionId !== turn.threadId) return null;
+    if (!text(threadId) || !text(turnId) || !result || turn.active || turn.state !== "completed" ||
+        turn.error || turn.observationError || turn.interruptRequested || turn.interruptAcknowledged ||
+        turn.threadId !== text(threadId) || turn.id !== text(turnId) ||
+        result.threadId !== text(threadId) || result.turnId !== text(turnId) ||
+        result.inputMessageId !== text(turn.inputMessageId) || !result.conversationTurn) return null;
+    return structuredClone(result);
   }
 
   async function sendMessage(key, input, options, application) {
@@ -1232,6 +1258,15 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     observe, observation, eventReady, readiness, finalResponse,
     writeRun, projectMessages, completeResult, onRetired
   }) {
+    delete turn.finalAssistantResult;
+    delete turn.finalAssistantResultTarget;
+    delete turn.finalAssistantResultProcess;
+    const registeredTarget = processes.get(key);
+    const finalAssistantResultTarget = registeredTarget &&
+      registeredTarget.abortController === target.abortController &&
+      registeredTarget.server === target.server &&
+      registeredTarget.upstreamSessionId === target.upstreamSessionId ? registeredTarget : null;
+    const finalAssistantResultProcess = finalAssistantResultTarget ? sharedProcess : null;
     turns.set(key, turn);
     const signal = AbortSignal.any([target.abortController.signal, turn.abortController.signal]);
     const monitor = Promise.resolve().then(async () => {
@@ -1243,6 +1278,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       }
       let finalState = "completed";
       let failure = "";
+      let finalAssistantResult = null;
       let credentialFailure = false;
       let providerApiFailure = false;
       try {
@@ -1285,7 +1321,8 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
             continue;
           }
           const projection = await projectMessages(completion.messages, {
-            inputMessageId: completion.inputMessageId
+            inputMessageId: completion.inputMessageId,
+            captureFinalAssistantResult: true
           });
           await turn.admission?.promise;
           signal.throwIfAborted();
@@ -1303,6 +1340,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
           } else if (turn.interruptRequested) {
             finalState = "interrupted";
           }
+          const published = projection.finalAssistantResult;
+          if (finalState === "completed" && !failure && published &&
+              published.inputMessageId === completion.inputMessageId &&
+              published.itemId === completion.result?.turnId &&
+              text(published.text) === text(completion.result?.text)) {
+            finalAssistantResult = { ...published, threadId: turn.threadId, turnId: turn.id };
+          }
           break;
         }
       } catch (error) {
@@ -1341,6 +1385,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         }
         turn.error = failure;
         turn.state = finalState;
+        turn.finalAssistantResult = finalState === "completed" && !failure ? finalAssistantResult : null;
+        turn.finalAssistantResultTarget = turn.finalAssistantResult ? finalAssistantResultTarget : null;
+        turn.finalAssistantResultProcess = turn.finalAssistantResult ? finalAssistantResultProcess : null;
         turn.updatedAt = new Date().toISOString();
         await writeRun(turn, finalState, failure).catch(() => null);
       }
@@ -1615,7 +1662,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     ensurePreparedSessionReadiness, inspectSessionReadiness, recoverSessionReadiness, needsObservationRecovery, recoverObservation,
     createConversation, selectConversation, existingConversation, runConversationTurn, readConversation, readPersistentConversation, waitForConversationTurn,
     stopConversation, deleteConversation, sendMessage, hasActiveTemporaryConversation, reconcileSessions, reconcilePreparedSession, recordStoppedObservation, beginMessageMonitor, beginMonitor, writeBindings,
-    writeConversationProjection,
+    writeConversationProjection, readFinalAssistantResult,
     projectConversationMessages: projectOpenCodeConversationMessages,
     readSessionState, startPreparedTerminal, attachTerminal, closeTerminal, allowTerminalAttachments,
     turnSnapshot: openCodeTurnSnapshot, providerApiFailure: openCodeProviderApiFailure

package/src/server/conversation/runtime.js

@@ -910,7 +910,12 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
           // Calls already in flight retain their actor and turn. Keep application
           // mutations ordered across steering as well as within each request.
           const work = toolWork.then(() => request.tools.execute(input, options));
-          toolWork = work.catch(error => { toolFailure ||= error; });
+          toolWork = work.catch(error => {
+            // Claude accepts a separate successor query; its predecessor's
+            // effect cannot fail that query. Other engines retain the original
+            // active-turn failure guard across steering.
+            if (engine !== "claude" || current === request) toolFailure ||= error;
+          });
           return work;
         }
       };