@jskit-ai/assistant-core 0.1.212 → 0.1.214

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 });
   }
@@ -182,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,
@@ -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 });
@@ -290,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 });
@@ -310,10 +334,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 +372,27 @@ export function createClaudeConversationOwner({
         await entry.nativeTurn.stopProcess(error.message);
       }
     }); } catch (error) {
-      if (store.releaseExecution && error.stopProof?.scopeEmpty) await store.releaseExecution(entry);
+      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);
+        if (entry.startupCleanup?.executionId === error.executionId) entry.startupCleanup = null;
+      }
       throw error;
     }
+    if (entry.startupCleanup?.executionId === entry.executionId) entry.startupCleanup = null;
     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 +441,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 +465,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 +491,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 +720,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 });
     }
@@ -660,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;
@@ -734,12 +822,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 +853,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 +878,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 +945,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);
@@ -817,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) {
@@ -836,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();
@@ -864,7 +1014,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 +1024,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 +1035,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 +1068,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 +1151,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 +1181,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 +1198,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 +1218,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 +1237,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 +1252,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/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";