@jskit-ai/assistant-core 0.1.213 → 0.1.214

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.214",
+    "@jskit-ai/http-runtime": "0.1.234",
+    "@jskit-ai/kernel": "0.1.236",
     "@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.53",
+    "@jskit-ai/connectors-catalog": "0.1.53"
   },
   "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.214",
   "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.178",
+    "@jskit-ai/resource-crud-core": "0.1.178",
     "@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.234",
+    "@jskit-ai/kernel": "0.1.236",
     "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;
   }
 
@@ -742,10 +748,10 @@ 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() };
     let failure;
@@ -947,10 +953,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 +973,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" });
+      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 });
+          entry.completion?.resolve(readResult());
+          if (entry.startupCleanup === startup) entry.startupCleanup = null;
+          throw error;
+        }
+      } else await onEvent({ type: "save" });
       entry.completion?.resolve(readResult());
+      if (entry.startupCleanup === startup) entry.startupCleanup = null;
       return entry.exitProof;
     };
     if (!binding) return operation();

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
   };

package/src/server/conversation/codexObservationControl.js

@@ -39,19 +39,19 @@ export function createCodexObservationControl({
   function createCodexAppServerObservation(sessionId, context = {}) {
     const { projectContext, target, retireProvider } = context;
     return {
-      prepare({ provider, error }) {
+      prepare({ provider, error, threadIds }) {
         return runInContext(projectContext, async () => {
           const managed = target(error);
           const threads = new Map();
           for (const entry of codexAppServerConversations.get(namespace(sessionId))?.values() || []) {
-            if (entry.provider !== provider) continue;
+            if (entry.provider !== provider || threadIds && !threadIds.includes(entry.conversationId)) continue;
             threads.set(entry.conversationId, entry.runId);
             if (codexAppServerConversationTurnIsActive(entry.status) || entry.goal?.status === "active") {
               entry.error = managed.pendingMessage;
             }
           }
           // A helper owns only its own threads. Main chat belongs to its managed provider.
-          if (managed.threadId) {
+          if (managed.threadId && (!threadIds || threadIds.includes(managed.threadId))) {
             const runtime = await createRuntime();
             const turn = turnState(await runtime.getSession(sessionId));
             threads.set(managed.threadId, turn.turnId);
@@ -66,10 +66,10 @@ export function createCodexObservationControl({
           return threads;
         });
       },
-      barrier({ error }) {
+      barrier({ error, threadIds }) {
         return runInContext(projectContext, async () => {
           const managed = target(error);
-          if (!managed.threadId) return;
+          if (!managed.threadId || threadIds && !threadIds.includes(managed.threadId)) return;
           const runtime = await createRuntime();
           const turn = turnState(await runtime.getSession(sessionId));
           if (!turn.active && !codexAppServerTurnOwnsActiveGoal(turn, managed.threadId)) return;
@@ -79,12 +79,12 @@ export function createCodexObservationControl({
           });
         });
       },
-      complete({ provider, error, sharedStop }) {
+      complete({ provider, error, sharedStop, threadIds }) {
         return runInContext(projectContext, async () => {
           const managed = target(error);
           let stoppedRun = null;
           let conversationStream = null;
-          if (managed.threadId) {
+          if (managed.threadId && (!threadIds || threadIds.includes(managed.threadId))) {
             const runtime = await createRuntime();
             stoppedRun = await runtime.store.mutateSession(sessionId, async () => {
               const run = await readCodexAppServerAgentRunForSession(runtime.store, sessionId);
@@ -105,7 +105,7 @@ export function createCodexObservationControl({
           if (sharedStop) await retireProvider(provider);
           else provider.observationFailure = null;
           for (const entry of codexAppServerConversations.get(namespace(sessionId))?.values() || []) {
-            if (entry.provider === provider && (
+            if (entry.provider === provider && (!threadIds || threadIds.includes(entry.conversationId)) && (
               codexAppServerConversationTurnIsActive(entry.status) || entry.goal?.status === "active"
             )) {
               entry.status = "interrupted";