maka-agent 0.2.0-dev.12.20260901 → 0.2.0-dev.14.20260902

package/node_modules/@maka/runtime/dist/ai-sdk-compaction.js

@@ -29,8 +29,9 @@ import { baseToolResultProjection, reduceEffectiveModelProjections, } from './mo
 import { buildRuntimeEventModelReplayPlan, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, } from './model-history.js';
 import { toolSchemaCharsForDiagnostics } from './request-shape.js';
 import { estimateNextRequestTokens, exceedsHighWater, planHistoryCompaction, } from './history-compaction.js';
-import { resolveContextBudgetCapacity, } from './context-budget-policy.js';
-import { collectHistoricalImageToolResults, omitHistoricalImageToolResults, } from './provider-image-overflow-recovery.js';
+import { resolveSelectedModelContextWindow } from './context-budget-policy.js';
+import { MATERIALIZED_IMAGE_TOKENS } from '@maka/core/attachments';
+import { collectHistoricalImageToolResults, isInlineImageFilePart, omitHistoricalImageToolResults, } from './provider-image-overflow-recovery.js';
 export class AiSdkCompaction {
     input;
     sessionId;
@@ -532,7 +533,9 @@ export class AiSdkCompaction {
      * Mid-turn capacity compaction eligibility (issue #882 PR 1). Explicit
      * opt-in via `historyCompact.midTurn.enabled`; requires the checkpoint
      * writer seams plus the durable turn-ledger read, the persisted head anchor
-     * for this turn, and a bounded capacity window.
+     * for this turn. A model that declares no context window still gets this
+     * state: reactive recovery runs off a real provider rejection and needs no
+     * window at all.
      */
     buildMidTurnCapacityCompactState(input) {
         const policy = this.input.contextBudget;
@@ -556,13 +559,19 @@ export class AiSdkCompaction {
             !isHistoryCompactContentEvent(headAnchor)) {
             return undefined;
         }
-        const capacity = resolveContextBudgetCapacity(this.input.connection, this.input.modelId, policy);
-        if (capacity === undefined)
-            return undefined;
         const priorContentEvents = (input.runtimeContext ?? [])
             .filter((event) => event.turnId !== input.turnId)
             .filter(isHistoryCompactContentEvent);
-        return new MidTurnCapacityCompactState(headAnchor, priorContentEvents, input.runtimeContextRunHeaders ?? [], capacity);
+        const state = new MidTurnCapacityCompactState(headAnchor, priorContentEvents, input.runtimeContextRunHeaders ?? [], resolveSelectedModelContextWindow(this.input.connection, this.input.modelId));
+        // Seed the turn's FIRST request with the last request the provider
+        // actually counted, so step 0 is estimated like every later step instead
+        // of guessing the whole payload at char/4.
+        const persisted = persistedRequestAnchor(input.runtimeContext ?? [], state.priorRunHeaders, this.input.modelId, this.targetConnectionId);
+        if (persisted) {
+            state.lastRequestInputTokens = persisted.inputTokens;
+            state.lastRequestPayloadChars = persisted.payloadChars;
+        }
+        return state;
     }
     /**
      * Request-projection stage for the mid-turn capacity invariant: between
@@ -573,15 +582,12 @@ export class AiSdkCompaction {
      * `[compact block, verbatim head anchor]`.
      *
      * This hook never terminates the turn: every failure fails open with a
-     * diagnostic and records itself for the final-request estimate owner, which
-     * re-measures the payload after ALL shaping (including active tool-result
-     * pruning, which runs later and can still rescue the step) and issues the
-     * context_budget_exhausted verdict only when the request that would really
-     * go out exceeds the window. The trigger threshold here is deliberately
-     * approximate — a missed or spurious trigger is recoverable; the verdict is
-     * not, so it does not live here.
+     * diagnostic and the request goes out. The trigger threshold is approximate
+     * on purpose — a missed or spurious trigger costs at most one compaction,
+     * and whether the request actually fits is the provider's answer, not a
+     * local estimate's.
      */
-    buildMidTurnCapacityCompactProjection(turnId, state, queue, providerTools, fallbackActiveTools, systemPromptChars, onDiagnosticPatch, origin, memoryCompactionDecision, onMemoryCompaction, abortSignal) {
+    buildMidTurnCapacityCompactProjection(turnId, state, queue, providerTools, onDiagnosticPatch, origin, memoryCompactionDecision, onMemoryCompaction, abortSignal) {
         if (!state)
             return undefined;
         const policy = this.input.contextBudget;
@@ -596,10 +602,6 @@ export class AiSdkCompaction {
             projectedMessages =
                 projectHistoricalImageOmissions(projectedMessages ?? incomingMessages, state.omittedImageToolResults) ?? projectedMessages;
             const keepProjection = () => projectedMessages ? { messages: projectedMessages } : undefined;
-            // Step 0 is shaped by the pre_turn path; the mid-turn trigger only runs
-            // between steps, once completed-step usage and events exist.
-            if (options.stepNumber < 1 || state.exhaustedDetail)
-                return keepProjection();
             // Real usage for the last finished step, read synchronously from the
             // SDK's own step results (the same numbers the finish-step chunk
             // carries) — no coupling to how far the stream consumer has advanced.
@@ -619,14 +621,22 @@ export class AiSdkCompaction {
             // request's chars would under-estimate the retry by the whole previous
             // step growth — so a missing baseline forces the whole-payload cold
             // start, exactly like a missing usage sample.
-            const lastStepInputTokens = options.completedSteps.at(-1)?.usage?.inputTokens;
-            state.lastRequestInputTokens =
-                state.lastRequestPayloadChars !== undefined &&
-                    lastStepInputTokens !== undefined &&
-                    Number.isFinite(lastStepInputTokens) &&
-                    lastStepInputTokens > 0
-                    ? lastStepInputTokens
-                    : undefined;
+            //
+            // Before the first step finishes nothing in-send has overwritten the
+            // seeded pair, so leave it alone rather than clearing a coherent anchor.
+            if (options.completedSteps.length > 0) {
+                const lastStepInputTokens = options.completedSteps.at(-1)?.usage?.inputTokens;
+                state.lastRequestInputTokens =
+                    state.lastRequestPayloadChars !== undefined &&
+                        lastStepInputTokens !== undefined &&
+                        Number.isFinite(lastStepInputTokens) &&
+                        lastStepInputTokens > 0
+                        ? lastStepInputTokens
+                        : undefined;
+            }
+            // The turn's first request folds as a pre_turn boundary, like the
+            // reactive step-0 recovery; later steps fold mid_turn.
+            const phase = options.stepNumber === 0 ? 'pre_turn' : 'mid_turn';
             // A skipped trigger is never silent: every failure-driven skip records a
             // failedOpen decision.
             const failOpen = (failOpenReason) => {
@@ -635,7 +645,7 @@ export class AiSdkCompaction {
                         stage: 'activeStep',
                         sourceKind: 'runtimeEvents',
                         decision: 'failedOpen',
-                        phase: 'mid_turn',
+                        phase,
                         boundaryKind: 'historyCompact',
                         reason: 'context_limit',
                         failOpenReason,
@@ -644,12 +654,10 @@ export class AiSdkCompaction {
                 });
                 return keepProjection();
             };
-            // A shaping failure additionally records itself for the final-request
-            // estimate owner: when the final payload is still over the window, the
-            // owner turns this step's failure into the terminal detail instead of
-            // re-entering a shaper that already attempted and failed.
-            const shapeFailure = (detail, diagnosticReason) => {
-                state.lastShapeFailure = { stepNumber: options.stepNumber, detail, diagnosticReason };
+            // A shaping failure records the step so the rescue re-entry does not
+            // re-run a shaper that already attempted and failed this step.
+            const shapeFailure = (diagnosticReason) => {
+                state.lastShapeFailure = { stepNumber: options.stepNumber };
                 return failOpen(diagnosticReason);
             };
             // Trigger estimate: the last request's input tokens plus a SIGNED char/4 delta of
@@ -661,21 +669,27 @@ export class AiSdkCompaction {
             // over-trigger; that is the recoverable direction, and the verdict owner
             // re-measures the post-shaping payload.
             const measuredMessages = projectedMessages ?? incomingMessages;
-            const activeToolsForStep = options.activeTools ?? fallbackActiveTools();
-            const payloadChars = midTurnRequestPayloadChars(measuredMessages, providerTools, activeToolsForStep, systemPromptChars);
+            // Price the request dispatch will actually build, not the pre-dispatch
+            // inputs: a finalization step adds prompt fragments and sends no tools.
+            const dispatch = options.resolveDispatch(options.activeTools);
+            const activeToolsForStep = dispatch.activeTools;
+            const payloadChars = midTurnRequestPayloadChars(measuredMessages, providerTools, activeToolsForStep, dispatch.systemPromptChars, charsPerToken);
             const forcedEstimate = state.forcedTriggerEstimate;
             state.forcedTriggerEstimate = undefined;
-            const estimate = forcedEstimate ??
-                estimateNextRequestTokens({
-                    ...(state.lastRequestInputTokens !== undefined
-                        ? { priorUsageTokens: state.lastRequestInputTokens }
-                        : {}),
-                    appendedChars: payloadChars - (state.lastRequestPayloadChars ?? payloadChars),
-                    charsPerToken,
-                    coldStartChars: payloadChars,
-                });
+            const anchored = requestEstimateAnchor(state, payloadChars);
+            // The turn's FIRST request only gets a trigger when a previous turn left
+            // a usable anchor. Without one the estimate is the whole payload at
+            // chars/4 — the same guess the pre_turn gate already spends, and far too
+            // crude to start a summarizer on. With one, step 0 is judged exactly like
+            // every later step.
+            if (options.stepNumber < 1 &&
+                forcedEstimate === undefined &&
+                anchored.priorUsageTokens === undefined) {
+                return keepProjection();
+            }
+            const estimate = forcedEstimate ?? estimateNextRequestTokens({ ...anchored, charsPerToken });
             if (forcedEstimate === undefined &&
-                !exceedsHighWater(estimate, state.capacity.tokens, reserveTokens)) {
+                (state.capacity === undefined || !exceedsHighWater(estimate, state.capacity, reserveTokens))) {
                 return keepProjection();
             }
             // Fold a safe completed prefix of the durable turn ledger into a
@@ -684,6 +698,7 @@ export class AiSdkCompaction {
             // keep the raw projection on skip/fail, apply the fold on success.
             const outcome = await this.compactActiveRequestHistory({
                 turnId,
+                phase,
                 origin,
                 state,
                 queue,
@@ -691,13 +706,13 @@ export class AiSdkCompaction {
                 referencePayloadChars: payloadChars,
                 providerTools,
                 activeToolsForStep,
-                systemPromptChars,
+                systemPromptChars: dispatch.systemPromptChars,
                 memoryCompactionDecision,
                 onMemoryCompaction,
                 abortSignal,
             });
             if (outcome.decision === 'fail') {
-                return shapeFailure(outcome.detail, outcome.diagnosticReason);
+                return shapeFailure(outcome.diagnosticReason);
             }
             acceptedProjection = {
                 sourceSignatures: incomingMessages.map(modelMessageSignature),
@@ -729,7 +744,6 @@ export class AiSdkCompaction {
         if (state.malformedSummaryFailure) {
             return {
                 decision: 'fail',
-                detail: state.malformedSummaryFailure,
                 diagnosticReason: state.malformedSummaryFailure,
             };
         }
@@ -777,14 +791,12 @@ export class AiSdkCompaction {
             if (abortSignal?.aborted) {
                 return {
                     decision: 'fail',
-                    detail: 'no_safe_completed_span',
                     diagnosticReason: 'ledger_wait_aborted',
                 };
             }
             if (queue.consumerDetached) {
                 return {
                     decision: 'fail',
-                    detail: 'no_safe_completed_span',
                     diagnosticReason: 'ledger_wait_aborted',
                 };
             }
@@ -799,7 +811,6 @@ export class AiSdkCompaction {
         catch {
             return {
                 decision: 'fail',
-                detail: 'no_safe_completed_span',
                 diagnosticReason: 'ledger_read_failed',
             };
         }
@@ -811,7 +822,6 @@ export class AiSdkCompaction {
         if (!currentTurnEvents.some((event) => event.id === state.headAnchor.id)) {
             return {
                 decision: 'fail',
-                detail: 'no_safe_completed_span',
                 diagnosticReason: 'head_anchor_not_durable',
             };
         }
@@ -822,7 +832,7 @@ export class AiSdkCompaction {
             phase: input.phase ?? 'mid_turn',
             orderedEvents,
             headAnchor: { runtimeEventId: state.headAnchor.id, turnId },
-            reserveTailEvents: midTurn.reserveTailEvents ?? 1,
+            reserveTailEvents: 1,
             charsPerToken,
             now: this.now(),
             ...(compactPolicy.highWaterName !== undefined
@@ -851,7 +861,9 @@ export class AiSdkCompaction {
                     ...(previousCheckpoint ? { previousCheckpoint } : {}),
                     newlyFoldedRuntimeEvents: [...newlyFoldedRuntimeEvents],
                     inputBudget: {
-                        maxEstimatedTokens: Math.max(1, state.capacity.tokens - reserveTokens),
+                        ...(state.capacity !== undefined
+                            ? { maxEstimatedTokens: Math.max(1, state.capacity - reserveTokens) }
+                            : {}),
                         charsPerToken,
                     },
                     ...(abortSignal ? { abortSignal } : {}),
@@ -866,9 +878,6 @@ export class AiSdkCompaction {
             }
             return {
                 decision: 'fail',
-                detail: isMalformedHistoryCompactSummaryReason(diagnosticReason)
-                    ? diagnosticReason
-                    : plan.reason,
                 diagnosticReason,
             };
         }
@@ -886,7 +895,6 @@ export class AiSdkCompaction {
             (replayPlan.hasProviderNativeSemantics && !this.canReplayProviderNative(replayPlan))) {
             return {
                 decision: 'fail',
-                detail: 'no_safe_completed_span',
                 diagnosticReason: 'replacement_unmaterializable',
             };
         }
@@ -896,11 +904,10 @@ export class AiSdkCompaction {
         // request that overflowed for reactive recovery): a materialized
         // replacement that is not smaller proves the summarizer's OUTPUT is
         // unusable, reported as summarizer_failed via replacement_not_smaller.
-        const replacedPayloadChars = midTurnRequestPayloadChars(replacementMessages, providerTools, activeToolsForStep, systemPromptChars);
+        const replacedPayloadChars = midTurnRequestPayloadChars(replacementMessages, providerTools, activeToolsForStep, systemPromptChars, charsPerToken);
         if (replacedPayloadChars >= input.referencePayloadChars) {
             return {
                 decision: 'fail',
-                detail: 'summarizer_failed',
                 diagnosticReason: 'replacement_not_smaller',
             };
         }
@@ -911,7 +918,6 @@ export class AiSdkCompaction {
         if (!replayFit.fits) {
             return {
                 decision: 'fail',
-                detail: 'head_anchor_exceeds_capacity',
                 diagnosticReason: `replay_rejected_${replayFit.reason}`,
             };
         }
@@ -924,7 +930,6 @@ export class AiSdkCompaction {
         catch {
             return {
                 decision: 'fail',
-                detail: 'summarizer_failed',
                 diagnosticReason: 'write_failed',
             };
         }
@@ -956,8 +961,8 @@ export class AiSdkCompaction {
      * latch (pi's `_overflowRecoveryAttempted`). Returns the compacted messages
      * to resend, or undefined when recovery is impossible or already spent, in
      * which case the caller surfaces the real provider error rather than a
-     * fabricated success or a synthesized `context_budget_exhausted` (the
-     * provider — not the runtime — rejected the request). Non-context-length
+     * fabricated success or a locally synthesized verdict (the provider — not the
+     * runtime — rejected the request). Non-context-length
      * errors and turns without the mid-turn seam never reach compaction, so the
      * default (no seam) behavior is already better than the old fake end_turn.
      */
@@ -987,7 +992,7 @@ export class AiSdkCompaction {
         // The cold-start fallback only covers a send whose verdict owner never
         // ran request projection (defensive; step 0 records the baseline too).
         const referencePayloadChars = state.lastRequestPayloadChars ??
-            midTurnRequestPayloadChars(input.currentMessages, input.providerTools, input.activeTools, input.systemPromptChars);
+            midTurnRequestPayloadChars(input.currentMessages, input.providerTools, input.activeTools, input.systemPromptChars, this.input.contextBudget?.charsPerToken ?? 4);
         const phase = input.stepNumber === 0 ? 'pre_turn' : 'mid_turn';
         const outcome = await this.compactActiveRequestHistory({
             turnId: input.turnId,
@@ -1039,8 +1044,11 @@ export class AiSdkCompaction {
         // Reset the baseline: the capacity hook's usage anchor is only coherent
         // paired with the payload chars of the SAME request, and a missing
         // baseline forces the whole-payload cold-start estimate instead of a
-        // stale pairing against the dead attempt.
+        // stale pairing against the dead attempt. The cross-turn seed goes with
+        // it: falling back to an even older request's anchor pairs worse, not
+        // better.
         state.lastRequestPayloadChars = undefined;
+        state.lastRequestInputTokens = undefined;
         return { messages: outcome.replacementMessages };
     }
     /**
@@ -1048,8 +1056,8 @@ export class AiSdkCompaction {
      * invariant. Every request-projection stage only shapes; this wrapper measures the
      * FINAL outgoing (messages, tools) payload — the bytes the provider will
      * actually see, after capacity compaction, active tool-result pruning, and
-     * semantic/active-full compaction have all run — and issues the one
-     * safety-critical verdict:
+     * semantic/active-full compaction have all run — and spends the last
+     * chance to shrink it:
      *
      *  - estimate = the last request's real INPUT tokens + signed char/4 delta
      *    against the previous request's measured payload (recorded here on
@@ -1059,50 +1067,43 @@ export class AiSdkCompaction {
      *    cold start rather than a zero baseline;
      *  - over the window with no capacity attempt this step (the approximate
      *    trigger missed, e.g. growth the trigger under-weighted), force ONE
-     *    capacity re-entry — the verdict must not terminate a turn a shaper can
-     *    still rescue, and one bounded re-entry preserves termination;
-     *  - still over the window → context_budget_exhausted, with the terminal
-     *    detail taken from this step's capacity outcome: a replacement that
-     *    remains too large is head_anchor_exceeds_capacity (the irreducible
-     *    remainder exceeds capacity); a recorded shaping failure keeps its own
-     *    detail and diagnostic reason.
+     *    capacity re-entry.
      *
-     * Step 0 is shaped by the pre_turn path. It is still measured here so an
-     * unshapable first request cannot bypass the capacity invariant.
+     * Still over afterwards, the request goes out anyway: only the provider
+     * knows whether it fits, and a rejection is recovered from.
      */
-    buildMidTurnFinalRequestVerdict(input) {
-        const { shaped, reentry, state, providerTools, fallbackActiveTools, charsPerToken, systemPromptChars, onDiagnosticPatch, abortController, } = input;
+    buildMidTurnFinalRequestRescue(input) {
+        const { shaped, reentry, state, providerTools, charsPerToken } = input;
         return async (options) => {
             let result = await Promise.resolve(shaped(options));
             const omissionProjection = projectHistoricalImageOmissions(result?.messages ?? options.messages, state.omittedImageToolResults);
             if (omissionProjection) {
                 result = { ...(result ?? {}), messages: omissionProjection };
             }
-            const finalPayloadChars = () => midTurnRequestPayloadChars(result?.messages ?? options.messages, providerTools, result?.activeTools ?? options.activeTools ?? fallbackActiveTools(), systemPromptChars);
+            const finalPayloadChars = () => {
+                // Measure the dispatched shape, so the payload recorded as the anchor's
+                // pair describes the same request the provider counts.
+                const dispatch = options.resolveDispatch(result?.activeTools ?? options.activeTools);
+                return midTurnRequestPayloadChars(result?.messages ?? options.messages, providerTools, dispatch.activeTools, dispatch.systemPromptChars, charsPerToken);
+            };
             let payloadChars = finalPayloadChars();
-            if ((options.stepNumber >= 1 || state.capacity.source === 'policy_fallback') &&
-                !state.exhaustedDetail) {
+            // Same rule as the trigger: the turn's first request is measured only
+            // when a previous turn left a usable anchor to measure it against.
+            const anchoredAtStepZero = requestEstimateAnchor(state, payloadChars).priorUsageTokens !== undefined;
+            if (state.capacity !== undefined && (options.stepNumber >= 1 || anchoredAtStepZero)) {
                 const estimateFinal = () => estimateNextRequestTokens({
-                    ...(state.lastRequestInputTokens !== undefined
-                        ? { priorUsageTokens: state.lastRequestInputTokens }
-                        : {}),
-                    appendedChars: payloadChars - (state.lastRequestPayloadChars ?? payloadChars),
+                    ...requestEstimateAnchor(state, payloadChars),
                     charsPerToken,
-                    coldStartChars: payloadChars,
                 });
-                let estimate = estimateFinal();
+                const estimate = estimateFinal();
                 const capacityAttemptedThisStep = state.replacedStepNumber === options.stepNumber ||
                     state.lastShapeFailure?.stepNumber === options.stepNumber;
-                if (options.stepNumber >= 1 &&
-                    estimate > state.capacity.tokens &&
-                    !capacityAttemptedThisStep) {
-                    // One bounded capacity re-entry: the trigger threshold is
-                    // approximate on purpose (recoverable), so a miss must become a
-                    // rescue attempt before it can become a terminal verdict. Re-run
-                    // only the capacity + prune shapers over the already-shaped
-                    // projection; a second attempt after a same-step failure is
-                    // pointless (the failure was not a trigger miss) and would double
-                    // recorder counters and summarizer calls.
+                if (estimate > state.capacity && !capacityAttemptedThisStep) {
+                    // One bounded capacity re-entry. Re-run only the capacity + prune
+                    // shapers over the already-shaped projection; a second attempt
+                    // after a same-step failure is pointless (the failure was not a
+                    // trigger miss) and would double recorder counters and summarizer
+                    // calls.
                     state.forcedTriggerEstimate = estimate;
                     const reshaped = await Promise.resolve(reentry({
                         ...options,
@@ -1118,33 +1119,6 @@ export class AiSdkCompaction {
                         };
                     }
                     payloadChars = finalPayloadChars();
-                    estimate = estimateFinal();
-                }
-                if (estimate > state.capacity.tokens) {
-                    const failure = state.lastShapeFailure?.stepNumber === options.stepNumber
-                        ? state.lastShapeFailure
-                        : undefined;
-                    const replacedThisStep = state.replacedStepNumber === options.stepNumber;
-                    const detail = replacedThisStep
-                        ? 'head_anchor_exceeds_capacity'
-                        : (failure?.detail ?? 'no_safe_completed_span');
-                    const diagnosticReason = replacedThisStep
-                        ? 'head_anchor_exceeds_capacity'
-                        : (failure?.diagnosticReason ?? 'no_safe_completed_span');
-                    state.exhaustedDetail = detail;
-                    onDiagnosticPatch({
-                        ...compactionDecisionDiagnosticPatch({
-                            stage: 'activeStep',
-                            sourceKind: 'runtimeEvents',
-                            decision: 'unchanged',
-                            phase: 'mid_turn',
-                            boundaryKind: 'historyCompact',
-                            reason: 'context_budget_exhausted',
-                            skippedReasonCounts: { [diagnosticReason]: 1 },
-                        }),
-                    });
-                    abortController?.abort(new Error(`mid-turn context budget exhausted: ${detail}`));
-                    return result;
                 }
             }
             state.lastRequestPayloadChars = payloadChars;
@@ -1250,6 +1224,9 @@ export class MidTurnCapacityCompactState {
      * Raw serialized chars of the final provider request. Overflow recovery
      * uses this as its shrink-reference baseline because it must compare the
      * actual rejected projection with a candidate replacement.
+     *
+     * Seeded before the turn's first request from the anchor a previous turn
+     * persisted, so it can describe a request from an earlier send.
      */
     lastRequestPayloadChars;
     /**
@@ -1260,14 +1237,16 @@ export class MidTurnCapacityCompactState {
      * them twice. Undefined when the last step's usage is missing or unusable
      * (no positive input count); estimates then fall back to the whole-payload
      * cold-start path — an unusable sample is unknown, never zero.
+     *
+     * Written and cleared as a pair with `lastRequestPayloadChars`, seeded from
+     * the previous turn's persisted anchor — see `LastRequestAnchor` for why the
+     * two only mean anything together.
      */
     lastRequestInputTokens;
     /** Latest durable checkpoint (loaded or written) for roll-forward summaries. */
     previousCheckpoint;
     /** Checkpoint accepted during this send; pins every later durable projection. */
     projectionCheckpoint;
-    /** Set when the turn must end with a context_budget_exhausted outcome. */
-    exhaustedDetail;
     /**
      * Step whose request the capacity hook replaced. Semantic/active-full
      * compaction yields on that exact step so one step never runs two
@@ -1290,15 +1269,16 @@ export class MidTurnCapacityCompactState {
     /** Exact historical image results omitted after a provider overflow. */
     omittedImageToolResults = new Map();
     /**
-     * The capacity hook's most recent shaping failure. The owner reads it (for
-     * the same step only) to pick the terminal detail and diagnostic reason
-     * when the final payload is over the window, and to avoid re-entering a
-     * shaper that already attempted and failed this step.
+     * The step of the capacity hook's most recent shaping failure. The rescue
+     * re-entry reads it so it never re-runs a shaper that already attempted and
+     * failed on the same step.
      */
     lastShapeFailure;
     /** Malformed summaries spend one bounded repair budget for this whole Turn. */
     malformedSummaryFailure;
-    constructor(headAnchor, priorContentEvents, priorRunHeaders, capacity) {
+    constructor(headAnchor, priorContentEvents, priorRunHeaders, 
+    /** The model's declared context window, absent when it declares none. */
+    capacity) {
         this.headAnchor = headAnchor;
         this.priorContentEvents = priorContentEvents;
         this.priorRunHeaders = priorRunHeaders;
@@ -1308,21 +1288,79 @@ export class MidTurnCapacityCompactState {
 /**
  * Char measure of the FULL provider-visible request input: the system prompt
  * (sent through the separate `system` field), the (projected) messages, and
- * the serialized schemas of the active tool subset. The capacity trigger and
- * the final-request estimate owner both measure with this ONE function, so
- * their raw payload comparisons against `lastRequestPayloadChars` are
- * commensurable and
+ * the serialized schemas of the active tool subset. Media is billed in tokens
+ * converted to chars, so the whole measure stays in one unit. The capacity
+ * trigger and the rescue re-entry both measure with this ONE function, so
+ * their comparisons against `lastRequestPayloadChars` are commensurable and
  * same-turn tool-schema growth (a `tool_search` activation) is counted like
  * any other payload growth. The system prompt is constant between adjacent
  * requests — signed deltas cancel it — but the cold-start estimate (no usable
  * usage sample) is the whole payload, so omitting it would under-estimate by
- * exactly the system prompt and let an over-window request stream.
+ * exactly the system prompt.
+ *
+ * A media part is worth what the provider charges for it, not what it
+ * serializes to: materialized bytes reach the request as base64 or a byte map,
+ * where a 500 KB screenshot serializes to ~667K chars. Measuring that string
+ * makes one image look like a whole context window, which is how an affordable
+ * request became a terminal verdict (#4458). Billing it at the same constant
+ * the ledger's ruler uses keeps the two measures commensurable.
  */
-function midTurnRequestPayloadChars(messages, providerTools, activeTools, systemPromptChars) {
+function midTurnRequestPayloadChars(messages, providerTools, activeTools, systemPromptChars, charsPerToken) {
+    let mediaParts = 0;
+    const serializedMessages = JSON.stringify(messages, (_key, value) => {
+        if (!isInlineImageFilePart(value))
+            return value;
+        mediaParts += 1;
+        return { type: value.type, mediaType: value.mediaType };
+    });
     return (Math.max(0, Math.floor(systemPromptChars)) +
-        JSON.stringify(messages).length +
+        (serializedMessages?.length ?? 0) +
+        mediaParts * MATERIALIZED_IMAGE_TOKENS * Math.max(1, charsPerToken) +
         toolSchemaCharsForDiagnostics(providerTools, activeTools));
 }
+/**
+ * The newest `LastRequestAnchor` persisted in the prior context.
+ *
+ * Reverse scan, and the FIRST anchor-bearing usage record decides — an older
+ * anchor describes a request further from the one about to go out, so a
+ * rejected newest anchor means cold start, never a fallback to an older one.
+ * The synthetic `token_usage` a manual `/compact` writes carries no anchor and
+ * is skipped for free.
+ *
+ * The anchor is a token count in the anchoring model's tokenizer, so it only
+ * transfers to a request going to the same model over the same connection.
+ */
+function persistedRequestAnchor(events, runHeaders, modelId, connectionId) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        const anchor = event?.actions?.tokenUsage?.lastRequestAnchor;
+        if (!anchor)
+            continue;
+        const header = runHeaders.find((candidate) => candidate.runId === event?.runId);
+        if (!header || header.modelId !== modelId || header.llmConnectionId !== connectionId) {
+            return undefined;
+        }
+        return anchor;
+    }
+    return undefined;
+}
+/**
+ * The estimate inputs for the request about to go out: the paired anchor and
+ * the signed char delta against the payload that anchor was reported for.
+ *
+ * A delta wider than the whole payload means the pairing has already failed, so
+ * drop it and cold start: the whole payload against a zero anchor.
+ */
+function requestEstimateAnchor(state, payloadChars) {
+    const anchor = state.lastRequestInputTokens;
+    const baseline = state.lastRequestPayloadChars;
+    if (anchor === undefined || baseline === undefined)
+        return { appendedChars: payloadChars };
+    const appendedChars = payloadChars - baseline;
+    if (Math.abs(appendedChars) > payloadChars)
+        return { appendedChars: payloadChars };
+    return { priorUsageTokens: anchor, appendedChars };
+}
 /**
  * The `decision: 'replaced'` diagnostic patch for a durable active-send fold,
  * shared by the proactive (`reason: 'context_limit'`) and reactive