@jskit-ai/assistant-core 0.1.213 → 0.1.215

package/examples/conversation/package.json

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

package/fixtures/responsive-assistant/ConversationFixture.vue

@@ -16,6 +16,8 @@ const previewCanTake = ref(true);
 const previewDelivery = createAssistantMessageDelivery();
 const avatarFixture = new URLSearchParams(location.search).has("avatar");
 const avatarToolsFixture = new URLSearchParams(location.search).has("avatarTools");
+const updateErrorFixture = new URLSearchParams(location.search).has("update-errors");
+const errorReloads = ref(0);
 const showAvatar = ref(avatarFixture);
 const avatarSize = ref("compact");
 const short = ref(avatarFixture);
@@ -136,7 +138,8 @@ const adapter = reactive({
       assistant: { messageId: `answer-${index}`, outputId: `output-${index}`, role: "assistant",
         text: `Support answer ${index + 1}: Keep your recovery email available.\n\nRead the **account instructions** and follow the [recovery link](https://example.com/help). A long message wraps inside this narrow conversation without taking space from the composer.` }
     })) : [],
-    visible: true, reloadable: avatarFixture, scrollKey: "fixture", welcomeMessage: "Composer responsiveness fixture"
+    visible: true, reloadable: avatarFixture && !updateErrorFixture, error: "", errorReloadable: updateErrorFixture,
+    scrollKey: "fixture", welcomeMessage: "Composer responsiveness fixture"
   },
   composer: {
     draft,
@@ -153,6 +156,7 @@ const adapter = reactive({
   models: capabilitiesEnabled ? models : undefined,
   questions: computed(() => showQuestions.value ? questionState : undefined),
   actions: {
+    reload() { errorReloads.value += 1; adapter.conversation.error = ""; },
     setDraft(value) { draft.value = value; },
     submit(payload) { attachmentReceipts.value = payload.attachments; attachments.clearAttachments(); submissions.value += 1; draft.value = ""; phase.value = "active"; },
     stop() { phase.value = "stopping"; }
@@ -166,6 +170,8 @@ const adapter = reactive({
         <button v-if="attribution" @click="assistantLabel = 'Next assistant'">Change assistant</button>
         <button v-for="state in ['idle', 'active', 'reconnecting', 'stopping', 'stopped']" :key="state" @click="phase = state">External {{ state }}</button>
         <button @click="narrow = !narrow">Resize pane</button>
+        <button v-if="updateErrorFixture" @click="adapter.conversation.error = 'Conversation updates are temporarily unavailable. Reload to reconnect; the assistant may still be working.'">Show update error</button>
+        <output v-if="updateErrorFixture">Error reloads: {{ errorReloads }}</output>
         <button @click="feedback = !feedback">Toggle action feedback</button>
         <button v-if="supportEnabled" @click="suggestionModel = 'other-model'">Change suggestion model</button>
         <button v-if="supportEnabled" @click="customActivity = !customActivity">Custom activity</button>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.213",
+  "version": "0.1.215",
   "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.177",
-    "@jskit-ai/resource-crud-core": "0.1.177",
+    "@jskit-ai/resource-core": "0.1.179",
+    "@jskit-ai/resource-crud-core": "0.1.179",
     "@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.233",
-    "@jskit-ai/kernel": "0.1.235",
+    "@jskit-ai/http-runtime": "0.1.235",
+    "@jskit-ai/kernel": "0.1.237",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/client/conversation/AssistantConversationElement.vue

@@ -1,5 +1,5 @@
 <template>
-  <section ref="container" class="assistant-conversation" :aria-label="label">
+  <section ref="container" class="assistant-conversation" :class="{ 'assistant-conversation--error': conversation.error }" :aria-label="label">
     <section
       v-if="$slots.avatar" class="assistant-conversation__avatar"
       :class="{ 'assistant-conversation__avatar--hidden': avatarSize === 'hidden' }" aria-label="Conversation avatar"
@@ -389,7 +389,10 @@ defineExpose({ focus: () => input.value?.focus(), submit, stop });
 <style scoped>
 .assistant-conversation__preview-actions { display: flex; justify-content: flex-end; }
 .assistant-conversation { position: relative; display: flex; flex-direction: column; min-height: 0; min-width: 0; height: 100%; gap: 0; container: assistant-conversation / inline-size; }
+.assistant-conversation--error { overflow-y: auto; }
 .assistant-conversation__avatar { position: absolute; top: 0; right: 0; z-index: 3; max-width: 100%; min-width: 0; }
+.assistant-conversation--error .assistant-conversation__avatar { position: relative; align-self: flex-end; flex: 0 0 auto; }
+.assistant-conversation--error .assistant-conversation__avatar-controls { position: static; }
 .assistant-conversation__avatar-controls { position: absolute; top: 0; right: 100%; display: flex; align-items: center; justify-content: flex-end; min-height: 44px; }
 .assistant-conversation__avatar--hidden .assistant-conversation__avatar-controls { right: 0; }
 .assistant-conversation__avatar-size { min-width: 44px; min-height: 44px; }
@@ -401,6 +404,7 @@ defineExpose({ focus: () => input.value?.focus(), submit, stop });
 .assistant-conversation__avatar-visual :deep(> *) { max-width: 100%; max-height: 100%; }
 .assistant-conversation__goal { display: flex; justify-content: flex-end; flex: 0 0 auto; }
 .assistant-conversation__transcript { flex: 1 1 auto; min-height: 0; }
+.assistant-conversation--error .assistant-conversation__transcript { min-height: min-content; }
 .assistant-conversation__composer { flex: 0 0 auto; }
 .assistant-conversation__attachment-error { flex-basis: 100%; margin: 0; }
 .assistant-conversation__setting { min-width: 8rem; max-width: 16rem; }

package/src/client/conversation/AssistantTranscript.vue

@@ -440,6 +440,9 @@ const KEYBOARD_SCROLL_KEYS = new Set([
   "Spacebar"
 ]);
 const timeFormatter = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  month: "short",
+  day: "2-digit",
   hour: "2-digit",
   minute: "2-digit"
 });
@@ -1103,7 +1106,12 @@ watch(() => props.visible, (visible) => {
 }
 
 .assistant-transcript--error {
-  grid-template-rows: auto minmax(0, 1fr);
+  grid-template-rows: max-content minmax(0, 1fr);
+  min-height: min-content;
+}
+
+.assistant-transcript--error .assistant-transcript__body {
+  contain: size;
 }
 
 .assistant-transcript__error {
@@ -1115,6 +1123,7 @@ watch(() => props.visible, (visible) => {
 .assistant-transcript__error-content {
   align-items: flex-start;
   display: flex;
+  flex-direction: column;
   gap: 0.5rem;
 }
 

package/src/server/conversation/agentRun.js

@@ -1,5 +1,6 @@
 import { isPlainObject, normalizeText } from "./normalize.js";
 import { createReentrantConversationStorage } from "./storage.js";
+import { isCompletedEnvelopeTurn } from "./transcript.js";
 import { normalizeCodexAppServerRunState, codexAppServerRunStateIsActive,
   codexAppServerRunStateIsTerminal } from "./codexTurn.js";
 
@@ -134,7 +135,7 @@ export function createCodexConversationStore({ storage, scope, segmentId, isCurr
     assertCurrent(sessionId);
     return transcript[name](sessionId, ...args);
   };
-  async function nativeOrigin(transaction, identity) {
+  async function nativeAuthorship(transaction, identity) {
     if (!identity?.threadId || !identity.turnId) return undefined;
     const { runtime } = await transaction.readMetadata();
     const run = runtime.binding?.codexAppServerRun;
@@ -143,17 +144,32 @@ export function createCodexConversationStore({ storage, scope, segmentId, isCurr
     for (const turnId of (await transaction.listTurnIds()).reverse()) {
       const turn = await transaction.readTurn(turnId);
       if (turn?.metadata?.runtime?.segmentId !== segmentId) continue;
-      if (turn.user?.messageId === run.outerTurnId) return "user";
-      if (turn.system?.messageId === run.outerTurnId && turn.system.origin === "application") return "application";
+      if (turn.user?.messageId === run.outerTurnId) return { origin: "user", messageId: run.outerTurnId, turnId };
+      if (turn.system?.messageId === run.outerTurnId && turn.system.origin === "application") {
+        return { origin: "application", messageId: run.outerTurnId, turnId,
+          ...(isCompletedEnvelopeTurn(turn) ? { completedEnvelope: true } : {}) };
+      }
     }
     const request = runtime.request;
-    if (request?.messageId === run.outerTurnId && ["user", "application"].includes(request.origin)) return request.origin;
+    if (request?.messageId === run.outerTurnId && ["user", "application"].includes(request.origin)) {
+      return { origin: request.origin, messageId: request.messageId,
+        ...(request.origin === "application" && request.completedEnvelope === true ? { completedEnvelope: true } : {}) };
+    }
     return undefined;
   }
-  const writer = name => (sessionId, input) => runStore.mutateSession(sessionId, async transaction => {
-    const written = await transcript[name](sessionId, input);
+  const writer = name => (sessionId, input = {}) => runStore.mutateSession(sessionId, async transaction => {
+    const authorship = await nativeAuthorship(transaction, input.nativeIdentity);
+    if (authorship?.completedEnvelope && !authorship.turnId) {
+      throw new Error("The native output's original turn no longer exists.");
+    }
+    // Queued human rows do not own an already admitted private native response.
+    // Corrections retain their original explicit target and message identity.
+    const written = await transcript[name](sessionId, {
+      ...input, ...(name !== "upsertConversationAssistantMessage" && authorship?.completedEnvelope && authorship.turnId
+        ? { turnId: authorship.turnId } : {})
+    });
     if (!written || written.metadata?.runtime?.segmentId) return written;
-    const origin = await nativeOrigin(transaction, input.nativeIdentity);
+    const origin = authorship?.origin;
     await transaction.updateTurnMetadata(written.turnId, { runtime: {
       status: "complete", engine: "codex", segmentId, ...(origin ? { origin } : {}),
       ...(input.nativeIdentity?.turnId ? { nativeTurnId: input.nativeIdentity.turnId } : {})
@@ -191,6 +207,8 @@ export function createCodexConversationStore({ storage, scope, segmentId, isCurr
           ...(request.data !== undefined ? { data: request.data } : {}), ...(request.goal ? { goal: request.goal } : {}),
           turnMetadata: { ...input.turnMetadata, runtime: { ...input.turnMetadata?.runtime,
             status: "running", engine: "codex", segmentId, origin: request.origin || "user",
+            ...(metadata.runtime.request?.messageId === input.messageId && metadata.runtime.request.completedEnvelope === true
+              ? { completedEnvelope: true } : {}),
             ...(input.nativeIdentity?.turnId ? { nativeTurnId: input.nativeIdentity.turnId } : {}),
             ...(request.goal ? { goalMessageId: request.messageId } : {}) } }
         });
@@ -212,11 +230,20 @@ export function createCodexConversationStore({ storage, scope, segmentId, isCurr
       });
     },
     updateConversationStream(sessionId, input) {
-      return runStore.mutateSession(sessionId, async transaction => streams.update(sessionId, {
-        ...input, origin: await nativeOrigin(transaction, input.nativeIdentity)
-      }));
+      return runStore.mutateSession(sessionId, async transaction => {
+        const authorship = await nativeAuthorship(transaction, input.nativeIdentity);
+        return streams.update(sessionId, { ...input, origin: authorship?.origin, authorship });
+      });
+    },
+    completeConversationStreamMessage(sessionId, messageId, options) {
+      assertCurrent(sessionId);
+      if (options?.nativeIdentity) return runStore.mutateSession(sessionId, async transaction => {
+        const authorship = await nativeAuthorship(transaction, options.nativeIdentity);
+        return streams.complete(sessionId, messageId, { ...options, authorship,
+          ...(!authorship ? { text: undefined } : {}) });
+      });
+      return streams.complete(sessionId, messageId, options);
     },
-    completeConversationStreamMessage(sessionId, messageId) { assertCurrent(sessionId); return streams.complete(sessionId, messageId); },
     clearConversationStream(sessionId) { assertCurrent(sessionId); return streams.clear(sessionId); }
   });
 }

package/src/server/conversation/claudeHistory.js

@@ -87,7 +87,11 @@ function claudeMessageBlocks(frame, { includeNested = false } = {}) {
 
 async function readClaudeHistory(options) {
   const file = await claudeHistoryPath(options);
-  if (!file || file.size === 0) return { exists: false, messages: [], userIds: [], text: "" };
+  const inspected = {
+    ...(options.includeUserMessages ? { userMessages: [] } : {}),
+    ...(options.includeFinalCarriers ? { completedResults: [], failedResults: [], structuredOutputs: [] } : {})
+  };
+  if (!file || file.size === 0) return { exists: false, messages: [], userIds: [], text: "", ...inspected };
   if (file.size > 256 * 1024 * 1024) throw new Error("Claude history exceeds the supported read limit.");
   const messages = new Map();
   const userIds = [];
@@ -98,9 +102,10 @@ async function readClaudeHistory(options) {
   let leafUuid = "";
   let rewound = false;
   // Snapshot the file length. A writer can be in the middle of its last frame;
-  // only this native-history read allows that unfinished tail.
+  // Live history reads allow that unfinished tail. Stopped maintenance can
+  // require the existing strict parser without changing live observation.
   for await (const frame of readClaudeJsonFrames(createReadStream(file.path, { end: file.size - 1 }), {
-    allowIncompleteTail: true
+    allowIncompleteTail: options.allowIncompleteTail ?? true
   })) {
     if (frame.isSidechain) continue;
     frames.push(frame);
@@ -139,12 +144,42 @@ async function readClaudeHistory(options) {
         (typeof frame.message?.content === "string" || frame.message?.content?.some((block) => block.type === "text"))) {
       userIds.push(frame.uuid);
       lastUserId = frame.uuid;
+      if (options.includeUserMessages && !frame.parent_tool_use_id) {
+        const content = frame.message.content;
+        const text = typeof content === "string" ? content : content
+          .filter(block => block.type === "text" && typeof block.text === "string").map(block => block.text).join("\n\n");
+        inspected.userMessages.push({ id: frame.uuid, text });
+      }
+    }
+    if (options.includeFinalCarriers && !frame.parent_tool_use_id && !frame.isMeta) {
+      if (frame.type === "result" && frame.subtype === "success" && !frame.is_error &&
+          !["aborted_streaming", "aborted_tools"].includes(frame.terminal_reason)) {
+        // Same final normalization as the live native turn; this is an actual
+        // saved result, never a result invented from a tool-use candidate.
+        const text = typeof frame.structured_output === "object" ? JSON.stringify(frame.structured_output) : String(frame.result || "");
+        inspected.completedResults.push({ id: frame.uuid || "", userId: lastUserId, text });
+      } else if (frame.type === "result") {
+        // Preserve the live terminal-failure/interruption contradiction without
+        // copying native error details into stopped application inspection.
+        inspected.failedResults.push({ id: frame.uuid || "", userId: lastUserId });
+      }
+      if (frame.type === "assistant") {
+        for (const block of frame.message?.content || []) {
+          if (block.type === "tool_use" && block.name === "StructuredOutput" && typeof block.id === "string" && block.id &&
+              block.input && typeof block.input === "object" && !Array.isArray(block.input)) {
+            // Raw native carrier only. A stopped importer must independently
+            // verify the original completed receipt and exact final/user custody.
+            inspected.structuredOutputs.push({ id: frame.uuid || "", userId: lastUserId,
+              toolUseId: block.id, text: JSON.stringify(block.input) });
+          }
+        }
+      }
     }
     for (const message of claudeMessageBlocks(frame)) {
       messages.set(message.id, { ...message, userId: lastUserId });
     }
   }
-  return { exists: true, messages: [...messages.values()], userIds, goal,
+  return { exists: true, messages: [...messages.values()], userIds, goal, ...inspected,
     text: [...messages.values()].filter((message) => message.role === "assistant" && message.userId === lastUserId)
       .map((message) => message.text).join("\n") };
 }
@@ -155,7 +190,7 @@ export async function deleteClaudeConversationHistory({ configRoot, workdir, con
   if (file) await rm(file.path, { force: true });
 }
 
-export { claudeMessageBlocks, readClaudeHistory, requireClaudeSessionId, archivedClaudeProjectDirectory, matchingClaudeProjectDirectories };
+export { claudeHistoryPath, claudeMessageBlocks, readClaudeHistory, requireClaudeSessionId, archivedClaudeProjectDirectory, matchingClaudeProjectDirectories };
 
 const TRANSCRIPT_PATH_PATTERN = /\.jsonl(?:\.(?:superseded|orphaned)-.*)?$/u;
 

package/src/server/conversation/claudeProcess.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { nativeAiProvider } from "../../shared/nativeProviders.js";
 import { Duplex } from "node:stream";
 import { stat } from "node:fs/promises";
@@ -65,6 +66,11 @@ async function readNativeClaudeCodeAuthStatus({ env, credentialHome, command, co
   }
 }
 
+/** Exact existing native connection pin, shared with stopped metadata conversion. */
+export function claudeConnectionIdentity(configRoot, providerId, baseUrl, apiKey) {
+  return createHash("sha256").update(JSON.stringify([configRoot, providerId, baseUrl, apiKey])).digest("hex");
+}
+
 /** Native provider routing; the application supplies only its authorized selection. */
 export function claudeModelConfiguration({ providerId, model: modelId }, connection) {
   const provider = nativeAiProvider(providerId);
@@ -305,7 +311,7 @@ export async function createClaudeCodeProcess({
     signal?.throwIfAborted();
     native = await execution.start({ command, args: claudeCodeArguments(options), cwd: workdir,
       env: environment, stream: true, limits: executionLimits });
-    await onStarted?.(native.id);
+    await onStarted?.(native.id, stop);
     signal?.throwIfAborted();
     client = createClaudeJsonClient({ stream: Duplex.from({ readable: native.stdout, writable: native.stdin }), onEvent, onFailure,
       onControlRequest(request, context) {
@@ -317,9 +323,17 @@ export async function createClaudeCodeProcess({
       }
     });
     signal?.addEventListener("abort", abort, { once: true });
-    const initialization = await client.initialize(commandWrapper ? { hooks: {
+    const initializing = client.initialize(commandWrapper ? { hooks: {
       PreToolUse: [{ matcher: "^Bash$", hookCallbackIds: ["jskit-command-wrapper"], timeout: 30 }]
     } } : {});
+    const initialization = await (native.exited ? Promise.race([
+      initializing,
+      native.exited.then(processExit => {
+        throw Object.assign(new Error("Claude exited before initialization completed."), {
+          code: "assistant_claude_startup_exited", processExit
+        });
+      })
+    ]) : initializing);
     return { client, initialization, executionId: native.id, stop };
   } catch (error) {
     // A rejected start may already own an execution and its cleanup proof.

package/src/server/conversation/claudeTurn.js

@@ -203,7 +203,7 @@ export function createClaudeConversationOwner({
     if (saved && typeof saved.then === "function") saved = await saved;
     if (!main && !saved && !create && !recoveringCleanup) throw createError("This Claude conversation is unavailable.");
     const state = saved ? JSON.parse(saved) : {};
-    const entry = { id, key, main, persistent: state.persistent === true, context, process: null,
+    const entry = { id, key, main, persistent: state.persistent === true, context, process: null, startupCleanup: null,
       executionId: state.executionId || (recoveringCleanup ? cleanupExecutionId : ""),
       accountIdentities: state.accountIdentities || (state.accountIdentity ? { anthropic: state.accountIdentity } : {}),
       accountIdentity: state.accountIdentity || "", sent: state.sent === true, nativeWorkdir: state.nativeWorkdir || nativeWorkdir,
@@ -312,7 +312,9 @@ export function createClaudeConversationOwner({
     if (options && typeof options.then === "function") options = await options;
     try { entry.process = await createProcess({ ...options,
       workdir: entry.nativeWorkdir, sessionId: entry.id, resume: entry.sent,
-      onStarted: async executionId => {
+      onStarted: async (executionId, stop) => {
+        if (typeof stop === "function") entry.startupCleanup = { executionId, stop };
+        if (entry.executionId === executionId) return;
         entry.executionId = executionId;
         await store.save(entry, { execution: true });
         await onEvent(entry, { type: "execution", context, executionId });
@@ -380,9 +382,13 @@ export function createClaudeConversationOwner({
           await onEvent(entry, { type: "execution", context, executionId: entry.executionId });
         } catch (bindingError) { error.bindingError = bindingError; }
       }
-      if (store.releaseExecution && error.stopProof?.scopeEmpty) await store.releaseExecution(entry);
+      if (store.releaseExecution && error.stopProof?.scopeEmpty) {
+        await store.releaseExecution(entry);
+        if (entry.startupCleanup?.executionId === error.executionId) entry.startupCleanup = null;
+      }
       throw error;
     }
+    if (entry.startupCleanup?.executionId === entry.executionId) entry.startupCleanup = null;
     return entry.process;
   }
 
@@ -461,7 +467,14 @@ export function createClaudeConversationOwner({
       if (!command) await entry.nativeTurn.updateState("active");
       if (applicationCommand && conversationTurn) {
         const value = deliveryResult();
-        applicationCommand.active.delivery = { value, completion: entry.completion?.promise };
+        const active = applicationCommand.active;
+        const previousCompletion = active.completion;
+        if (active.finishIfCurrent) {
+          active.completion = Promise.withResolvers();
+          active.completion.promise.catch(() => {});
+        }
+        active.delivery = { value, completion: active.finishIfCurrent ? active.completion.promise : entry.completion?.promise };
+        if (active.finishIfCurrent) previousCompletion.resolve();
         // 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 });
@@ -715,13 +728,13 @@ export function createClaudeConversationOwner({
     command.signal.throwIfAborted();
     const entry = await acquire(command.context);
     const active = control.current;
-    const applicationCommand = active?.tools ? { active, accept: command.accept } : null;
+    const applicationCommand = active && (active.tools || active.finishIfCurrent) ? { 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;
+      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;
@@ -742,12 +755,12 @@ export function createClaudeConversationOwner({
   async function run(control, command, { acquire, reportFailure, entry: selectedEntry, maximumOutput, maximumToolCalls = 32, timeoutMs } = {}) {
     if (control.disposed || control.current) throw new Error("This Claude conversation is closed or already working.");
     const binding = Boolean(store.releaseExecution);
-    const { configuration, context, input, tools, signal, beforeDispatch, accept, onMessage, onEvent } = command;
+    const { configuration, context, input, tools, signal, beforeDispatch, accept, onMessage, onEvent, onNativeToolUse } = command;
     const completion = Promise.withResolvers();
     completion.promise.catch(() => {});
-    const active = { completion, onMessage, onEvent, signal, tools, admitted: false, nativeTools: new Map(),
+    const active = { completion, onMessage, onEvent, onNativeToolUse, signal, tools, admitted: false, nativeTools: new Map(),
       messageId: input.messageId, goal: input.goal, nativeToolCount: 0, toolWork: new Set(), maximumToolCalls,
-      context, failure: Promise.withResolvers() };
+      context, finishIfCurrent: command.finishIfCurrent, failure: Promise.withResolvers() };
     let failure;
     active.failure.promise.catch(error => { failure = error; });
     control.current = active;
@@ -804,6 +817,10 @@ export function createClaudeConversationOwner({
           catch (error) { problem = error; }
         }
         if (command.finishIfCurrent && !await command.finishIfCurrent(() => active.delivery === settling)) continue;
+        if (!problem && typeof result === "function") {
+          try { result = await result(); }
+          catch (error) { problem = error; }
+        }
         problem = dispatchFailure || failure || problem;
         if (!problem && settling?.completion && (binding ? result.status !== "completed" : !result.ok)) {
           problem = Object.assign(new Error(result.error || (binding ? "Claude interrupted this answer." : `Claude turn ${result.status}.`)), { status: result.status });
@@ -826,7 +843,7 @@ export function createClaudeConversationOwner({
       }
     } else {
       await cancellation?.catch(() => {});
-      if (tools && active.entry) {
+      if (active.entry) {
         try {
           if (problem || signal.aborted) await active.entry.nativeTurn.stopProcess(problem?.message || "Work stopped.");
         } catch (error) {
@@ -921,6 +938,11 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       messages: current.messages, error: entry.turn?.error || "", status };
   }
 
+  function resolveCompletion(result) {
+    entry.completion?.resolve(result);
+    if (entry.command?.finishIfCurrent) entry.command.completion.resolve(result);
+  }
+
   async function updateState(state, message = "") {
     if (!entry.turn) return;
     const active = ["starting", "active", "finalizing"].includes(state);
@@ -947,10 +969,11 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     const active = read().active;
     if (!binding) entry.stopping = true;
     const operation = async () => {
+      const startup = entry.startupCleanup?.executionId === entry.executionId ? entry.startupCleanup : null;
       let proof;
       try {
         if (!binding || entry.process || entry.executionId) {
-          proof = await stopClaudeCodeProcess({ process: entry.process, executionId: entry.executionId,
+          proof = await stopClaudeCodeProcess({ process: entry.process || startup, executionId: entry.executionId,
             stopExecution: process.stopExecution });
         }
       } catch (error) {
@@ -966,12 +989,25 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       entry.exitProof = proof;
       stop(binding ? reason : reason || "Claude stopped before acknowledging the prompt.");
       if (binding) {
+        if (entry.startupCleanup === startup) entry.startupCleanup = null;
         if (active) entry.completion?.resolve({ status: "interrupted", error: reason || "Work stopped." });
         return;
       }
-      if (entry.turn?.active) await updateState("interrupted", reason);
-      else await onEvent({ type: "save" });
-      entry.completion?.resolve(readResult());
+      if (entry.turn?.active) {
+        try { await updateState("interrupted", reason); }
+        catch (error) {
+          // Native cleanup is verified even when the host refuses its checkpoint.
+          // Retain that refusal without publishing a completed answer or active work.
+          setState("interrupted", error.message);
+          await onEvent({ type: "save" });
+          await onEvent({ type: "state", state: "interrupted", active: false, message: error.message });
+          resolveCompletion(readResult());
+          if (entry.startupCleanup === startup) entry.startupCleanup = null;
+          throw error;
+        }
+      } else await onEvent({ type: "save" });
+      resolveCompletion(readResult());
+      if (entry.startupCleanup === startup) entry.startupCleanup = null;
       return entry.exitProof;
     };
     if (!binding) return operation();
@@ -980,9 +1016,32 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     return entry.stopPending;
   }
 
-  async function publishEntryEvent(event) {
+  async function publishEntryEvent(event, deferred = false) {
     if (entry.stopping) return;
     const binding = Boolean(process.releaseExecution);
+    const command = entry.command;
+    if (event.type === "settled" && !binding && !deferred && command?.finishIfCurrent) {
+      const delivery = command.delivery;
+      const completion = entry.completion;
+      const owner = acceptedInput;
+      // Release the native queue before the common run joins reserved steering.
+      // That same accepted delivery then performs the original retained checkpoint.
+      command.completion.resolve(async () => {
+        if (entry.command !== command || command.delivery !== delivery || entry.completion !== completion ||
+            command.signal.aborted || !currentReceiptOwner(owner)) {
+          clearFinalAssistantResult();
+          throw failure("Claude's completion belongs to a retired native input.");
+        }
+        try {
+          await publishEntryEvent(event, true);
+          return readResult();
+        } catch (error) {
+          clearFinalAssistantResult();
+          throw error;
+        }
+      });
+      return;
+    }
     if (event.type === "admitted") {
       if (event.userEcho) entry.sent = true;
       if (!binding) await onEvent({ type: "save" });
@@ -1002,7 +1061,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     }
     if (event.type === "settled") {
       if (event.source === "result") await onEvent({ type: "provider-update", change: "goal" });
-      entry.completion?.resolve(binding ? event : readResult());
+      resolveCompletion(binding ? event : readResult());
     }
     return published;
   }

package/src/server/conversation/codexConfiguration.js

@@ -943,7 +943,7 @@ export function codexProviderModelCatalog({ models }) {
       supports_reasoning_summaries: false,
       default_reasoning_summary: "none",
       support_verbosity: false,
-      truncation_policy: { mode: "bytes", limit: 10000 },
+      truncation_policy: { mode: "tokens", limit: 10000 },
       context_window: model.contextWindow,
       max_context_window: model.contextWindow,
       effective_context_window_percent: 95,

package/src/server/conversation/codexHistoryAdapter.js

@@ -1,4 +1,5 @@
 import { open, realpath } from "node:fs/promises";
+import { isUtf8 } from "node:buffer";
 import { createServer } from "node:http";
 import path from "node:path";
 import { Readable } from "node:stream";
@@ -120,8 +121,9 @@ function retainedUserRecord(item) {
 }
 
 // Scan a fixed snapshot without retaining the lifetime transcript. A single
-// record still has a transport-sized bound; incomplete native appends are ignored.
-async function* readCodexHistoryRows(file, start, end, signal) {
+// record still has a transport-sized bound; recovery ignores incomplete appends.
+// Stopped offline inspection can require complete rows without changing recovery.
+async function* readCodexHistoryRows(file, start, end, signal, { strictComplete = false } = {}) {
   const chunk = Buffer.alloc(64 * 1024);
   let pending = [];
   let size = 0;
@@ -141,7 +143,11 @@ async function* readCodexHistoryRows(file, start, end, signal) {
       pending.push(Buffer.from(chunk.subarray(from, until)));
       if (complete) {
         signal.throwIfAborted();
-        if (size) yield { row: JSON.parse(Buffer.concat(pending, size).toString("utf8")), offset: lineStart };
+        if (size) {
+          const bytes = Buffer.concat(pending, size);
+          if (strictComplete && !isUtf8(bytes)) throw compactionHistoryError("the saved history contains invalid UTF-8.");
+          yield { row: JSON.parse(bytes.toString("utf8")), offset: lineStart };
+        }
         pending = [];
         size = 0;
         lineStart = offset + newline + 1;
@@ -150,6 +156,7 @@ async function* readCodexHistoryRows(file, start, end, signal) {
     }
     offset += bytesRead;
   }
+  if (strictComplete && size) throw compactionHistoryError("the saved history has an incomplete final record.");
 }
 
 // Native compaction keeps the original rollout on disk. Foreign providers
@@ -456,4 +463,4 @@ async function prepareCodexHistory(params, client, { baseUrl, modelProviderId, .
   } };
 }
 
-export { startCodexHistoryAdapter, translateCodexHistory, prepareCodexHistory };
+export { startCodexHistoryAdapter, translateCodexHistory, prepareCodexHistory, readCodexHistoryRows };

package/src/server/conversation/codexNotificationQueue.js

@@ -40,8 +40,7 @@ export function createCodexAppServerNotificationQueue({
     });
   }
 
-  async function drainCodexAppServerNotificationTasks(sessionId = "") {
-    const taskSessionKey = namespace(sessionId);
+  async function drainCodexAppServerNotificationTasksForKey(taskSessionKey) {
     while (true) {
       const task = codexAppServerNotificationTasks.get(taskSessionKey);
       if (!task) {
@@ -51,6 +50,15 @@ export function createCodexAppServerNotificationQueue({
     }
   }
 
+  async function drainCodexAppServerNotificationTasks(sessionId = "") {
+    return drainCodexAppServerNotificationTasksForKey(namespace(sessionId));
+  }
+
+  function captureCodexAppServerNotificationDrain(sessionId = "") {
+    const taskSessionKey = namespace(sessionId);
+    return () => drainCodexAppServerNotificationTasksForKey(taskSessionKey);
+  }
+
   function queueCodexAppServerStream(context, classification, deliver) {
     if (isClosing() || !classification.itemId || !classification.turnId) return;
     const pending = codexAppServerPendingStreams.get(context.sessionKey);
@@ -97,6 +105,7 @@ export function createCodexAppServerNotificationQueue({
     pendingReasoning: codexAppServerPendingReasoning,
     run: runCodexAppServerNotificationTask,
     drain: drainCodexAppServerNotificationTasks,
+    captureDrain: captureCodexAppServerNotificationDrain,
     stream: queueCodexAppServerStream,
     reasoning: queueCodexAppServerReasoning
   };