@opengeni/worker-bundle 2.0.1 → 2.0.3-canary.36079201993001

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "2.0.1",
+  "version": "2.0.3-canary.36079201993001",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -54,24 +54,24 @@
   },
   "dependencies": {
     "@llamaindex/liteparse": "2.14.2",
-    "@opengeni/agent-proto": "^0.6.0",
-    "@opengeni/capabilities": "^0.3.4",
-    "@opengeni/codemode": "^0.6.1",
-    "@opengeni/codex": "^0.2.25",
-    "@opengeni/config": "^2.1.0",
-    "@opengeni/contracts": "^5.1.0",
-    "@opengeni/core": "^4.0.1",
-    "@opengeni/db": "^6.0.1",
-    "@opengeni/documents": "^0.8.32",
-    "@opengeni/events": "^0.4.30",
-    "@opengeni/github": "^0.7.15",
-    "@opengeni/network": "^0.3.1",
-    "@opengeni/observability": "^0.8.31",
-    "@opengeni/runtime": "^4.0.1",
-    "@opengeni/sdk": "^7.1.0",
-    "@opengeni/storage": "^0.2.132",
-    "@opengeni/tool-gateway": "^0.1.12",
-    "@opengeni/xai-subscription": "^0.1.4",
+    "@opengeni/agent-proto": "^0.6.0-canary.36079201993001",
+    "@opengeni/capabilities": "^0.3.4-canary.36079201993001",
+    "@opengeni/codemode": "^0.6.2-canary.36079201993001",
+    "@opengeni/codex": "^0.2.26-canary.36079201993001",
+    "@opengeni/config": "^2.1.1-canary.36079201993001",
+    "@opengeni/contracts": "^5.1.1-canary.36079201993001",
+    "@opengeni/core": "^4.0.3-canary.36079201993001",
+    "@opengeni/db": "^6.0.3-canary.36079201993001",
+    "@opengeni/documents": "^0.8.34-canary.36079201993001",
+    "@opengeni/events": "^0.4.32-canary.36079201993001",
+    "@opengeni/github": "^0.7.16-canary.36079201993001",
+    "@opengeni/network": "^0.3.1-canary.36079201993001",
+    "@opengeni/observability": "^0.8.32-canary.36079201993001",
+    "@opengeni/runtime": "^4.0.3-canary.36079201993001",
+    "@opengeni/sdk": "^7.1.1-canary.36079201993001",
+    "@opengeni/storage": "^0.2.133-canary.36079201993001",
+    "@opengeni/tool-gateway": "^0.1.13-canary.36079201993001",
+    "@opengeni/xai-subscription": "^0.1.4-canary.36079201993001",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",
     "@temporalio/worker": "^1.17.0",

package/src/activities/agent-turn/compaction-prep.ts

@@ -11,7 +11,8 @@ import {
   compactionThresholdTokens,
   CompactionNeededError,
   compactionProviderRejection,
-  SUMMARY_BUFFER_TOKENS,
+  estimateSerializedValueTokens,
+  compactionSummaryOutputTokens,
   type ModelResponseUsage,
 } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
@@ -168,6 +169,13 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
   const remotePrefix: RemoteCompactionPrefix = {
     agent: null,
   };
+  const portableResponsesNeedsAgentPrefix =
+    resolvedModel?.provider.api === "responses" &&
+    !(billingState.isCodexTurn && session.codexCompactionMode === "remote_v2");
+  const preparedPortableRequest = () => {
+    if (!remotePrefix.agent) throw new Error("Compaction agent is unavailable");
+    return preparedCompactionRequest(remotePrefix.agent);
+  };
 
   const promptCacheKey = acceptsPromptCacheKeyForTurn(resolvedModel) ? input.sessionId : undefined;
   const compactionUsageState = createCompactionModelUsageEventState(claimedModelUsageSourceKeys);
@@ -200,8 +208,8 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
       contextContributions: eventing.companyBrainContextContributions,
     });
   };
-  const compactionSummarizerFor = (systemInstructions?: string) =>
-    resolvedModel
+  const compactionSummarizerFor = (systemInstructions?: string): CompactionSummarizer => {
+    const summarize: CompactionSummarizer = resolvedModel
       ? (s: Settings, m: Array<Record<string, unknown>>) =>
           withProviderRequestContext(() =>
             summarizeContextForCompaction(s, m, {
@@ -209,20 +217,37 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
               provider: resolvedModel.provider,
               api: resolvedModel.provider.api,
               model: turnExecutionPolicy.upstreamModelId,
-              maxOutputTokens: SUMMARY_BUFFER_TOKENS,
+              maxOutputTokens: compactionSummaryOutputTokens(s.contextWindowTokens),
+              ...(cancellationSignal ? { signal: cancellationSignal } : {}),
               onUsage: recordCompactionUsage,
               ...(systemInstructions ? { systemInstructions } : {}),
               ...(promptCacheKey ? { promptCacheKey } : {}),
+              ...(portableResponsesNeedsAgentPrefix
+                ? { preparedRequest: preparedPortableRequest() }
+                : {}),
             }),
           )
       : (s: Settings, m: Array<Record<string, unknown>>) =>
           summarizeContextForCompaction(s, m, {
             model: turnExecutionPolicy.upstreamModelId,
-            maxOutputTokens: SUMMARY_BUFFER_TOKENS,
+            maxOutputTokens: compactionSummaryOutputTokens(s.contextWindowTokens),
+            ...(cancellationSignal ? { signal: cancellationSignal } : {}),
             onUsage: recordCompactionUsage,
             ...(systemInstructions ? { systemInstructions } : {}),
             ...(promptCacheKey ? { promptCacheKey } : {}),
           });
+    summarize.estimatePrefixTokens = () => {
+      if (resolvedModel?.provider.api === "chat") {
+        return estimateSerializedValueTokens(systemInstructions ?? "");
+      }
+      const prepared = portableResponsesNeedsAgentPrefix ? preparedPortableRequest() : null;
+      return (
+        estimateSerializedValueTokens(prepared?.systemInstructions ?? systemInstructions ?? "") +
+        (prepared ? estimateSerializedValueTokens(prepared.tools) : 0)
+      );
+    };
+    return summarize;
+  };
   // Prompt-cache prefix for remote_v2 MUST match ordinary turns:
   // tools → instructions → history. Filled after buildAgent for every
   // compact path (including operator /compact, which now builds the agent
@@ -265,13 +290,9 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     ...(remoteCompactionRequester ? { requestRemoteCompactionV2: remoteCompactionRequester } : {}),
   } as const;
 
-  // Operator /compact:
-  // - portable (incl. Codex portable): early maintenance path — no
-  //   prepareTools/sandbox; summarizer only needs composed instructions.
-  // - remote_v2: fall through to prepareTools/buildAgent so the compact
-  //   request reuses the ordinary tools→instructions cache prefix, then
-  //   settle without inference. (Requester is also wired for Codex portable
-  //   turns but unused there — gate on the frozen session mode.)
+  // Responses compaction, portable or remote, prepares the ordinary agent
+  // request first so tool schemas and instructions match the warm cache prefix.
+  // Chat providers keep the standalone portable maintenance path.
   const compactionOnlyTurn = turn.source === "compaction";
   const remoteV2CompactionNeedsAgentPrefix =
     Boolean(remoteCompactionRequester) && session.codexCompactionMode === "remote_v2";
@@ -308,7 +329,11 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     control.activityStatus = "idle";
     return claimedResult({ status: "idle" });
   };
-  if (compactionOnlyTurn && !remoteV2CompactionNeedsAgentPrefix) {
+  if (
+    compactionOnlyTurn &&
+    !remoteV2CompactionNeedsAgentPrefix &&
+    !portableResponsesNeedsAgentPrefix
+  ) {
     const compactionInstructions = appendWorkspaceMemory(
       appendSessionInstructions(
         appendWorkspaceGovernance(
@@ -466,6 +491,7 @@ export async function runPostAgentCompaction(
     claimedResult,
     turn,
     session,
+    resolvedModel,
     remotePrefix,
     remoteCompactionRequester,
     publishCompactionLiveEvents,
@@ -480,10 +506,13 @@ export async function runPostAgentCompaction(
   } = deps;
 
   const agentInstructions = typeof agent.instructions === "string" ? agent.instructions : "";
+  const preparedPortable =
+    resolvedModel?.provider.api === "responses" &&
+    !(remoteCompactionRequester && session.codexCompactionMode === "remote_v2");
   const compactSummarizer = compactionSummarizerFor(
     agentInstructions.trim() ? agentInstructions : undefined,
   );
-  if (remoteCompactionRequester) {
+  if (remoteCompactionRequester || preparedPortable) {
     // The prefix is captured only after this agent passes normal SDK preparation.
     remotePrefix.agent = agent;
   }
@@ -491,7 +520,11 @@ export async function runPostAgentCompaction(
   if (compactionOnlyTurn) {
     const requested = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
     let outcome: Awaited<ReturnType<typeof maybeCompactContext>> | null = null;
-    if (requested && remoteCompactionRequester && session.codexCompactionMode === "remote_v2") {
+    if (
+      requested &&
+      (preparedPortable ||
+        (remoteCompactionRequester && session.codexCompactionMode === "remote_v2"))
+    ) {
       queuePreparedCompaction(
         agent,
         new CompactionNeededError({
@@ -610,7 +643,10 @@ export async function runPostAgentCompaction(
     return { exit: claimedResult({ status: "idle" }) };
   }
 
-  if (remoteCompactionRequester && session.codexCompactionMode === "remote_v2") {
+  if (
+    preparedPortable ||
+    (remoteCompactionRequester && session.codexCompactionMode === "remote_v2")
+  ) {
     const forced = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
     const thresholdTokens = compactionThresholdTokens(eventing.modelRunSettings);
     if (

package/src/activities/agent-turn/errors.ts

@@ -16,7 +16,8 @@ import {
   type CompactionProviderRejection,
   isMcpRequestTimeoutError,
   isMcpTransportConnectivityError,
-  isModalTaskExecStartDnsResolutionError,
+  isModalTaskExecStartPreDispatchUnavailableError,
+  isRoutingMutationOutcomeUnknownError,
   RoutingWorkspaceRootChangedError,
   SandboxMaterializationVerificationError,
   materializationVerificationDiagnostic,
@@ -119,6 +120,7 @@ export function providerRecoveryResult(input: {
           input.failureCode === "sandbox_command_start_unavailable" ||
           input.failureCode === "mcp_transport_timeout" ||
           input.failureCode === "mcp_transport_unavailable" ||
+          input.failureCode === "turn_execution_policy_definition_mismatch" ||
           input.failureCode === POST_COMPACTION_CONTINUATION_EMPTY_CODE
         ? Math.max(
             providerDelay ?? 0,
@@ -1021,10 +1023,13 @@ function baseAgentRunFailurePayload(
       retryable: true,
     };
   }
-  if (isModalTaskExecStartDnsResolutionError(error)) {
+  if (
+    !isRoutingMutationOutcomeUnknownError(error) &&
+    isModalTaskExecStartPreDispatchUnavailableError(error)
+  ) {
     return {
       error:
-        "The managed sandbox command transport was temporarily unreachable before the command started. The same turn will retry after a short delay.",
+        "The managed sandbox command router was not ready before the command was sent. The same turn will retry after a short delay.",
       code: "sandbox_command_start_unavailable",
       retryable: true,
     };

package/src/activities/agent-turn/failure-settlement.ts

@@ -16,14 +16,14 @@ import {
 } from "@opengeni/db";
 import { publishDurableSessionEvents } from "@opengeni/events";
 import { maxTurnsExceededRunState } from "@opengeni/runtime";
-import { CancelledFailure } from "@temporalio/activity";
+import { ApplicationFailure, CancelledFailure } from "@temporalio/activity";
 import {
   authoritativeCodexCapacityResetAt,
   classifyCodexPin,
   selectCodexCredentialLeaseForTurn,
   type CodexRotationStrategy,
 } from "../codex-rotation";
-import type { Settings } from "@opengeni/config";
+import { TurnExecutionPolicyDefinitionMismatchError, type Settings } from "@opengeni/config";
 import {
   classifyCodexEncryptedArtifactRejection,
   classifyCodexUsageLimitError,
@@ -1499,10 +1499,28 @@ export async function settleTurnFailure(deps: TurnFailureDeps): Promise<RunAgent
   // truth, recover this SAME accepted turn, then let the workflow re-claim
   // it after a pacing delay. This is independent of goal state and never
   // relies on a synthetic continuation prompt.
-  let failure = agentRunFailurePayload(error, {
-    isCodexTurn: billingState.isCodexTurn,
-  }) as ReturnType<typeof agentRunFailurePayload>;
-  if (failure.retryable && eventing.publish && attempt.turnId && eventing.turnStartedPublished) {
+  // A rolling-deployment definition mismatch is a separate configuration
+  // class: only the exact typed setup error can use this checkpoint before
+  // eventing exists. No generic setup/credential failure gains retry authority.
+  const earlyDefinitionMismatch =
+    error instanceof TurnExecutionPolicyDefinitionMismatchError &&
+    !attempt.modelRequestStarted &&
+    !eventing.turnStartedPublished &&
+    !!attempt.turnId &&
+    !!attempt.triggerEventId &&
+    attempt.executionGeneration > 0;
+  let failure = (
+    earlyDefinitionMismatch
+      ? { error: error.message, code: error.code, retryable: true }
+      : agentRunFailurePayload(error, {
+          isCodexTurn: billingState.isCodexTurn,
+        })
+  ) as ReturnType<typeof agentRunFailurePayload>;
+  if (
+    attempt.turnId &&
+    (earlyDefinitionMismatch ||
+      (failure.retryable && eventing.publish && eventing.turnStartedPublished))
+  ) {
     const nextProviderRecoveryCount = attempt.providerRecoveryCount + 1;
     const recoveryResult = providerRecoveryResult({
       failureCode: failure.code,
@@ -1511,8 +1529,10 @@ export async function settleTurnFailure(deps: TurnFailureDeps): Promise<RunAgent
     });
     try {
       if (recoveryResult.status === "recovering") {
-        await flushRuntimeBatcher();
-        await historySink.reconcileConversationTruth({ requireDurable: true });
+        if (!earlyDefinitionMismatch) {
+          await flushRuntimeBatcher();
+          await historySink.reconcileConversationTruth({ requireDurable: true });
+        }
         const recovery = await requestSessionTurnRecovery(db, input.workspaceId, {
           sessionId: input.sessionId,
           turnId: attempt.turnId,
@@ -1540,6 +1560,18 @@ export async function settleTurnFailure(deps: TurnFailureDeps): Promise<RunAgent
         return claimedResult(recoveryResult);
       }
       failure = providerRecoveryExhaustedFailure(failure, recoveryResult);
+      if (earlyDefinitionMismatch) {
+        // Setup has no eventing sink yet. Carry only the fixed, safe diagnostic
+        // through Temporal into exact-attempt workflow failure settlement.
+        control.activityStatus = "failed";
+        control.turnMetricOutcome = "failed";
+        control.activityError = error;
+        throw ApplicationFailure.create({
+          message: `${error.message}. Automatic same-turn configuration recovery exhausted after ${recoveryResult.providerRecoveryCount} retries.`,
+          type: "TurnExecutionPolicyDefinitionMismatchError",
+          nonRetryable: true,
+        });
+      }
     } catch (recoveryError) {
       const escaped =
         recoveryResult.status === "recovering"

package/src/activities/agent-turn/history.ts

@@ -186,7 +186,20 @@ export function toolCallProducesRetainableSessionImage(name: string | null): boo
   return (
     name === "computer_screenshot" ||
     name === "view_image" ||
-    name === "interaction__computer_observe"
+    name === "interaction__computer_observe" ||
+    retainableBrowserScreenshotToolCall(name)
+  );
+}
+
+/** Browser interactions can carry an image block, including opt-in observe frames. */
+export function retainableBrowserScreenshotToolCall(name: string | null): boolean {
+  return (
+    name === "browser_screenshot" ||
+    name === "interaction__browser_screenshot" ||
+    name === "browser_observe" ||
+    name === "interaction__browser_observe" ||
+    name === "browser_act" ||
+    name === "interaction__browser_act"
   );
 }
 

package/src/activities/agent-turn/media-artifacts.ts

@@ -12,7 +12,7 @@ import {
   type TurnToolCancellationFence,
 } from "@opengeni/runtime";
 import type { Settings } from "@opengeni/config";
-import type { RetainedArtifactMetadata } from "@opengeni/contracts";
+import type { RetainedArtifactMetadata, RetainedSessionScreenshotKind } from "@opengeni/contracts";
 import type { ResumedTurnSandbox } from "../../sandbox-resume";
 import type { SharedActivityServices } from "../types";
 import {
@@ -79,6 +79,7 @@ export class TurnMediaArtifacts {
   sandboxFileDownloadBackend: Settings["sandboxBackend"];
   nativeImageGenerationRetention: NativeImageGenerationRetention | null = null;
   readonly retainedSessionImageCallIds = new Set<string>();
+  readonly retainedSessionImageKindsByCallId = new Map<string, RetainedSessionScreenshotKind>();
 
   constructor(private readonly deps: TurnMediaArtifactDeps) {
     this.sandboxFileDownloadBackend = deps.getModelRunSettings().sandboxBackend;

package/src/activities/agent-turn/sandbox-runtime.ts

@@ -1,7 +1,7 @@
 import {
   advanceWorkspaceGeneration,
   verifyWorkspaceMutationSettlement,
-  heartbeatLeaseHolder,
+  heartbeatLeaseHolderStatus,
   readLease,
   accrueWarmSeconds,
   SandboxWorkspaceMutationFencedError,
@@ -526,12 +526,15 @@ export function createSandboxTurnRuntime(deps: SandboxTurnRuntimeDeps) {
     // home turn that degraded to the cloud group box (swap-away / flag-off), that
     // is the deployment default (modal), so the fallback box is warm-metered at
     // the cloud rate instead of selfhosted's rate-0 (which would under-bill).
-    const warmRate = sandboxWarmRateMicrosPerSecond(
-      settings,
-      warmBackend ?? (sandbox.established.backendId as Settings["sandboxBackend"]),
-    );
+    const warmRate =
+      settings.sandboxWarmBillingMode === "usage_only"
+        ? 0
+        : sandboxWarmRateMicrosPerSecond(
+            settings,
+            warmBackend ?? (sandbox.established.backendId as Settings["sandboxBackend"]),
+          );
     sandboxState.leaseHeartbeatTimer = setInterval(() => {
-      void heartbeatLeaseHolder(db, {
+      void heartbeatLeaseHolderStatus(db, {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         sandboxGroupId: heartbeatGroupId,
@@ -539,9 +542,17 @@ export function createSandboxTurnRuntime(deps: SandboxTurnRuntimeDeps) {
         holderId: heartbeatHolderId,
         leaseTtlMs: settings.sandboxLeaseTtlMs,
         expectedEpoch: heartbeatEpoch,
+        billingMode: settings.sandboxWarmBillingMode,
       })
-        .then(async (alive) => {
-          if (alive) return;
+        .then(async (status) => {
+          if (status.fence === "funding") {
+            stopLeaseHeartbeat();
+            sandboxRotationController.abort(
+              new Error("Insufficient OpenGeni credits to extend paid sandbox compute"),
+            );
+            return;
+          }
+          if (status.leaseExtended) return;
           const rotation = await beginRotationPreemption(sandbox, heartbeatEpoch, heartbeatGroupId);
           if (rotation === "not_rotating") {
             // The holder was reaped, the exact attempt closed, the epoch was
@@ -557,9 +568,14 @@ export function createSandboxTurnRuntime(deps: SandboxTurnRuntimeDeps) {
         sandboxGroupId: heartbeatGroupId,
         expectedEpoch: heartbeatEpoch,
         warmRateMicrosPerSecond: warmRate,
+        billingMode: settings.sandboxWarmBillingMode,
         subjectId: input.sessionId,
       })
-        .then((result) => recordCreditMicros(observability, "usage", result.costMicros))
+        .then((result) => {
+          if (settings.sandboxWarmBillingMode === "credits") {
+            recordCreditMicros(observability, "usage", result.costMicros);
+          }
+        })
         .catch(() => undefined);
       // MID-SESSION snapshot (sandbox-file-persistence): while the turn holds
       // the box, fold a fresh /workspace snapshot onto the lease every

package/src/activities/agent-turn/stream-attempt.ts

@@ -61,7 +61,7 @@ import {
 import {
   compactRetainedScreenshotHistory,
   sdkEventContainsInlineImage,
-  retainComputerScreenshot,
+  retainSessionScreenshot,
   typedScreenshotFromSdkEvent,
   unavailableRetainedSessionImage,
 } from "../retained-screenshots";
@@ -108,6 +108,7 @@ import {
 import {
   pendingToolCallFromSdkEvent,
   toolCallProducesRetainableSessionImage,
+  retainableBrowserScreenshotToolCall,
   completedToolCallFromSdkEvent,
 } from "./history";
 import { checkpointHistoryBeforeProviderDispatch } from "./provider-dispatch-barrier";
@@ -1125,6 +1126,12 @@ export async function runTurnStreamAttempt(
           currentToolBatchCallIds.add(pendingToolCall.callId);
           if (toolCallProducesRetainableSessionImage(pendingToolCall.callName)) {
             media.retainedSessionImageCallIds.add(pendingToolCall.callId);
+            if (retainableBrowserScreenshotToolCall(pendingToolCall.callName)) {
+              media.retainedSessionImageKindsByCallId.set(
+                pendingToolCall.callId,
+                "browser_screenshot",
+              );
+            }
           }
         }
         const completedToolCall = completedToolCallFromSdkEvent(durableSdkEvent);
@@ -1147,6 +1154,7 @@ export async function runTurnStreamAttempt(
               toolCallId: completedToolCall.callId,
               toolOutputId: completedToolCall.callId,
               reason: "unsupported",
+              kind: media.retainedSessionImageKindsByCallId.get(completedToolCall.callId),
             });
             media.retainedScreenshotReceiptsByCallId.set(
               completedToolCall.callId,
@@ -1169,12 +1177,13 @@ export async function runTurnStreamAttempt(
               toolCallId: typedScreenshot.callId,
               toolOutputId: typedScreenshot.toolOutputId,
               reason: "pending",
+              kind: media.retainedSessionImageKindsByCallId.get(completedToolCall.callId),
             });
             media.retainedScreenshotReceiptsByCallId.set(
               completedToolCall.callId,
               retainedScreenshotMetadata,
             );
-            retainedScreenshotMetadata = await retainComputerScreenshot({
+            retainedScreenshotMetadata = await retainSessionScreenshot({
               db,
               objectStorage,
               accountId: input.accountId,
@@ -1183,6 +1192,7 @@ export async function runTurnStreamAttempt(
               turnId: activeTurnId,
               attemptId: input.attemptId,
               output: typedScreenshot,
+              kind: media.retainedSessionImageKindsByCallId.get(completedToolCall.callId),
             });
             media.retainedScreenshotReceiptsByCallId.set(
               completedToolCall.callId,
@@ -1339,6 +1349,7 @@ export async function runTurnStreamAttempt(
           }
           for (const callId of stableToolCallIdsToClear) {
             media.retainedSessionImageCallIds.delete(callId);
+            media.retainedSessionImageKindsByCallId.delete(callId);
           }
         }
       }

package/src/activities/context-compaction.ts

@@ -9,7 +9,8 @@ import {
 import {
   EmptyCompactionSummaryError,
   REMOTE_COMPACTION_V2_IMPLEMENTATION,
-  SUMMARY_BUFFER_TOKENS,
+  compactionSummaryOutputTokens,
+  buildSummaryItem,
   buildCompactionReplacementHistory,
   buildRemoteV2ReplacementHistory,
   compactionThresholdTokens,
@@ -58,7 +59,13 @@ export type MaybeCompactResult =
  * Codex, call Codex `/codex/responses` with `compaction_trigger` and persist the
  * opaque compaction item. Fail closed — never silently fall back to portable.
  */
-export type CompactionSummarizer = (settings: Settings, input: CompactionItem[]) => Promise<string>;
+export type CompactionSummarizer = ((
+  settings: Settings,
+  input: CompactionItem[],
+) => Promise<string>) & {
+  /** Model-visible instructions and tool schemas outside the history estimate. */
+  estimatePrefixTokens?: () => number;
+};
 
 /** Returns the opaque Codex remote compaction v2 item. */
 export type RemoteCompactionV2Requester = (
@@ -81,7 +88,7 @@ export async function maybeCompactContext(
   // Injectable for tests; defaults to the real provider-aware model call.
   summarize: CompactionSummarizer = (s, m) =>
     summarizeForCompaction(s, m, {
-      maxOutputTokens: SUMMARY_BUFFER_TOKENS,
+      maxOutputTokens: compactionSummaryOutputTokens(s.contextWindowTokens),
     }),
   // Operator-forced (the /compact command): bypass the budget trigger and
   // compact now if there is anything to summarize. Structural guards still hold.
@@ -300,6 +307,7 @@ async function settleSkippedAfterStart(
   reason:
     | "no_history"
     | "replacement_not_smaller"
+    | "replacement_exceeds_model_budget"
     | "replacement_unchanged"
     | "summarization_failed",
 ): Promise<Extract<MaybeCompactResult, { compacted: false }>> {
@@ -455,12 +463,23 @@ async function compactContextPortable(
   const summarized = await summarizeWithCodexOverflowTrimming(summarize, settings, items);
   const summaryBody = summarized.summaryBody;
   const retainedTokens = await retentionTokenCounts(canonicalItems, projectForWire);
+  const outputReserve = compactionSummaryOutputTokens(settings.contextWindowTokens);
+  const structuralBudget = Math.min(
+    contextInputBudgetTokens(settings) || settings.contextWindowTokens - outputReserve,
+    settings.contextWindowTokens - outputReserve,
+  );
+  const prefixTokens = Math.max(0, Math.ceil(summarize.estimatePrefixTokens?.() ?? 0));
+  const summaryTokens = estimateTokens([buildSummaryItem(summaryBody)]);
   const replacementHistory = buildCompactionReplacementHistory(
     canonicalItems,
     summaryBody,
     (item) => retainedTokens.get(item) ?? estimateTokens([item]),
+    Math.min(outputReserve, Math.max(0, structuralBudget - prefixTokens - summaryTokens)),
   );
   const estimatedTokensAfter = estimateTokens(await projectForWire(replacementHistory));
+  if (estimatedTokensAfter + prefixTokens > structuralBudget) {
+    return await settleSkippedAfterStart(db, scope, options, "replacement_exceeds_model_budget");
+  }
   const replacementFingerprint = compactionReplacementFingerprint(replacementHistory);
   const previousReplacementFingerprint = latestCompactionReplacementFingerprint(canonicalItems);
   const summaryIndex =
@@ -520,7 +539,7 @@ async function compactContextPortable(
   };
 }
 
-async function summarizeWithCodexOverflowTrimming(
+export async function summarizeWithCodexOverflowTrimming(
   summarize: CompactionSummarizer,
   settings: Settings,
   activeHistory: CompactionItem[],
@@ -531,17 +550,32 @@ async function summarizeWithCodexOverflowTrimming(
 }> {
   // Codex's estimator is intentionally coarse. Keep the explicit checkpoint
   // request below both the effective input window and the raw window minus the
-  // requested summary, then leave 15% estimator headroom. This changes only the
-  // temporary summarizer input; durable active history remains untouched until
-  // applyContextCompaction succeeds under the attempt fence.
-  const summaryAwareBudget = Math.max(0, settings.contextWindowTokens - SUMMARY_BUFFER_TOKENS);
+  // requested summary. Preserve the full portable history copy on the first
+  // call whenever it fits; only trim further after an actual provider overflow.
+  // Durable active history remains untouched until applyContextCompaction.
+  const summaryAwareBudget = Math.max(
+    0,
+    settings.contextWindowTokens - compactionSummaryOutputTokens(settings.contextWindowTokens),
+  );
   const configuredInputBudget = contextInputBudgetTokens(settings);
   const structuralBudget = Math.min(
     configuredInputBudget > 0 ? configuredInputBudget : summaryAwareBudget,
     summaryAwareBudget,
   );
-  const initialBudget = Math.floor(structuralBudget * 0.85);
+  const prefixTokens = Math.max(0, Math.ceil(summarize.estimatePrefixTokens?.() ?? 0));
+  const initialBudget = Math.max(0, structuralBudget - prefixTokens);
   let preparation = prepareCompactionPromptInput(activeHistory, initialBudget);
+  // A checkpoint prompt without source history cannot summarize that history.
+  // Do not let a plausible-sounding reply replace durable active context.
+  const requireHistory = () => {
+    if (activeHistory.length > 0 && preparation.input.length === 1) {
+      throw new EmptyCompactionSummaryError({
+        stage: "portable_input_budget",
+        reason: "no_history_fit",
+      });
+    }
+  };
+  requireHistory();
   try {
     return {
       summaryBody: await summarize(settings, preparation.input),
@@ -551,15 +585,16 @@ async function summarizeWithCodexOverflowTrimming(
   } catch (error) {
     if (!isContextWindowExceeded(error)) throw error;
     // The provider is more authoritative than the byte/4 estimate. Refit once
-    // to 70% of both the configured target and the actual prepared estimate;
+    // to 40% of both the available target and the actual prepared estimate;
     // then fail terminally with prior history intact. Never issue one failing
-    // request per oldest item. The production incident proved that the
-    // provider can count slightly more than twice the byte/4 estimate, so a
-    // half-size retry is the smallest honest bound for that observed skew.
+    // request per oldest item. The retry is bounded, not a guarantee: the
+    // provider can count slightly more than twice the byte/4 estimate. The
+    // prepared prefix has already been reserved from the available budget.
     const retryBudget = Math.floor(
-      Math.min(initialBudget * 0.5, preparation.estimatedInputTokens * 0.5),
+      Math.min(initialBudget * 0.4, preparation.estimatedInputTokens * 0.4),
     );
     preparation = prepareCompactionPromptInput(activeHistory, retryBudget);
+    requireHistory();
     return {
       summaryBody: await summarize(settings, preparation.input),
       preparation,