@jskit-ai/assistant-core 0.1.226 → 0.1.228

package/src/server/conversation/codexConfiguration.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
-import { open, rename, rm, writeFile } from "node:fs/promises";
+import { open, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { isPlainObject as isRecord, normalizeText } from "./normalize.js";
@@ -196,6 +196,29 @@ export async function prepareCodexModelCatalog({ command, runtimeDir, bundled =
   return catalogPath;
 }
 
+// Read the same catalogue supplied to this runtime's native model manager.
+// max_context_window advertises an extended window; it is not the normal budget.
+export async function readCodexModelContextWindow({ runtimeDir, model } = {}) {
+  if (typeof runtimeDir !== "string" || !path.isAbsolute(runtimeDir) ||
+      typeof model !== "string" || !model.trim()) {
+    throw new TypeError("A selected Codex runtime and exact model are required.");
+  }
+  try {
+    const catalog = JSON.parse(await readFile(path.join(runtimeDir, "models.json"), "utf8"));
+    const matches = catalog.models.filter(row => row?.slug === model);
+    if (matches.length !== 1) throw new Error("Unknown model");
+    const { context_window: windowTokens, effective_context_window_percent: percent } = matches[0];
+    if (!Number.isSafeInteger(windowTokens) || windowTokens < 1 ||
+        !Number.isSafeInteger(percent) || percent < 1 || percent > 100) throw new Error("Invalid context limit");
+    const effectiveWindowTokens = Math.floor(windowTokens * percent / 100);
+    if (effectiveWindowTokens < 1) throw new Error("Invalid effective context limit");
+    return { model, windowTokens, effectiveWindowTokens };
+  } catch {
+    // A native catalogue can contain private provider configuration.
+    throw new Error("Codex's normal context window is unavailable for the selected runtime and model.");
+  }
+}
+
 const DISABLED_FEATURES = Object.freeze([
   "apps",
   "artifact",

package/src/server/conversation/codexGoalCommands.js

@@ -38,9 +38,11 @@ export function createCodexGoalCommands({
 
   async function updateCodexAppServerGoal(sessionId, input = {}, {
     context: initialContext,
+    signal,
     prepareConversation
   } = {}) {
     let context = initialContext;
+    signal?.throwIfAborted();
     if (context.ok === false) return context;
     let threadId = context.threadId;
     if (threadId !== input.threadId || (!threadId && input.action !== "set")) {
@@ -59,10 +61,11 @@ export function createCodexGoalCommands({
       if (previousGoal && (previousGoal.status !== "complete" || previousGoal.createdAt !== input.createdAt)) {
         return { ok: false, error: "The Codex goal changed. Refresh it before setting a new goal." };
       }
+      signal?.throwIfAborted();
       subscribeCodexAppServerEvents(sessionId, context.provider, threadId, context);
       const result = await context.provider.setGoal(threadId, {
         objective: input.objective, tokenBudget: input.tokenBudget
-      });
+      }, { signal });
       await reconcileCodexAppServerGoalUpdated(sessionId, context.provider, threadId, {
         params: { goal: result.goal }
       });
@@ -75,7 +78,7 @@ export function createCodexGoalCommands({
     }
     if (input.action === "cancel") {
       subscribeCodexAppServerEvents(sessionId, context.provider, threadId, context);
-      await context.provider.clearGoal(threadId);
+      await context.provider.clearGoal(threadId, { signal });
       await reconcileCodexAppServerGoalUpdated(sessionId, context.provider, threadId, {
         method: "thread/goal/cleared",
         params: { threadId }
@@ -105,9 +108,11 @@ export function createCodexGoalCommands({
           patch: { providerStatus: "interrupted", error: "" }
         });
       });
+      signal?.throwIfAborted();
       await context.provider.resumeThread(threadId, context.resumeOptions);
     }
-    const result = await context.provider.setGoalStatus(threadId, input.action === "pause" ? "paused" : "active");
+    signal?.throwIfAborted();
+    const result = await context.provider.setGoalStatus(threadId, input.action === "pause" ? "paused" : "active", { signal });
     await reconcileCodexAppServerGoalUpdated(sessionId, context.provider, threadId, {
       params: { goal: result.goal }
     });

package/src/server/conversation/codexTurnRecovery.js

@@ -54,6 +54,7 @@ export function createCodexTurnRecovery({
     finalizedTurns: codexAppServerFinalizedTurns,
     resultFinalizationKey: codexAppServerResultFinalizationKey,
     readAgentRunForSession: readCodexAppServerAgentRunForSession,
+    submitAssistantResult: submitCodexAppServerAssistantResult,
     cleanupUntrackedTurn: cleanupCodexAppServerUntrackedTurn
   } = output;
   const {
@@ -953,14 +954,23 @@ export function createCodexTurnRecovery({
       }
       return { ok: true, processed: false, reason: "failure_detail_pending", status: normalizedStatus };
     }
-    const recovered = await recoverCodexAppServerFinalResponseBeforeOutcome(
-      normalizedSessionId,
-      normalizedThreadId,
-      normalizedTurnId,
-      normalizedStatus
-    );
-    if (recovered?.processed) {
-      return recovered;
+    if (resolvedOutcome === turnOutcomes.PROVIDER_FAILURE) {
+      // Saved output is still useful, but cannot turn a known provider failure
+      // into successful completion. Persist it without settling the turn;
+      // the failure notice and checkpoint below own the terminal outcome.
+      await submitCodexAppServerAssistantResult(normalizedSessionId, normalizedThreadId, normalizedTurnId, {
+        recoverFromProvider: true
+      });
+    } else {
+      const recovered = await recoverCodexAppServerFinalResponseBeforeOutcome(
+        normalizedSessionId,
+        normalizedThreadId,
+        normalizedTurnId,
+        normalizedStatus
+      );
+      if (recovered?.processed) {
+        return recovered;
+      }
     }
     // History recovery awaited the provider. Confirm activity again before
     // publishing a failure, because the goal may have continued in that gap.

package/src/server/conversation/continuity.js

@@ -17,8 +17,13 @@ export function conversationMessageVersion(message, { includeData = false } = {}
 /** Keep native delivery and its history cursor in the same durable record. */
 export function createConversationChangeover({ state, transcript, agent, identity, presentation = {}, log = () => {},
   captureContext = false, applicationMessages = false, maximumInitialMessages = 30,
-  maximumInitialMessageCharacters = Infinity }) {
-  if (!Number.isSafeInteger(maximumInitialMessages) || maximumInitialMessages < 0 ||
+  maximumInitialMessageCharacters = Infinity, maximumHistoryBytes = Infinity }) {
+  if (typeof maximumHistoryBytes !== "function" && maximumHistoryBytes !== Infinity &&
+      (!Number.isSafeInteger(maximumHistoryBytes) || maximumHistoryBytes < 1) ||
+      maximumInitialMessages === Infinity && maximumHistoryBytes === Infinity) {
+    throw new TypeError("Native history requires a positive byte limit for unbounded message selection.");
+  }
+  if (maximumInitialMessages !== Infinity && (!Number.isSafeInteger(maximumInitialMessages) || maximumInitialMessages < 0) ||
       maximumInitialMessageCharacters !== Infinity &&
       (!Number.isSafeInteger(maximumInitialMessageCharacters) || maximumInitialMessageCharacters < 1)) {
     throw new TypeError("Initial native history requires a non-negative message limit and a positive text limit.");
@@ -167,12 +172,16 @@ export function createConversationChangeover({ state, transcript, agent, identit
 
     const provisional = messages.find((message) => (message.role === "user" || applicationMessages && message.role === "application") &&
       message.messageId === input.messageId && message.receipt === false);
-    if (provisional) {
+    // The original pending write precedes every native dispatch. A retained
+    // false attempt for this exact input proves it has not crossed that boundary
+    // (or the native owner explicitly rejected it before writing).
+    const notAttempted = binding.pending?.messageId === input.messageId && binding.pending.attempted === false;
+    if (provisional && !notAttempted) {
       const receipt = await agent.inspectMessageAdmission({ messageId: input.messageId }).catch(() => null);
       if (receipt?.admission !== "accepted") return unconfirmed(input.messageId, receipt?.threadId);
       return { ok: true, delivered: true, messageId: input.messageId, duplicate: true };
     }
-    if (await transcript.hasMessage(input.messageId)) {
+    if (!provisional && await transcript.hasMessage(input.messageId)) {
       return { ok: true, delivered: true, messageId: input.messageId, duplicate: true };
     }
     const snapshot = Object.fromEntries(messages.map((message) => [message.id, message.version]));
@@ -181,19 +190,52 @@ export function createConversationChangeover({ state, transcript, agent, identit
     const renderChanged = changed.filter(message => !excluded.has(message.messageId));
     const deleted = Object.keys(binding.seen).filter((id) => !Object.hasOwn(snapshot, id));
     const switched = value.lastEngine !== engineId;
-    // A new native conversation gets the recent bubbles. A returning one gets
-    // every missed/edited bubble, even if the edit is older than that window.
-    const catchup = (returning ? changed : maximumInitialMessages ? messages.slice(-maximumInitialMessages) : [])
+    // Returning conversations select missed/edited bubbles independently of
+    // the initial message window. The total byte budget applies to both paths.
+    let catchup = (returning ? changed : maximumInitialMessages ? messages.slice(-maximumInitialMessages) : [])
       .filter(message => !excluded.has(message.messageId));
     let pending = binding.pending;
     if (pending && pending.messageId !== input.messageId) {
       delete binding.pending;
       pending = null;
     }
-    if (!pending && (switched || renderChanged.length || deleted.length)) {
+    if (!pending) {
+      const needsContext = switched || renderChanged.length || deleted.length;
       const handover = value.replacement?.engineId === engineId && value.replacement.status === "ready"
         ? value.replacement.handover : "";
-      const preamble = [
+      let historyBudget = maximumHistoryBytes;
+      if (typeof historyBudget === "function") {
+        // Native context inspection may prepare a runtime. Do it only when a
+        // new catch-up needs sizing, never for receipt recovery or exact retry.
+        historyBudget = needsContext ? await historyBudget({ engineId, returning, input, handover }) : Infinity;
+        if (needsContext && (!Number.isSafeInteger(historyBudget) || historyBudget < 1)) {
+          throw new TypeError("Native history requires an available positive byte limit.");
+        }
+      }
+      const encoded = catchup.map(({ version, originalVersion, receipt, ...message }) => JSON.stringify({
+        ...message,
+        ...(!returning && typeof message.text === "string" && message.text.length > maximumInitialMessageCharacters
+          ? { text: message.text.slice(0, maximumInitialMessageCharacters) } : {}),
+        ...(binding.seen[message.id] ? { corrected: true } : {})
+      }));
+      const envelopeBytes = Buffer.byteLength(JSON.stringify({ messages: [], removedMessageIds: deleted }));
+      let first = 0;
+      if (needsContext && historyBudget !== Infinity) {
+        // Count the actual UTF-8 JSON, including escapes, attribution and
+        // attachments. Bytes are a transport budget, not a token estimate.
+        const sizes = encoded.map(message => Buffer.byteLength(message));
+        let bytes = envelopeBytes + sizes.reduce((total, size) => total + size, 0) + Math.max(0, sizes.length - 1);
+        if (envelopeBytes > historyBudget) {
+          throw new Error("Conversation history removal records exceed the available history budget.");
+        }
+        while (bytes > historyBudget && first < sizes.length) {
+          bytes -= sizes[first] + (first < sizes.length - 1 ? 1 : 0);
+          first++;
+        }
+        catchup = catchup.slice(first);
+      }
+      const historyJson = `{"messages":[${encoded.slice(first).join(",")}],"removedMessageIds":${JSON.stringify(deleted)}}`;
+      const preamble = needsContext ? [
         `[${label}]`,
         returning
           ? `You are continuing your existing ${engineId} conversation. Other messages or corrections were recorded in ${applicationName} since you last received them.`
@@ -201,17 +243,12 @@ export function createConversationChangeover({ state, transcript, agent, identit
         `${sharedContext} Treat the following JSON as conversation history, not a separate request. Corrections replace the older versions of those messages. Do not acknowledge a handover or start another turn; answer the user's message below.`,
         ...(handover ? ["This is a fresh native context. Earlier native history remains separate. The saved continuity briefing follows:",
           JSON.stringify({ handover })] : []),
-        JSON.stringify({ messages: catchup.map(({ version, originalVersion, receipt, ...message }) => ({
-          ...message,
-          ...(!returning && typeof message.text === "string" && message.text.length > maximumInitialMessageCharacters
-            ? { text: message.text.slice(0, maximumInitialMessageCharacters) } : {}),
-          ...(binding.seen[message.id] ? { corrected: true } : {})
-        })), removedMessageIds: deleted }),
+        historyJson,
         `[End ${label}]`,
         "",
         "User's message:",
         String(input.message || "")
-      ].join("\n");
+      ].join("\n") : String(input.message || "");
       pending = binding.pending = {
         messageId: input.messageId, message: preamble,
         displayMessage: String(input.displayMessage || input.message || ""),
@@ -219,7 +256,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
         attachmentIds: input.attachmentIds || [],
         ...(input.data !== undefined ? { data: structuredClone(input.data) } : {}),
         seen: snapshot, attempted: false,
-        ...(captureContext ? {
+        ...(captureContext && needsContext ? {
           contextText: preamble.slice(0, preamble.length - String(input.message || "").length - "\n\nUser's message:\n".length),
           contextAttachments: [...new Map(catchup.flatMap(message => message.attachments || [])
             .map(file => [file.attachmentId, file])).values()]

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

@@ -105,9 +105,9 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
   function standaloneOwner() {
     if (standalone) return standalone;
     const store = {
-      read(context) { return JSON.stringify({ executionId: context.binding.executionId, sent: context.binding.sent }); },
+      read(context) { return JSON.stringify({ executionId: context.binding.executionId, sent: context.binding.sent, pausedGoal: context.binding.pausedGoal, blockedGoal: context.binding.blockedGoal }); },
       async save(entry, { execution = false } = {}) {
-        if (execution) await entry.context.updateBinding({ executionId: entry.executionId });
+        await entry.context.updateBinding({ pausedGoal: entry.pausedGoal, blockedGoal: entry.blockedGoal, ...(execution ? { executionId: entry.executionId } : {}) });
       },
       async releaseExecution(entry) {
         await entry.context.updateBinding({ executionId: "" });
@@ -213,6 +213,7 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
     await bindClaudeConversationAccount({ accountIdentity: previous,
       accountIdentities: { [providerId || "anthropic"]: previous }
     }, { identity, providerId: providerId || "anthropic",
+      allowAccountChange: host.allowAccountChange === true && !requireBound,
       stop: (_entry, reason) => entry.nativeTurn.stopProcess(reason),
       save: account => entry.context.updateBinding(providerId
         ? { connectionIdentities: { ...entry.context.binding.connectionIdentities, [providerId]: account.accountIdentity } }
@@ -402,7 +403,7 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
             await acquire(context);
             const completeResult = supplied.completeResult?.(context);
             let command = input;
-            let facilities;
+            let facilities = { signal: context?.signal };
             if (representation !== "native") {
               const current = await owner.readGoal(await acquire(context));
               if (input.action !== "set" && claudeGoalValue(current.goal, current.threadId)?.id !== input.expectedGoalId) {
@@ -410,7 +411,7 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
               }
               command = { ...input, threadId: current.threadId,
                 ...(input.action !== "set" ? { createdAt: current.goal.createdAt, objective: current.goal.objective } : {}) };
-              facilities = { interrupt, send: command => send(command, { threadId: current.threadId }) };
+              facilities = { signal: context?.signal, interrupt, send: command => send(command, { threadId: current.threadId }) };
             }
             const nativeResult = await owner.updateGoal(await acquire(context), command, facilities);
             await completeResult?.(nativeResult);
@@ -422,7 +423,7 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
             throw new Error("The Claude goal changed. Refresh before trying again.");
           }
           await entry.goals.update({ ...input, threadId: entry.id,
-            ...(input.action !== "set" ? { createdAt: goal?.createdAt, objective: goal?.objective } : {}) }, { interrupt, send });
+            ...(input.action !== "set" ? { createdAt: goal?.createdAt, objective: goal?.objective } : {}) }, { interrupt, send, signal: context?.signal });
           return claudeGoalValue(await entry.goals.read(), entry.id);
         },
         async inspectAdmission({ context, representation, verifyAccount = false, ...input }) {

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

@@ -823,7 +823,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             if (supplied) return delivered;
             throw Object.assign(new Error(value?.error || "Codex is not ready to receive this instruction."), value);
           } catch (error) {
-            if (attempted && !accepted && !rejected && !Number.isInteger(error.code)) error.delivery = "uncertain";
+            if (attempted && !accepted && !rejected && error.delivery !== "not-sent" && !Number.isInteger(error.code)) error.delivery = "uncertain";
             throw error;
           }
         });
@@ -933,7 +933,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
                   createdAt: goal?.createdAt, objective: input.action === "set" ? input.objective : goal?.objective };
               }
               result = await owner.updateGoal(sessionId, command, {
-                context: nativeContext, prepareConversation: () => goalContext(configuration, context, undefined, { prepareThread: true })
+                context: nativeContext, signal: context.signal, prepareConversation: () => goalContext(configuration, context, undefined, { prepareThread: true })
               });
               if (result.ok !== false) binding.goal = result.goal || null;
             } finally { admission.release(); }
@@ -957,7 +957,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           if ((goalValue(goal)?.id || null) !== (input.expectedGoalId || null)) throw new Error("The native goal changed. Read it again before changing it.");
           const result = await owner.updateGoal(sessionId, { ...input, threadId: binding.threadId,
             createdAt: goal?.createdAt, objective: input.action === "set" ? input.objective : goal?.objective }, {
-            context: nativeContext,
+            context: nativeContext, signal: context.signal,
             prepareConversation: () => goalContext(configuration, context, signal, { prepareThread: true, tools })
           });
           if (result.ok === false) throw new Error(result.error);

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

@@ -154,21 +154,34 @@ export async function readPersistentConversation(options) {
   const scope = { sessionId, conversationId: record.conversationId };
   let response = {};
   let turns = await store.readConversationLog(scope);
-  const requestTurn = turns.findLast((turn) => turn.user?.messageId === record.messageId);
-  const messageScope = projection.messageScope(context, scope, requestTurn);
-  const savedIds = new Set(turns.flatMap((turn) => turn.messages.map((message) => message.messageId)));
+  const requestTurns = new Map(turns.filter(turn => turn.user?.messageId).map(turn => [turn.user.messageId, turn]));
+  let requestTurn = turns.findLast((turn) => turn.user?.messageId === record.messageId);
+  const savedIds = new Set(turns.flatMap(turn => turn.messages.flatMap(message => [message.messageId, message.outputId].filter(Boolean))));
   const writtenTurnIds = new Set();
   let appended = false;
   if (record.providerConversationId && record.state !== "closing") {
     try {
-      response = requireSuccess(await operations.readConversation(sessionId, records.input(record), context));
+      response = requireSuccess(await operations.readConversation(sessionId,
+        records.input(record, { requestMessageIds: [...requestTurns.keys()] }), context));
       for (const message of response.messages || []) {
         const operation = messageWriters[message.role];
-        if (operation && message.text && message.complete !== false && !savedIds.has(message.id)) {
-          const written = await store[operation](messageScope, {
-            ...projection.message(message, record, "stored"), messageId: message.id
+        if (operation && message.text && message.complete !== false && !savedIds.has(message.id) && !savedIds.has(message.outputId)) {
+          const identified = Object.hasOwn(message, "requestMessageId");
+          const target = identified ? requestTurns.get(message.requestMessageId) : requestTurn;
+          // An identified output must never fall through to the latest request.
+          // Its authored row may not have been committed yet; retain native proof.
+          if (identified && !target) continue;
+          const written = await store[operation](projection.messageScope(context, scope, target), {
+            ...projection.message(message, record, "stored"), messageId: message.id,
+            ...(target && (identified || !target.assistant) ? { turnId: target.turnId } : {})
           });
-          if (written) writtenTurnIds.add(written.turnId);
+          if (written) {
+            savedIds.add(message.id);
+            if (message.outputId) savedIds.add(message.outputId);
+            writtenTurnIds.add(written.turnId);
+            if (written.user?.messageId) requestTurns.set(written.user.messageId, written);
+            if (written.turnId === requestTurn?.turnId) requestTurn = written;
+          }
           appended = true;
         }
       }
@@ -196,6 +209,7 @@ export async function readPersistentConversation(options) {
 export async function startPersistentConversationTurn(options) {
   const { sessionId, input, operations, store, records, prepare, receipts } = options;
   let { record, context } = options;
+  const priorInput = { messageId: record.messageId || "", runId: record.runId || "" };
   const previous = await readPersistentConversation({ ...options, record: { ...record, messageId: input.messageId } });
   if (previous.readError) throw new Error(previous.error);
   if (previous.admitted) return { ...previous, delivered: true, turnId: previous.runId };
@@ -236,12 +250,19 @@ export async function startPersistentConversationTurn(options) {
     if (authoredTurn) await publishTranscript(options, context, record, [authoredTurn], { admitted: true });
     return { ...result, delivered: true, turnId: result.runId, conversationId: record.conversationId };
   } catch (error) {
+    const notSent = error.delivery === "not-sent";
+    // A rejected follow-up does not own the prior request's late answer. Retain
+    // its authored row, but restore the admitted identity before reconciliation.
+    if (notSent) {
+      record = await records.save(context, record, priorInput);
+      await input.onPromptRejected?.();
+    }
     const observed = await readPersistentConversation({ ...options, context, record });
-    if (observed.admitted) {
+    if (!notSent && observed.admitted) {
       if (receipts.afterAdmission(input)) await writeReceipt();
       return { ...observed, delivered: true, turnId: observed.runId };
     }
-    if (observed.readError && !receipts.afterAdmission(input)) return {
+    if (!notSent && observed.readError && !receipts.afterAdmission(input)) return {
       ...observed, ok: false, delivered: false, status: "uncertain", messageId: input.messageId, error: error.message
     };
     await records.save(context, record, { error: error.message, status: "failed" });

package/src/server/conversation/runtime.js

@@ -214,7 +214,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       status: logical ? logical.status : entry.storageFailure || entry.executionFailure ? "unavailable" : entry.active || nativeTurn?.active ? "working" : metadata.runtime.replacement ? "replacement-pending"
         : metadata.runtime.request && (entry.engine === "api" || metadata.runtime.request.attempted || metadata.runtime.request.inspectionOnly) ? "unconfirmed" : "ready",
       phase: logical ? logical.phase || "" : entry.phase || (nativeTurn?.active && nativeTurn.status !== "observation_lost" ? nativeTurn.phase === "compacting" ? "compacting" : "working" : ""),
-      error: logical ? logical.error || "" : entry.error || nativeTurn?.error || metadata.runtime.request?.error || last?.error || "",
+      error: logical ? logical.error || "" : entry.error || nativeTurn?.error || request?.error || last?.error || "",
       goal: entry.goal || null,
       pendingRequest: logical ? logical.pendingRequest || null : pendingRequest,
       ...(logical?.presentation ? { presentation: logical.presentation } : {}),
@@ -402,18 +402,26 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     };
   }
 
-  function nativeChangeover(entry, context, request, sendMessage) {
+  function nativeChangeover(entry, context, request, sendMessage, signal) {
     let observation;
     const initialWindow = limits.maxInitialNativeHistoryMessages;
+    const budget = entry.conversation?.maximumHistoryBytes;
     if (initialWindow !== undefined && (!Number.isSafeInteger(initialWindow) || initialWindow < 0)) {
       throw new TypeError("Initial native history requires a non-negative message limit.");
     }
     return createConversationChangeover({
       state: entry.conversation?.state || changeoverState(entry, request),
       captureContext: !entry.conversation, applicationMessages: !entry.conversation,
-      maximumInitialMessages: initialWindow === undefined ? undefined
+      maximumInitialMessages: initialWindow === undefined ? (budget ? Infinity : undefined)
         : Math.max(0, initialWindow - (request?.input.origin === "user" ? 1 : 0)),
       maximumInitialMessageCharacters: limits.maxInitialNativeHistoryMessageCharacters,
+      ...(budget ? { maximumHistoryBytes: async options => {
+        await access(context, entry.id, request.operation, entry);
+        signal.throwIfAborted();
+        const bytes = await budget({ ...options, context, signal });
+        signal.throwIfAborted();
+        return bytes;
+      } } : {}),
       presentation: entry.conversation?.presentation || { unconfirmedCode: "conversation_delivery_uncertain",
         unconfirmedMessage: "The previous submission has uncertain delivery. Retry this message to check its native receipt; it will not be resent automatically." },
       transcript: entry.conversation?.transcript || {
@@ -994,7 +1002,10 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     async function beforeDispatch(request) {
       await access(request.context, entry.id, request.operation, entry);
       active.controller.signal.throwIfAborted();
-      if (active.finishing) throw failure("The native turn finished before this instruction was sent. Send it as a new message.", "conversation_not_steerable");
+      if (request.input.goal && request.context?.signal?.aborted) {
+        throw Object.assign(failure("The goal command was stopped before delivery.", "conversation_goal_stopped"), { delivery: "not-sent" });
+      }
+      if (active.finishing) throw Object.assign(failure("The native turn finished before this instruction was sent. Send it as a new message.", "conversation_steer_turn_finished"), { delivery: "not-sent" });
     }
 
     async function deliverNative(request, dispatch) {
@@ -1008,7 +1019,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       const dispatchPrepared = async input => {
         rendered = input;
         rejectionSaves.delete(request.input.messageId);
-        if (request.operation === "steer" && !request.steering) throw failure("There is no active native turn to steer. Send a new message.", "conversation_not_steerable");
+        if (request.operation === "steer" && !request.steering) throw Object.assign(failure("There is no active native turn to steer. Send a new message.", "conversation_steer_turn_finished"), { delivery: "not-sent" });
         if ((input.contextText || "").length > maximumContinuity) throw new Error("Conversation updates exceed the configured history budget. Renew the context with a continuity briefing before continuing.");
         if (request.input.goal && input.contextText) {
           throw failure("Send a chat message to deliver the saved continuity briefing before starting a native terminal or goal.", "conversation_replacement_briefing_pending");
@@ -1048,6 +1059,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         completion = Promise.resolve().then(() => dispatch({
           context: request.context,
           input: { ...request.input, authoredInput: { ...request.input, at: request.at },
+            ...(request.input.goal ? { signal: request.context?.signal } : {}),
             ...(boundInput ? { nativeMessage: boundInput } : {}),
             text: input.message, contextText: input.contextText || "",
             content: [...contextFiles.content, ...files.content], localFiles, attachmentManifest },
@@ -1064,6 +1076,9 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
               turnMetadata: { runtime: { engine, segmentId, origin: request.input.origin,
                 ...(request.completedEnvelope ? { completedEnvelope: true } : {}),
                 ...(typeof request.nativeToolAttempt === "boolean" ? { nativeToolAttempt: request.nativeToolAttempt } : {}) } } });
+            if (request.input.goal && request.context?.signal?.aborted) {
+              throw Object.assign(failure("The goal command was stopped before delivery.", "conversation_goal_stopped"), { delivery: "not-sent" });
+            }
             request.deliveryTiming?.("dispatch-started");
           },
           async accept(native) {
@@ -1085,7 +1100,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
           }
           if (!request.accepted) throw new Error("The engine did not acknowledge the message.");
         }).catch(async error => {
-          if (!entry.conversation && !request.accepted && error.delivery !== "uncertain") {
+          if (!request.accepted && (error.delivery === "not-sent" || !entry.conversation && error.delivery !== "uncertain")) {
             try { await input.onPromptRejected(); }
             catch (saveError) {
               rejectionSaves.set(request.input.messageId, input.onPromptRejected);
@@ -1139,7 +1154,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         // context rendering and its delivery cursor must not change /goal input.
         const delivered = entry.conversation && request.input.goal
           ? await dispatchPrepared(input)
-          : await nativeChangeover(entry, request.context, request, dispatchPrepared).send({ engineId: engine,
+          : await nativeChangeover(entry, request.context, request, dispatchPrepared, active.controller.signal).send({ engineId: engine,
             messages: entry.conversation ? await entry.conversation.transcript.history() : conversationNativeMessages(history),
             ...(entry.conversation ? { turnMetadata: { engineId: engine } } : {}),
             ...(request.completedEnvelope ? { completedEnvelope: true, excludedMessageIds: request.excludedMessageIds } : {}), input });
@@ -1449,6 +1464,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     const operation = goal ? "goal" : input?.steer === true ? "steer" : origin === "application" ? "wake" : "send";
     await access(context, entry.id, operation, entry);
     await entry.conversation?.admission(context, operation);
+    if (goal) context?.signal?.throwIfAborted();
     let suppliedExclusions;
     if (wakeOptions !== undefined) {
       if (!completedEnvelope || entry.conversation || origin !== "application" || goal ||
@@ -1511,9 +1527,9 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       return { promise: pending.admission.promise };
     }
     const working = entry.active;
-    if (entry.conversation && ["codex", "opencode", "claude"].includes(entry.engine) && operation === "send" && working?.finishing) {
+    if (entry.conversation && ["codex", "opencode", "claude"].includes(entry.engine) && ["send", "goal"].includes(operation) && working?.finishing) {
       // No native dispatch has occurred for this request. Finish the previous
-      // waiter before reserving the same authored request on the ordinary path.
+      // waiter before reserving the same authored message or goal request.
       await working.done;
       return admitSend(entry, context, input, origin, goal, originalInput, wakeOptions, deliveryTiming);
     }
@@ -1525,7 +1541,12 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       throw failure("Completed Claude responses cannot share a native steering turn. Wait for the response or stop it.", "conversation_not_steerable");
     }
     if (working && !input.steer && !goal && !entry.conversation) throw failure("Wait for this answer or use steer to send another instruction.", "conversation_busy");
-    if (input.steer && (!working && !nativeSteering || working?.finishing) && !(nativePending?.attempted || nativePending?.inspectionOnly)) throw failure("There is no active native turn to steer. Send a new message.", "conversation_not_steerable");
+    if (input.steer && (!working && !nativeSteering || working?.finishing) && !(nativePending?.attempted || nativePending?.inspectionOnly)) {
+      const previousState = nativeState?.nativeTurn?.runState || nativeState?.nativeTurn?.state || history.at(-1)?.metadata?.runtime?.status;
+      const completed = working ? !working.controller.signal.aborted && !working.timedOut : ["complete", "completed"].includes(previousState);
+      throw Object.assign(failure("There is no active native turn to steer. Send a new message.",
+        completed ? "conversation_steer_turn_finished" : "conversation_not_steerable"), { delivery: "not-sent" });
+    }
     if (goal && working?.finishing) throw failure("Wait for the current turn to finish saving before starting the goal.", "conversation_busy");
     if (working && (!working.request.admissionSettled || working.steering)) throw failure("Wait for the pending instruction to be admitted before steering again.", "conversation_busy");
     const barrier = working ? Promise.withResolvers() : null;
@@ -1629,8 +1650,9 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     return representation === "native" ? result.nativeResult : structuredClone(entry.goal);
   }
 
-  async function updateGoal(entry, context, input, representation) {
+  async function updateGoal(entry, context, input, representation, retryFinishedTurn = true) {
     await access(context, entry.id, "goal", entry);
+    context?.signal?.throwIfAborted();
     if (!capabilities(entry).goals) throw failure("This connection does not support native goals.", "conversation_unsupported", 400);
     if (representation !== "native" && !capabilities(entry).goals) {
       throw failure("This bound conversation does not yet map native goal messages to canonical receipts.", "conversation_unsupported", 400);
@@ -1753,8 +1775,18 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       await emit(entry, { type: "goal", goal: entry.goal });
       return { goal: structuredClone(entry.goal) };
     });
-    const completed = result.operation ? await result.operation : result;
-    return completed.receipt || completed.promise || completed.goal;
+    try {
+      const completed = result.operation ? await result.operation : result;
+      return await (completed.receipt || completed.promise || completed.goal);
+    } catch (error) {
+      if (!retryFinishedTurn || !entry.conversation || !starting || !messageCommand ||
+          error.code !== "conversation_steer_turn_finished" || error.delivery !== "not-sent") throw error;
+      // Completion can retire Claude's generation during asynchronous native
+      // preparation. Its exact pre-write rejection permits one re-admission of
+      // this same goal/message ID, after the original cleanup and save finish.
+      await entry.active?.done;
+      return updateGoal(entry, context, input, representation, false);
+    }
   }
 
   async function retrySave(entry) {
@@ -2412,6 +2444,9 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
           typeof conversation.prepareInput !== "function" || typeof conversation.read !== "function"))) {
         throw new TypeError("A bound native conversation requires its original identity, store, preparation and native owners.");
       }
+      if (conversation?.maximumHistoryBytes !== undefined && typeof conversation.maximumHistoryBytes !== "function") {
+        throw new TypeError("A bound native history budget requires a server-owned resolver.");
+      }
       if (!["canonical", "native"].includes(representation) || representation === "native" && !conversation) {
         throw new TypeError("Native result representation requires an original bound conversation.");
       }

package/src/server/conversation/streams.js

@@ -7,11 +7,12 @@ export function createConversationStreams({ clock = () => new Date() } = {}) {
     const stream = streams.get(scope);
     return {
       revision,
-      messages: stream ? [...stream.messages.values()].map((message) => ({ ...message })) : []
+      messages: stream ? [...stream.messages.values()].map((message) => ({ ...message,
+        ...(message.metadata ? { metadata: structuredClone(message.metadata) } : {}) })) : []
     };
   }
 
-  function update(scope, { turnId, messageId, role = "assistant", text, delta, at, origin, nativeIdentity, outputId, authorship } = {}) {
+  function update(scope, { turnId, messageId, role = "assistant", text, delta, at, origin, nativeIdentity, outputId, authorship, metadata } = {}) {
     if (!turnId || !messageId || !["assistant", "commentary"].includes(role)) return null;
     let stream = streams.get(scope);
     if (!stream || stream.turnId !== turnId) {
@@ -24,8 +25,11 @@ export function createConversationStreams({ clock = () => new Date() } = {}) {
     if (authorship?.messageId && (!previous || captured?.messageId === authorship.messageId)) {
       stream.authorship.set(messageId, captured?.turnId ? captured : { ...authorship });
     }
+    const capturedMetadata = previous?.metadata || (metadata && typeof metadata === "object" && !Array.isArray(metadata)
+      ? structuredClone(metadata) : null);
     const next = {
       messageId,
+      ...(capturedMetadata ? { metadata: capturedMetadata } : {}),
       ...((previous?.outputId || outputId) ? { outputId: previous?.outputId || outputId } : {}),
       // Native grouping is private even when its authored origin is known.
       // Ordinary runtime output already carries the exact authored row identity.
@@ -39,7 +43,7 @@ export function createConversationStreams({ clock = () => new Date() } = {}) {
       status: "inProgress"
     };
     if (previous?.text === next.text && previous.role === next.role && previous.outputId === next.outputId &&
-        previous.completedEnvelope === next.completedEnvelope) return null;
+        previous.completedEnvelope === next.completedEnvelope && previous.metadata === next.metadata) return null;
     stream.messages.set(messageId, next);
     revision += 1;
     return read(scope);

package/src/server/conversation/transcript.js

@@ -85,7 +85,8 @@ export function createConversationTranscript({ storage, clock = () => new Date()
       await transaction.appendMessage(turnId, {
         role, text: messageText, messageId: id, at: createdAt.toISOString(),
         ...(["assistant", "commentary", "thinking"].includes(role) && normalizeText(outputId) ? { outputId: normalizeText(outputId) } : {}),
-        ...(role === "user" ? { attachments, turnMetadata, ...(data !== undefined ? { data: structuredClone(data) } : {}) } : {})
+        ...(role === "user" ? { attachments, turnMetadata } : {}),
+        ...(data !== undefined ? { data: structuredClone(data) } : {})
       });
       return transaction.readTurn(turnId);
     });

package/src/server/hosts/codexConfiguration.js

@@ -14,6 +14,7 @@ export {
   codexCatalogReasoningEfforts,
   codexCatalogModels,
   codexConfiguredModelCatalog,
+  readCodexModelContextWindow,
   createCodexAccountReader,
   createCodexAppServerIsolation,
   readCodexToolFreeConfiguration