maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.30.20260912

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

@@ -17,27 +17,29 @@
  * under the License.
  */
 import { compactionDecisionDiagnosticPatch } from './compaction-boundary.js';
-import { ARCHIVED_TOOL_RESULT_REWRITE_VERSION, buildContextBudgetDiagnosticShell, estimateRuntimeEventsTokens, mergeContextBudgetDiagnostic, } from './context-budget.js';
-import { evaluateHistoryCompactCheckpointReplay, isHistoryCompactContentEvent, } from './history-compaction.js';
-import { canContinueHistoryCompactCheckpointForModel, canReplayHistoryCompactCheckpointForModel, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
+import { buildContextBudgetDiagnosticShell, mergeContextBudgetDiagnostic, mergeContextBudgetDiagnosticPatches, } from './context-budget.js';
+import { isHistoryCompactContentEvent } from './history-compaction.js';
+import { canContinueHistoryCompactCheckpointForModel, canReplayHistoryCompactCheckpointForModel, historyCompactSourceDigest, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { HistoryCompactSummarizerError, isMalformedHistoryCompactSummaryReason, } from './history-compact-error.js';
 import { createHash } from 'node:crypto';
 import { rewriteActiveToolResultsInMessages, } from './active-tool-result-prune.js';
-import { collectStaleToolResultArchiveCandidates } from './tool-result-archive.js';
-import { buildRuntimeEventModelReplayPlan, collectToolActivityTurnIds, } 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 { archiveToolResultAsTransition, collectStaleToolResultArchiveCandidates, serializedToolResultProjection, } from './tool-result-archive-transition.js';
+import { estimateTokens } from './context-budget-helpers.js';
+import { baseToolResultProjection, reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
+import { buildRuntimeEventModelReplayPlan, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, } from './model-history.js';
+import { planHistoryCompaction } from './history-compaction.js';
+import { resolveDeclaredContextWindow } from './context-budget-policy.js';
 import { collectHistoricalImageToolResults, omitHistoricalImageToolResults, } from './provider-image-overflow-recovery.js';
 export class AiSdkCompaction {
     input;
     sessionId;
+    targetConnectionId;
+    targetProviderStateIdentity;
     now;
     modelAdapter;
     createProviderRequestTracker;
     materializeRuntimeReplayPlan;
     canReplayProviderNative;
-    appendTurnTailPrompt;
     historyCompactAbortController = null;
     /**
      * Session-scoped circuit for exact malformed compaction inputs. A retry or
@@ -48,18 +50,63 @@ export class AiSdkCompaction {
     constructor(deps) {
         this.input = deps.input;
         this.sessionId = deps.sessionId;
+        this.targetConnectionId = deps.targetConnectionId;
+        this.targetProviderStateIdentity = deps.targetProviderStateIdentity;
         this.now = deps.now;
         this.modelAdapter = deps.modelAdapter;
         this.createProviderRequestTracker = deps.createProviderRequestTracker;
         this.materializeRuntimeReplayPlan = deps.materializeRuntimeReplayPlan;
         this.canReplayProviderNative = deps.canReplayProviderNative;
-        this.appendTurnTailPrompt = deps.appendTurnTailPrompt;
+    }
+    /**
+     * Every transition this session has committed.
+     *
+     * Read from the durable ledger rather than remembered: a Turn that pruned and
+     * a Turn that replays it may be different processes. A read that fails or that
+     * this build cannot fully decode is reported, never smoothed into "there are
+     * no transitions" — a caller that cannot see the whole chain may still show
+     * what it folded, but it may not append a successor onto a state it only
+     * partly knows.
+     */
+    async loadModelProjectionTransitions() {
+        const loaded = await this.input.loadModelProjectionTransitions?.();
+        const resolved = {
+            transitions: [],
+            unreadableTargets: new Set(),
+            unscopedUnreadable: 0,
+            ...loaded,
+        };
+        if (resolved.unscopedUnreadable > 0) {
+            // The record names no target, so nothing can be confined and nothing can
+            // be shown: replaying raw history here would show whatever that record
+            // removed. Failing is recoverable; showing it again is not.
+            throw new Error('model projection transition ledger contains an unscoped unreadable record');
+        }
+        return resolved;
+    }
+    /**
+     * The archive-and-commit writer, or `undefined` when this session cannot make
+     * a lossy model-history change durable. Without both halves — an archive to
+     * put the body in and a ledger to record the replacement — no prune may run.
+     */
+    toolResultArchiveTransitionServices(turnId) {
+        const archive = this.input.toolResultArchive?.services.archiveToolResult;
+        const record = this.input.recordModelProjectionTransition;
+        if (!archive || !record)
+            return undefined;
+        return {
+            sessionId: this.sessionId,
+            archiveToolResult: (candidate) => archive(candidate),
+            recordTransition: (transition) => record(transition, turnId),
+            loadTransitions: () => this.loadModelProjectionTransitions(),
+            now: this.now,
+        };
     }
     /** Abort an in-flight manual history compaction (called by AiSdkBackend.stop). */
     abortHistoryCompact() {
         this.historyCompactAbortController?.abort();
     }
-    async compactHistory(input, requestShapeHashBefore, automaticMemoryBoundary) {
+    async compactHistory(input, automaticMemoryBoundary) {
         const historyCompactAbortController = new AbortController();
         this.historyCompactAbortController = historyCompactAbortController;
         try {
@@ -76,12 +123,11 @@ export class AiSdkCompaction {
                 return { outcome: { kind: 'unchanged', reason: 'empty_history' } };
             }
             const charsPerToken = policy.charsPerToken ?? 4;
-            const estimatedTokensBefore = Math.max(1, estimateRuntimeEventsTokens(runtimeContext, charsPerToken));
             let previousCheckpoint;
             try {
                 const loaded = await Promise.resolve(this.input.loadHistoryCompactCheckpoint?.());
                 if (loaded &&
-                    canContinueHistoryCompactCheckpointForModel(loaded, this.input.connection, this.input.modelId)) {
+                    canContinueHistoryCompactCheckpointForModel(loaded, this.input.connection, this.targetConnectionId, this.input.modelId)) {
                     previousCheckpoint = loaded;
                 }
             }
@@ -91,8 +137,7 @@ export class AiSdkCompaction {
             if (previousCheckpoint) {
                 const match = matchHistoryCompactCheckpointPrefix(previousCheckpoint, runtimeContext);
                 if (!match.reason && match.successorRuntimeEvents.length === 0) {
-                    const fit = evaluateHistoryCompactCheckpointReplay(previousCheckpoint, [], charsPerToken, policy.maxHistoryEstimatedTokens, { sourceReplayEvents: runtimeContext });
-                    if (fit.fits) {
+                    {
                         const projectedEvents = projectHistoryCompactCheckpointReplay(previousCheckpoint, match.coveredRuntimeEvents, []);
                         return {
                             outcome: { kind: 'unchanged', reason: 'already_compacted' },
@@ -124,6 +169,15 @@ export class AiSdkCompaction {
                 sessionId: this.sessionId,
                 phase: 'standalone',
                 orderedEvents: runtimeContext,
+                ...(input.runtimeContextInvocations
+                    ? { invocations: input.runtimeContextInvocations }
+                    : {}),
+                acceptedRoute: {
+                    modelId: this.input.modelId,
+                    ...(this.targetConnectionId !== undefined
+                        ? { connectionId: this.targetConnectionId }
+                        : {}),
+                },
                 reserveTailEvents: 0,
                 charsPerToken,
                 now: this.now(),
@@ -132,20 +186,28 @@ export class AiSdkCompaction {
                     : {}),
                 ...(automaticMemoryBoundary ? { memoryExtractionBoundary: automaticMemoryBoundary } : {}),
                 ...(previousCheckpoint ? { previousCheckpoint } : {}),
-                summarize: async ({ coveredRuntimeEvents, newlyFoldedRuntimeEvents, previousCheckpoint }) => await this.summarizeWithFailureCircuit(summarizer, {
-                    sessionId: this.sessionId,
-                    turnId: input.turnId,
-                    source: { foldedRuntimeEvents: [...coveredRuntimeEvents] },
-                    newlyFoldedRuntimeEvents: [...newlyFoldedRuntimeEvents],
-                    ...(previousCheckpoint ? { previousCheckpoint } : {}),
-                    inputBudget: {
-                        maxEstimatedTokens: policy.maxHistoryEstimatedTokens ?? estimatedTokensBefore,
-                        charsPerToken,
-                    },
-                    ...(requestShapeHashBefore ? { requestShapeHashBefore } : {}),
-                    abortSignal: historyCompactAbortController.signal,
-                    ...(tracker ? { providerRequestTracker: tracker } : {}),
-                }),
+                // The planner projects the covered span to its effective view before
+                // summarizing and pins its digest as coverage.effectiveSourceDigest:
+                // the summary can never quote a body a durable transition removed, and
+                // a later transition invalidates the checkpoint at replay (#4845).
+                projectEffectiveCoverage: (covered) => this.foldEffectiveModelHistory(covered),
+                summarize: async ({ coveredRuntimeEvents, newlyFoldedRuntimeEvents, previousCheckpoint, }) => {
+                    return await this.summarizeWithFailureCircuit(summarizer, {
+                        sessionId: this.sessionId,
+                        turnId: input.turnId,
+                        runId: input.runId,
+                        source: {
+                            foldedRuntimeEvents: [...coveredRuntimeEvents],
+                            ...(input.runtimeContextInvocations
+                                ? { invocations: input.runtimeContextInvocations }
+                                : {}),
+                        },
+                        newlyFoldedRuntimeEvents: [...newlyFoldedRuntimeEvents],
+                        ...(previousCheckpoint ? { previousCheckpoint } : {}),
+                        abortSignal: historyCompactAbortController.signal,
+                        ...(tracker ? { providerRequestTracker: tracker } : {}),
+                    });
+                },
             });
             if (historyCompactAbortController.signal.aborted) {
                 return { outcome: { kind: 'failed', reason: 'aborted' } };
@@ -167,22 +229,6 @@ export class AiSdkCompaction {
                     }),
                 };
             }
-            const replayFit = evaluateHistoryCompactCheckpointReplay(plan.checkpoint, plan.tailRuntimeEvents, charsPerToken, policy.maxHistoryEstimatedTokens, { sourceReplayEvents: runtimeContext });
-            if (!replayFit.fits) {
-                return {
-                    outcome: { kind: 'failed', reason: replayFit.reason },
-                    contextBudget: mergeContextBudgetDiagnostic(diagnosticShell(runtimeContext), {
-                        ...compactionDecisionDiagnosticPatch({
-                            stage: 'priorReplay',
-                            sourceKind: 'runtimeEvents',
-                            decision: 'failedOpen',
-                            phase: 'pre_turn',
-                            boundaryKind: 'historyCompact',
-                            failOpenReason: replayFit.reason,
-                        }),
-                    }),
-                };
-            }
             try {
                 await Promise.resolve(recorder(plan.checkpoint, input.turnId));
             }
@@ -234,16 +280,34 @@ export class AiSdkCompaction {
         return Boolean(this.input.summarizeHistoryCompact && this.input.recordHistoryCompactCheckpoint);
     }
     async summarizeWithFailureCircuit(summarizer, input) {
+        const foldedRunIds = new Set(input.source.foldedRuntimeEvents.map((event) => event.runId));
+        const sourceRunRoutes = input.source.invocations
+            ?.filter((invocation) => foldedRunIds.has(invocation.runId))
+            .map((invocation) => {
+            const route = invocation.opening.route;
+            return {
+                runId: invocation.runId,
+                ...(route.provenance === 'runtime' ? { connectionId: route.llmConnectionId } : {}),
+                modelId: route.modelId,
+            };
+        })
+            .sort((left, right) => left.runId.localeCompare(right.runId));
         const fingerprint = sha256(stableStringifyForSignature({
-            version: 1,
+            version: 2,
             connection: this.input.connection,
             modelId: this.input.modelId,
             historyCompactRoute: this.input.historyCompactRoute,
             contextBudget: this.input.contextBudget,
-            inputBudget: input.inputBudget,
-            requestShapeHashBefore: input.requestShapeHashBefore,
-            previousCheckpointId: input.previousCheckpoint?.checkpointId,
+            maxOutputTokens: input.maxOutputTokens,
+            previousCheckpoint: input.previousCheckpoint,
+            currentRunEventIds: input.runId
+                ? input.source.foldedRuntimeEvents
+                    .filter((event) => event.runId === input.runId)
+                    .map((event) => event.id)
+                : [],
+            sourceRunRoutes,
             foldedRuntimeEvents: input.source.foldedRuntimeEvents,
+            newlyFoldedRuntimeEvents: input.newlyFoldedRuntimeEvents,
         }));
         const priorFailure = this.malformedSummaryFailures.get(fingerprint);
         if (priorFailure)
@@ -266,51 +330,119 @@ export class AiSdkCompaction {
             throw error;
         }
     }
-    async prepareContextBudgetPolicy(runtimeContext) {
+    /**
+     * Fold the durable transition ledger onto any slice of model-visible history.
+     *
+     * The current Turn's own events go through here on every provider step, for
+     * the same reason prior Turns do: what the model sees is the folded ledger,
+     * not the raw one. A ledger this build cannot read in full leaves the slice
+     * untouched — the content is then merely unpruned, never wrongly replaced.
+     */
+    async foldEffectiveModelHistory(events) {
+        const loaded = await this.loadModelProjectionTransitions();
+        if (loaded.transitions.length === 0 && loaded.unreadableTargets.size === 0) {
+            return [...events];
+        }
+        // Forward the unreadable set: a target whose transition record this build
+        // cannot decode must fold to the withholding sentinel here too, or this
+        // path becomes the one consumer that replays the body a record removed.
+        return reduceEffectiveModelProjections(events, loaded.transitions, loaded.unreadableTargets)
+            .events;
+    }
+    /**
+     * Whether the checkpoint's pinned effective view still is the covered
+     * prefix's effective view. The raw identity match happens later in the
+     * replay authority; this gate is about content currency: a projection
+     * transition committed after the fold changes what the model may see of the
+     * covered span without touching the raw ledger, and the checkpoint's summary
+     * or provider state must not survive that drift (#4845 review).
+     */
+    checkpointEffectiveCoverageMatches(checkpoint, effectiveEvents) {
+        const pinned = checkpoint.coverage.effectiveSourceDigest;
+        if (pinned === undefined)
+            return false;
+        const covered = effectiveEvents
+            .filter(isHistoryCompactContentEvent)
+            .slice(0, checkpoint.coverage.eventCount);
+        if (covered.length !== checkpoint.coverage.eventCount)
+            return false;
+        if (covered.at(-1)?.id !== checkpoint.coverage.through.runtimeEventId)
+            return false;
+        return historyCompactSourceDigest(covered) === pinned;
+    }
+    /**
+     * Fold the durable transition ledger onto this session's prior history, and
+     * commit any new stale-result transition the prune policy calls for.
+     *
+     * This is the one seam where raw RuntimeEvents become effective model
+     * history: the caller uses the returned events for replay, budgeting and
+     * compaction alike, so no later stage can read content a transition removed.
+     */
+    async prepareContextBudgetPolicy(runtimeContext, turnId) {
         const policy = this.input.contextBudget;
+        const loaded = await this.loadModelProjectionTransitions();
+        let transitions = loaded.transitions;
+        let effective = reduceEffectiveModelProjections(runtimeContext, transitions, loaded.unreadableTargets);
         if (!policy)
-            return { policy };
+            return { policy, events: effective.events };
         let nextPolicy = policy;
-        if (policy.staleToolResultPrune?.enabled === true) {
-            const candidates = collectStaleToolResultArchiveCandidates(runtimeContext, policy?.staleToolResultPrune, policy?.charsPerToken ?? 4);
-            if (candidates.length > 0) {
-                const archiveRefs = new Map();
-                const existingArchiveRefs = nextPolicy.staleToolResultPrune?.archiveRefs;
-                if (Array.isArray(existingArchiveRefs)) {
-                    for (const ref of existingArchiveRefs)
-                        archiveRefs.set(ref.runtimeEventId, ref);
-                }
-                else if (existingArchiveRefs) {
-                    for (const ref of Object.values(existingArchiveRefs))
-                        archiveRefs.set(ref.runtimeEventId, ref);
-                }
-                for (const candidate of candidates) {
-                    const bodySha256 = sha256(candidate.serializedResult);
-                    const archived = await Promise.resolve(this.input.toolResultArchive?.services.archiveToolResult({
-                        ...candidate,
-                        sessionId: this.sessionId,
-                        bodySha256,
-                    })).catch(() => undefined);
-                    if (!archived?.artifactId)
-                        continue;
-                    archiveRefs.set(candidate.runtimeEventId, {
-                        runtimeEventId: candidate.runtimeEventId,
-                        toolCallId: candidate.toolCallId,
-                        toolName: candidate.toolName,
-                        artifactId: archived.artifactId,
-                        bodySha256,
-                        originalEstimatedTokens: candidate.originalEstimatedTokens,
-                        originalBytes: candidate.originalBytes,
-                        rewriteVersion: ARCHIVED_TOOL_RESULT_REWRITE_VERSION,
-                        reason: candidate.reason,
-                    });
+        let diagnosticPatch;
+        // A chain this reader cannot see in full is a chain it must not extend: a
+        // successor built on a partly known state would name the wrong predecessor
+        // and be permanently inert, losing the content it archived.
+        const services = loaded.unreadableTargets.size === 0
+            ? this.toolResultArchiveTransitionServices(turnId)
+            : undefined;
+        if (policy.staleToolResultPrune?.enabled === true && services) {
+            // The decision is taken over EFFECTIVE history, so a result an earlier
+            // Turn already replaced is never re-measured — or re-archived — at the
+            // size it used to have.
+            const candidates = collectStaleToolResultArchiveCandidates(effective.events, policy.staleToolResultPrune, policy.charsPerToken ?? 4);
+            const committed = [];
+            let archiveFailures = 0;
+            let estimatedTokensBefore = 0;
+            let estimatedTokensAfter = 0;
+            for (const candidate of candidates) {
+                const outcome = await archiveToolResultAsTransition(services, {
+                    runtimeEventId: candidate.runtimeEventId,
+                    turnId: candidate.turnId,
+                    toolCallId: candidate.toolCallId,
+                    toolName: candidate.toolName,
+                    sourceProjection: candidate.sourceProjection,
+                    serializedResult: candidate.serializedResult,
+                    originalBytes: candidate.originalBytes,
+                    originalEstimatedTokens: candidate.originalEstimatedTokens,
+                    reason: candidate.reason,
+                    result: candidate.result,
+                });
+                if (!outcome) {
+                    archiveFailures += 1;
+                    continue;
                 }
-                nextPolicy = {
-                    ...nextPolicy,
-                    staleToolResultPrune: {
-                        ...nextPolicy.staleToolResultPrune,
-                        archiveRefs: [...archiveRefs.values()],
-                    },
+                committed.push(outcome.transition);
+                estimatedTokensBefore += candidate.originalEstimatedTokens;
+                estimatedTokensAfter += estimateTokens(serializedToolResultProjection(outcome.transition.replacement).length, policy.charsPerToken ?? 4);
+            }
+            if (committed.length > 0) {
+                transitions = [...transitions, ...committed];
+                effective = reduceEffectiveModelProjections(runtimeContext, transitions, loaded.unreadableTargets);
+            }
+            if (committed.length > 0 || archiveFailures > 0) {
+                diagnosticPatch = {
+                    ...(committed.length > 0
+                        ? {
+                            prunedToolResults: committed.length,
+                            prunedToolResultEstimatedTokensBefore: estimatedTokensBefore,
+                            prunedToolResultEstimatedTokensAfter: estimatedTokensAfter,
+                            archivePlaceholders: committed.length,
+                            archivePlaceholderReasonCounts: {
+                                stale_tool_result_pruned_before_compact: committed.length,
+                            },
+                        }
+                        : {}),
+                    ...(archiveFailures > 0
+                        ? { archiveWriteFailures: archiveFailures, unarchivedToolResults: archiveFailures }
+                        : {}),
                 };
             }
         }
@@ -322,23 +454,109 @@ export class AiSdkCompaction {
             loadedCheckpoint = undefined;
         }
         if (loadedCheckpoint &&
-            canReplayHistoryCompactCheckpointForModel(loadedCheckpoint, this.input.connection, this.input.modelId)) {
-            nextPolicy = {
-                ...nextPolicy,
-                historyCompact: { ...nextPolicy.historyCompact, checkpoint: loadedCheckpoint },
-            };
+            canReplayHistoryCompactCheckpointForModel(loadedCheckpoint, this.input.connection, this.targetConnectionId, this.input.modelId)) {
+            // Raw identity first: a coverage miss keeps the apply-stage path, whose
+            // matcher reports the real identity reason (coverage_miss and friends).
+            // This gate is only for the case where the raw identity matches but a
+            // projection transition committed after the fold changed the effective
+            // view the summary (or provider state) was built from (#4845 review).
+            const rawIdentityMatch = matchHistoryCompactCheckpointPrefix(loadedCheckpoint, runtimeContext.filter(isHistoryCompactContentEvent));
+            if (rawIdentityMatch.reason) {
+                nextPolicy = {
+                    ...nextPolicy,
+                    historyCompact: { ...nextPolicy.historyCompact, checkpoint: loadedCheckpoint },
+                };
+            }
+            else if (this.checkpointEffectiveCoverageMatches(loadedCheckpoint, effective.events)) {
+                nextPolicy = {
+                    ...nextPolicy,
+                    historyCompact: { ...nextPolicy.historyCompact, checkpoint: loadedCheckpoint },
+                };
+            }
+            else {
+                // Rejecting keeps the stale block from restoring what the transition
+                // removed; the next fold re-summarizes (#4845 review).
+                diagnosticPatch = mergeContextBudgetDiagnosticPatches(diagnosticPatch, compactionDecisionDiagnosticPatch({
+                    stage: 'priorReplay',
+                    sourceKind: 'runtimeEvents',
+                    decision: 'failedOpen',
+                    phase: 'pre_turn',
+                    boundaryKind: 'historyCompact',
+                    ...(loadedCheckpoint.coverage.effectiveSourceDigest !== undefined
+                        ? { boundaryIds: [loadedCheckpoint.checkpointId] }
+                        : {}),
+                    failOpenReason: 'effective_history_changed',
+                }));
+            }
         }
-        return { policy: nextPolicy };
+        return {
+            policy: nextPolicy,
+            events: effective.events,
+            ...(diagnosticPatch ? { diagnosticPatch } : {}),
+        };
     }
     buildActiveToolResultPruneProjection(turnId, includeNewestStep, onDiagnosticPatch) {
         const policy = this.input.contextBudget?.activeToolResultPrune;
         if (policy?.enabled !== true)
             return undefined;
-        const archivedPlaceholders = new Map();
+        const services = this.toolResultArchiveTransitionServices(turnId);
+        // No durable ledger, no lossy rewrite. The old per-Turn placeholder map let
+        // this run prune content that the NEXT request would have shown again.
+        if (!services || !this.input.loadTurnRuntimeEvents)
+            return undefined;
+        // The current Turn reads the same folded history as every other consumer.
+        // Nothing here remembers what this run already archived: the ledger says it,
+        // and a step that measures the raw body again would archive it again.
+        let effective;
+        const loadEffectiveTurnEvents = async () => {
+            if (effective)
+                return effective;
+            const loaded = await this.loadModelProjectionTransitions();
+            if (loaded.unreadableTargets.size > 0)
+                return undefined;
+            let turnEvents;
+            try {
+                turnEvents = await this.input.loadTurnRuntimeEvents(turnId);
+            }
+            catch {
+                return undefined;
+            }
+            const reduction = reduceEffectiveModelProjections(turnEvents, loaded.transitions);
+            const lastApplied = new Map();
+            for (const transition of reduction.applied) {
+                lastApplied.set(transition.target.runtimeEventId, transition.transitionId);
+            }
+            effective = { events: reduction.events, lastApplied };
+            return effective;
+        };
+        const resolveProjection = async (toolCallId) => {
+            const current = await loadEffectiveTurnEvents();
+            if (!current)
+                return undefined;
+            const event = current.events.find((candidate) => candidate.partial !== true &&
+                candidate.content?.kind === 'function_response' &&
+                candidate.content.id === toolCallId);
+            if (!event || event.content?.kind !== 'function_response')
+                return undefined;
+            const projection = baseToolResultProjection(event);
+            if (!projection)
+                return undefined;
+            const previousTransitionId = current.lastApplied.get(event.id);
+            return {
+                runtimeEventId: event.id,
+                turnId: event.turnId,
+                toolName: event.content.name,
+                projection,
+                ...(previousTransitionId ? { previousTransitionId } : {}),
+            };
+        };
         return async (options) => {
             const eligibleToolCallIds = collectPrunableCompletedStepToolCallIds(options.completedSteps, includeNewestStep);
             if (eligibleToolCallIds.size === 0)
                 return undefined;
+            // Each provider step rebuilds its messages from the durable Turn ledger,
+            // so each step must re-fold it too.
+            effective = undefined;
             const rewritten = await rewriteActiveToolResultsInMessages({
                 messages: options.messages,
                 policy,
@@ -352,14 +570,8 @@ export class AiSdkCompaction {
                     input: call.input,
                     stepNumber,
                 }))),
-                archivedPlaceholders,
-                archiveToolResult: async (candidate) => {
-                    return await Promise.resolve(this.input.toolResultArchive?.services.archiveToolResult({
-                        ...candidate,
-                        sessionId: this.sessionId,
-                        runtimeEventId: candidate.runtimeEventId ?? activeToolResultArchiveKey(candidate),
-                    }));
-                },
+                resolveProjection,
+                transitions: services,
             });
             if (hasActiveToolResultPruneDiagnosticPatch(rewritten.diagnosticPatch)) {
                 onDiagnosticPatch?.(rewritten.diagnosticPatch);
@@ -371,7 +583,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;
@@ -391,43 +605,49 @@ export class AiSdkCompaction {
             headAnchor.sessionId !== this.sessionId ||
             headAnchor.turnId !== input.turnId ||
             headAnchor.role !== 'user' ||
-            headAnchor.author !== 'user' ||
+            (headAnchor.author !== 'user' && headAnchor.author !== 'host') ||
             !isHistoryCompactContentEvent(headAnchor)) {
             return undefined;
         }
-        const capacity = resolveContextBudgetCapacity(this.input.connection, this.input.modelId, policy);
-        if (capacity === undefined)
-            return undefined;
+        // Handoff replay is an authenticated predecessor prefix, including the
+        // current logical Turn. The live reader remains physical-run scoped.
+        const handoff = input.continuation?.sourceTurnId === input.turnId;
         const priorContentEvents = (input.runtimeContext ?? [])
-            .filter((event) => event.turnId !== input.turnId)
+            .filter((event) => handoff || event.turnId !== input.turnId)
             .filter(isHistoryCompactContentEvent);
-        return new MidTurnCapacityCompactState(headAnchor, priorContentEvents, capacity);
+        const state = new MidTurnCapacityCompactState(headAnchor, priorContentEvents, input.runtimeContextInvocations ?? [], resolveDeclaredContextWindow(this.input.connection, this.input.modelId));
+        // Seed the turn's FIRST request with the last request the provider
+        // actually counted, so step 0 is judged by the same real number as every
+        // later step. No anchor means no proactive fold on step 0; the provider
+        // decides, and its rejection is recovered from.
+        const persisted = persistedRequestAnchor(input.runtimeContext ?? [], state.priorInvocations, this.input.modelId, this.targetConnectionId);
+        if (persisted) {
+            state.baselineTokens = persisted.inputTokens + (persisted.outputTokens ?? 0);
+            state.lastAcceptedTotalTokens = state.baselineTokens;
+            state.priorAcceptedInputTokens = persisted.inputTokens;
+        }
+        if (persisted)
+            state.replyReserveTokens = replyReserveTokens(persisted.outputTokens);
+        return state;
     }
     /**
-     * Request-projection stage for the mid-turn capacity invariant: between
-     * steps of one turn, estimate the next provider request (last step's real
-     * usage + a signed char/4 payload delta, tool schemas included) against
-     * `contextWindow - reserve`; over the high-water, fold a safe completed
-     * prefix into a durable mid_turn checkpoint and continue the same turn on
-     * `[compact block, verbatim head anchor, preserved tail]`.
+     * Request-projection stage for proactive compaction: before each request of
+     * one turn, compare the baseline — the last provider-accepted request's real
+     * input plus real output tokens — against the context window the user
+     * declared, and over it fold a safe completed prefix into a durable
+     * checkpoint, continuing the turn on `[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.
+     * Nothing here estimates whether a request fits: the baseline is the
+     * provider's own count, the window is the user's own number, and the part of
+     * the next request neither describes (tool results, user text, images
+     * appended since) is judged by the provider when the request goes out. This
+     * hook never terminates the turn: every failure fails open with a diagnostic
+     * and the request is sent; a rejection is recovered by one reactive fold
+     * (#4559).
      */
-    buildMidTurnCapacityCompactProjection(turnId, state, queue, providerTools, fallbackActiveTools, turnTailPrompt, 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;
-        const compactPolicy = policy.historyCompact;
-        const midTurn = compactPolicy.midTurn;
-        const charsPerToken = policy.charsPerToken ?? 4;
-        const reserveTokens = midTurn.reserveTokens ?? 16_384;
         let acceptedProjection;
         return async (options) => {
             const incomingMessages = options.messages;
@@ -435,37 +655,23 @@ 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.
-            // Baseline = the last request's INPUT tokens only (see the state field
-            // doc: the payload delta already carries the step's output). The
-            // adapter fails closed on missing token counts (undefined, #972), and a
-            // provider can still report a zero input outright — either way a
-            // non-positive input count is unusable for estimation, so clear the
-            // baseline and let the estimate fall back to the whole-payload cold
-            // start instead of "0 + delta".
-            //
-            // The usage anchor is only meaningful PAIRED with the payload baseline
-            // of the request it was reported for (`lastRequestPayloadChars`). A
-            // successful overflow recovery restructures the request and resets that
-            // baseline to undefined: the send-global steps view still carries the
-            // dead attempt's last usage, but anchoring on it against the rejected
-            // 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;
+            // Baseline = the last accepted request's REAL input tokens plus its REAL
+            // output tokens, read synchronously from the SDK's own step results.
+            // Everything the model produced last step is re-sent as input this step,
+            // so both halves are already in the next request; the only part no
+            // number describes yet is what was appended from outside the model,
+            // and that part is the provider's to judge. A missing or non-positive
+            // input count is no baseline at all — unknown, never zero.
+            if (options.completedSteps.length > 0) {
+                const lastUsage = options.completedSteps.at(-1)?.usage;
+                state.baselineTokens = usageBaselineTokens(lastUsage);
+                if (state.baselineTokens !== undefined) {
+                    state.lastAcceptedTotalTokens = state.baselineTokens;
+                    state.replyReserveTokens = replyReserveTokens(lastUsage?.outputTokens);
+                }
+            }
+            // Physical step zero may already be mid-Turn after a handoff.
+            const phase = state.compactionPhase(options.stepNumber);
             // A skipped trigger is never silent: every failure-driven skip records a
             // failedOpen decision.
             const failOpen = (failOpenReason) => {
@@ -474,7 +680,7 @@ export class AiSdkCompaction {
                         stage: 'activeStep',
                         sourceKind: 'runtimeEvents',
                         decision: 'failedOpen',
-                        phase: 'mid_turn',
+                        phase,
                         boundaryKind: 'historyCompact',
                         reason: 'context_limit',
                         failOpenReason,
@@ -483,62 +689,47 @@ 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 };
-                return failOpen(diagnosticReason);
-            };
-            // Trigger estimate: the last request's input tokens plus a SIGNED char/4 delta of
-            // this step's payload (system prompt + projected messages + active tool
-            // schemas) against the previous request's measured payload. Measured synchronously from
-            // the SDK's own projection — no ledger dependency — so a same-turn
-            // `tool_search` schema expansion or a large tool result both count. This
-            // position measures BEFORE later shapers (prune) run, so it can
-            // 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);
-            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,
-                });
-            if (forcedEstimate === undefined &&
-                !exceedsHighWater(estimate, state.capacity.tokens, reserveTokens)) {
+            // One trigger, one real signal: the baseline plus the room the next reply
+            // needs crossed the window the user declared. A cut reply is deliberately
+            // not a trigger — see the note on `finishReason: length` in the backend.
+            // The next request is at least the baseline, and its reply needs room on
+            // top of it. The room is measured from the last reply the model actually
+            // wrote, not from the largest one it could write: on a model whose
+            // output limit is a large fraction of its window (k3-256k reports
+            // 131,072 against 262,144) reserving the limit would fold at half the
+            // declared window, while a reply twice the size of the last one is the
+            // margin the session's own behaviour supports (#4634).
+            const overWindow = state.capacity !== undefined &&
+                state.baselineTokens !== undefined &&
+                state.baselineTokens + state.replyReserveTokens >= state.capacity;
+            if (!overWindow || state.compactionAttemptedThisSend) {
                 return keepProjection();
             }
+            state.compactionAttemptedThisSend = true;
+            const activeToolsForStep = options.resolveDispatch(options.activeTools).activeTools;
             // Fold a safe completed prefix of the durable turn ledger into a
             // replacement projection (validate → persist), shared with the reactive
             // overflow path. This stage maps the outcome to the request-projection contract:
             // keep the raw projection on skip/fail, apply the fold on success.
             const outcome = await this.compactActiveRequestHistory({
                 turnId,
+                phase,
                 origin,
                 state,
                 queue,
                 minFlushedSteps: options.stepNumber,
-                referencePayloadChars: payloadChars,
-                providerTools,
                 activeToolsForStep,
-                systemPromptChars,
-                turnTailPrompt,
                 memoryCompactionDecision,
                 onMemoryCompaction,
                 abortSignal,
             });
             if (outcome.decision === 'fail') {
-                return shapeFailure(outcome.detail, outcome.diagnosticReason);
+                return failOpen(outcome.diagnosticReason);
             }
+            // The fold replaced the request; the baseline described the old one.
+            // The next accepted request is the first measurement of the new shape.
+            state.compactionAppliedThisSend = true;
+            state.baselineTokens = undefined;
             acceptedProjection = {
                 sourceSignatures: incomingMessages.map(modelMessageSignature),
                 projectedMessages: outcome.replacementMessages,
@@ -565,12 +756,11 @@ export class AiSdkCompaction {
      * the pass/terminate verdict and the diagnostic emission are the caller's.
      */
     async compactActiveRequestHistory(input) {
-        const { turnId, state, queue, providerTools, activeToolsForStep, systemPromptChars, turnTailPrompt, abortSignal, } = input;
-        if (state.malformedSummaryFailure) {
+        const { turnId, state, queue, activeToolsForStep, abortSignal } = input;
+        if (state.summarizerFailure) {
             return {
                 decision: 'fail',
-                detail: state.malformedSummaryFailure,
-                diagnosticReason: state.malformedSummaryFailure,
+                diagnosticReason: state.summarizerFailure,
             };
         }
         const summarizer = this.input.summarizeHistoryCompact;
@@ -587,9 +777,7 @@ export class AiSdkCompaction {
         const loadTurnRuntimeEvents = this.input.loadTurnRuntimeEvents;
         const policy = this.input.contextBudget;
         const compactPolicy = policy.historyCompact;
-        const midTurn = compactPolicy.midTurn;
         const charsPerToken = policy.charsPerToken ?? 4;
-        const reserveTokens = midTurn.reserveTokens ?? 16_384;
         // Coverage pool = the durable run ledger, read through the injected
         // seam. Covered events are persisted by construction (no crash window
         // between checkpoint and source), and their bytes are exactly what a
@@ -617,14 +805,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',
                 };
             }
@@ -639,30 +825,33 @@ export class AiSdkCompaction {
         catch {
             return {
                 decision: 'fail',
-                detail: 'no_safe_completed_span',
                 diagnosticReason: 'ledger_read_failed',
             };
         }
         const currentTurnEvents = turnLedger
             .filter((event) => event.turnId === turnId)
             .filter(isHistoryCompactContentEvent);
-        // The head anchor is persisted before backend.send() is invoked, so
-        // its absence is a wiring error, not replication lag — fail open now.
-        if (!currentTurnEvents.some((event) => event.id === state.headAnchor.id)) {
+        const orderedEvents = [...state.priorContentEvents, ...currentTurnEvents];
+        // A fresh anchor belongs to the live ledger; after handoff it belongs to
+        // the authenticated predecessor prefix. Neither path manufactures it.
+        if (!orderedEvents.some((event) => event.id === state.headAnchor.id)) {
             return {
                 decision: 'fail',
-                detail: 'no_safe_completed_span',
                 diagnosticReason: 'head_anchor_not_durable',
             };
         }
-        const orderedEvents = [...state.priorContentEvents, ...currentTurnEvents];
         const memoryDecision = input.memoryCompactionDecision?.();
         const plan = await planHistoryCompaction({
             sessionId: this.sessionId,
             phase: input.phase ?? 'mid_turn',
             orderedEvents,
             headAnchor: { runtimeEventId: state.headAnchor.id, turnId },
-            reserveTailEvents: midTurn.reserveTailEvents ?? 1,
+            invocations: state.priorInvocations,
+            acceptedRoute: {
+                modelId: this.input.modelId,
+                ...(this.targetConnectionId !== undefined ? { connectionId: this.targetConnectionId } : {}),
+            },
+            reserveTailEvents: 1,
             charsPerToken,
             now: this.now(),
             ...(compactPolicy.highWaterName !== undefined
@@ -679,17 +868,22 @@ export class AiSdkCompaction {
                     },
                 }
                 : {}),
+            projectEffectiveCoverage: (covered) => this.foldEffectiveModelHistory(covered),
             summarize: async ({ coveredRuntimeEvents, newlyFoldedRuntimeEvents, previousCheckpoint }) => {
+                // Same contract as the standalone path: the planner hands the
+                // effective (transition-folded) view to the summarizer and pins its
+                // digest, so a summary can never quote a body a durable transition
+                // removed (#4845).
                 return await this.summarizeWithFailureCircuit(summarizer, {
                     sessionId: this.sessionId,
                     turnId,
-                    source: { foldedRuntimeEvents: [...coveredRuntimeEvents] },
+                    ...(input.origin.runId ? { runId: input.origin.runId } : {}),
+                    source: {
+                        foldedRuntimeEvents: [...coveredRuntimeEvents],
+                        invocations: state.priorInvocations,
+                    },
                     ...(previousCheckpoint ? { previousCheckpoint } : {}),
                     newlyFoldedRuntimeEvents: [...newlyFoldedRuntimeEvents],
-                    inputBudget: {
-                        maxEstimatedTokens: Math.max(1, state.capacity.tokens - reserveTokens),
-                        charsPerToken,
-                    },
                     ...(abortSignal ? { abortSignal } : {}),
                     ...(midTurnTracker ? { providerRequestTracker: midTurnTracker } : {}),
                 });
@@ -697,23 +891,22 @@ export class AiSdkCompaction {
         });
         if (plan.decision === 'fail_open') {
             const diagnosticReason = plan.diagnosticReason ?? plan.reason;
-            if (isMalformedHistoryCompactSummaryReason(diagnosticReason)) {
-                state.malformedSummaryFailure = diagnosticReason;
-            }
+            // Latch every fail-open reason, not only the malformed ones. The baseline
+            // that fired this trigger survives a fail-open, so without the latch the
+            // next step evaluates the same condition and dispatches the same doomed
+            // summarizer call: a provider that answers slowly and fails (kimi's HTTP
+            // 200 with an error body) produced 15 such calls over 47 minutes before
+            // one main request (#4634). One attempt per send, then fail open (#4559).
+            state.summarizerFailure = diagnosticReason;
             return {
                 decision: 'fail',
-                detail: isMalformedHistoryCompactSummaryReason(diagnosticReason)
-                    ? diagnosticReason
-                    : plan.reason,
                 diagnosticReason,
             };
         }
-        // Lifecycle order is validate → persist → apply, where validate =
-        // materializable ∧ smaller ∧ replay-admissible. Replay applies the
-        // session's latest checkpoint BEFORE any high-water check, so a
-        // checkpoint that fails ANY of the three must never be persisted — it
-        // would poison every later projection even though this step correctly
-        // refused it.
+        // Lifecycle order is validate → persist → apply, where validate is
+        // materializable and replay-admissible. A checkpoint that fails either
+        // check must never be persisted because it would poison every later
+        // projection.
         const replayPlan = buildRuntimeEventModelReplayPlan(plan.replacementEvents, {
             toolActivityTurnIds: collectToolActivityTurnIds(orderedEvents),
         });
@@ -722,45 +915,13 @@ export class AiSdkCompaction {
             (replayPlan.hasProviderNativeSemantics && !this.canReplayProviderNative(replayPlan))) {
             return {
                 decision: 'fail',
-                detail: 'no_safe_completed_span',
                 diagnosticReason: 'replacement_unmaterializable',
             };
         }
-        // The head anchor must render exactly like the raw projection's current
-        // user message: the initial request decorates it with the volatile turn
-        // tail (cwd, shell context, task state — see send()), which is not part
-        // of the durable anchor bytes. Reuse the same decoration owner
-        // (appendTurnTailPrompt) on the anchor's replay item so a replacement
-        // never silently drops that context — and never counts the drop as
-        // shrinkage in the guard below.
-        const replayItemsWithAnchorTail = replayPlan.items.map((item) => item.kind === 'text' && item.role === 'user' && item.eventId === state.headAnchor.id
-            ? { ...item, content: this.appendTurnTailPrompt(item.content, turnTailPrompt) }
-            : item);
-        const replacementMessages = await this.materializeRuntimeReplayPlan({ ...replayPlan, items: replayItemsWithAnchorTail }, input.origin.imageBudget, plan.checkpoint);
-        // Apply the shape only when it actually shrinks the request versus the
-        // reference payload (the incoming request for the proactive hook, the
-        // 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);
-        if (replacedPayloadChars >= input.referencePayloadChars) {
-            return {
-                decision: 'fail',
-                detail: 'summarizer_failed',
-                diagnosticReason: 'replacement_not_smaller',
-            };
-        }
-        // Replay admissibility uses the same complete-prefix capacity gate as
-        // recovery. Actual payload shrinkage was already checked above because
-        // only this owner can measure the fully materialized provider request.
-        const replayFit = evaluateHistoryCompactCheckpointReplay(plan.checkpoint, plan.checkpoint.version === 3 ? plan.replacementEvents : plan.replacementEvents.slice(1), policy?.charsPerToken, policy?.maxHistoryEstimatedTokens);
-        if (!replayFit.fits) {
-            return {
-                decision: 'fail',
-                detail: 'head_anchor_exceeds_capacity',
-                diagnosticReason: `replay_rejected_${replayFit.reason}`,
-            };
-        }
+        const replacementMessages = await this.materializeRuntimeReplayPlan(replayPlan, input.origin.imageBudget, plan.checkpoint, compatibleProviderReasoningReplayEventIds(plan.replacementEvents, state.priorInvocations, this.targetProviderStateIdentity, this.input.modelId, input.origin.runId));
+        // Whether the replacement fits is the provider's answer once it goes out;
+        // no local measure stands between a materializable fold and dispatch
+        // (#4559).
         // The replacement is valid: durably persist the checkpoint BEFORE
         // applying the projection — the same order as the pre_turn path. A
         // persistence failure keeps raw messages and records write_failed.
@@ -770,7 +931,6 @@ export class AiSdkCompaction {
         catch {
             return {
                 decision: 'fail',
-                detail: 'summarizer_failed',
                 diagnosticReason: 'write_failed',
             };
         }
@@ -802,8 +962,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.
      */
@@ -811,7 +971,7 @@ export class AiSdkCompaction {
         const state = input.midTurnState;
         if (input.retryAlreadyUsed || !state)
             return undefined;
-        if (this.modelAdapter.classifyError(input.error) !== 'ContextLength')
+        if (this.modelAdapter.classifyError(input.error) !== 'context_overflow')
             return undefined;
         const eligibleImages = collectHistoricalImageToolResults(state.priorContentEvents);
         const imageOmission = omitHistoricalImageToolResults(input.currentMessages, eligibleImages);
@@ -820,21 +980,13 @@ export class AiSdkCompaction {
                 const image = eligibleImages.get(toolCallId);
                 return image ? [[toolCallId, image]] : [];
             }));
-            state.lastRequestPayloadChars = undefined;
-            state.lastRequestInputTokens = undefined;
+            state.baselineTokens = undefined;
             return { messages: imageOmission.messages };
         }
-        // The shrink baseline is the request the provider actually rejected. Its
-        // single owner is the verdict owner's per-request payload measure
-        // (state.lastRequestPayloadChars), recorded at the end of every
-        // request-projection run — the attempt-INITIAL messages undercount the rejected
-        // request by every same-turn tool step, and a baseline anchored there
-        // refuses folds that genuinely shrink the real request (review P1-1).
-        // 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);
-        const phase = input.stepNumber === 0 ? 'pre_turn' : 'mid_turn';
+        const phase = state.compactionPhase(input.stepNumber);
+        // Entering the module spends the send's one attempt whether or not a fold
+        // comes out of it; only a selected projection sets `applied`.
+        state.compactionAttemptedThisSend = true;
         const outcome = await this.compactActiveRequestHistory({
             turnId: input.turnId,
             phase,
@@ -844,11 +996,7 @@ export class AiSdkCompaction {
             // The stream has ended, so every completed step is already flushed; wait
             // only for the consumer to drain the durable ledger up to date.
             minFlushedSteps: state.flushedSteps,
-            referencePayloadChars,
-            providerTools: input.providerTools,
             activeToolsForStep: input.activeTools,
-            systemPromptChars: input.systemPromptChars,
-            turnTailPrompt: input.turnTailPrompt,
             memoryCompactionDecision: input.memoryCompactionDecision,
             onMemoryCompaction: input.onMemoryCompaction,
             abortSignal: input.abortSignal,
@@ -881,123 +1029,11 @@ export class AiSdkCompaction {
             estimatedTokensAfter: outcome.estimatedTokensAfter,
             reason: 'overflow',
         }));
-        // A successful recovery restructures the request, so the rejected
-        // request's payload measure no longer describes what the retry sends.
-        // 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.
-        state.lastRequestPayloadChars = undefined;
+        // The fold replaced the request; the baseline described the rejected one.
+        state.compactionAppliedThisSend = true;
+        state.baselineTokens = undefined;
         return { messages: outcome.replacementMessages };
     }
-    /**
-     * The single end-of-pipeline estimate owner for the mid-turn capacity
-     * 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:
-     *
-     *  - estimate = the last request's real INPUT tokens + signed char/4 delta
-     *    against the previous request's measured payload (recorded here on
-     *    every step, including step 0's baseline); the delta already carries
-     *    the step's fresh output, so an output-inclusive baseline would count
-     *    it twice, and an unusable usage sample falls back to the whole-payload
-     *    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.
-     *
-     * Step 0 is shaped by the pre_turn path. It is still measured here so an
-     * unshapable first request cannot bypass the capacity invariant.
-     */
-    buildMidTurnFinalRequestVerdict(input) {
-        const { shaped, reentry, state, providerTools, fallbackActiveTools, charsPerToken, systemPromptChars, onDiagnosticPatch, abortController, } = 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);
-            let payloadChars = finalPayloadChars();
-            if ((options.stepNumber >= 1 || state.capacity.source === 'policy_fallback') &&
-                !state.exhaustedDetail) {
-                const estimateFinal = () => estimateNextRequestTokens({
-                    ...(state.lastRequestInputTokens !== undefined
-                        ? { priorUsageTokens: state.lastRequestInputTokens }
-                        : {}),
-                    appendedChars: payloadChars - (state.lastRequestPayloadChars ?? payloadChars),
-                    charsPerToken,
-                    coldStartChars: payloadChars,
-                });
-                let 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.
-                    state.forcedTriggerEstimate = estimate;
-                    const reshaped = await Promise.resolve(reentry({
-                        ...options,
-                        messages: result?.messages ?? options.messages,
-                        ...(result?.activeTools ? { activeTools: result.activeTools } : {}),
-                    }));
-                    state.forcedTriggerEstimate = undefined;
-                    if (reshaped) {
-                        result = {
-                            ...(result ?? {}),
-                            ...reshaped,
-                            activeTools: reshaped.activeTools ?? result?.activeTools,
-                        };
-                    }
-                    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;
-            return result;
-        };
-    }
 }
 // -- moved helpers (defined in ai-sdk-backend, used only by cache write) -------
 function incrementRecord(counts, key) {
@@ -1009,9 +1045,6 @@ function mergeCountsInto(target, source) {
     }
 }
 // -- moved helpers (prepare-step / signature / prune) ------------------------
-function activeToolResultArchiveKey(candidate) {
-    return `active:${candidate.turnId}:${candidate.toolCallId}:${candidate.bodySha256}`;
-}
 /**
  * Tool results from the newest completed step have not crossed the provider
  * boundary yet: projection is invoked immediately before the first request
@@ -1094,29 +1127,35 @@ export function hasActiveToolResultPruneDiagnosticPatch(patch) {
 export class MidTurnCapacityCompactState {
     headAnchor;
     priorContentEvents;
+    priorInvocations;
     capacity;
     /**
-     * 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.
+     * The last provider-accepted request's real input tokens plus its real
+     * output tokens, as the provider counted them — everything already in the
+     * next request that a number describes. Seeded from the previous turn's
+     * persisted anchor, refreshed at every step boundary, and cleared by any
+     * fold (the checkpoint changed the request; the next accepted one is the
+     * first measurement). Undefined is "no baseline", never zero.
+     */
+    baselineTokens;
+    /**
+     * Input plus output of the last request the provider accepted, as it
+     * counted them. Unlike `baselineTokens` it survives a fold: it is not a
+     * trigger input but the number a rejected user can declare as their window,
+     * proven to fit because the provider already accepted it (#4559).
      */
-    lastRequestPayloadChars;
+    lastAcceptedTotalTokens;
     /**
-     * The last request's REAL input size: the inputTokens the provider reported
-     * for the last finished step. Never input+output — the signed payload delta
-     * already carries the step's freshly generated output (assistant text/tool
-     * calls) and its tool results, so an output-inclusive baseline would count
-     * 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.
+     * Room the next reply may need: the model's declared output limit when the
+     * connection or metadata states one, else 0. A provider fact, never an
+     * estimate; it lets the trigger fire before a request that would otherwise
+     * be accepted but leave the reply no room (#4559).
      */
-    lastRequestInputTokens;
+    replyReserveTokens = 0;
     /** 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
@@ -1130,46 +1169,109 @@ export class MidTurnCapacityCompactState {
      * events enqueued at all.
      */
     flushedSteps = 0;
-    /**
-     * Set by the final-request estimate owner to force one capacity re-entry on
-     * the current step, bypassing the (deliberately approximate) high-water
-     * trigger. Consumed by the capacity hook on its next invocation.
-     */
-    forcedTriggerEstimate;
     /** Exact historical image results omitted after a provider overflow. */
     omittedImageToolResults = new Map();
+    /** Malformed summaries spend one bounded repair budget for this whole Turn. */
+    summarizerFailure;
     /**
-     * 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 compaction module has been entered in this send.
+     *
+     * One attempt per send, whatever its outcome: the summarizer's own failure
+     * circuit already latches for the rest of the send, so a second entry would
+     * dispatch nothing new. This is the budget, and only the budget (#4559).
      */
-    lastShapeFailure;
-    /** Malformed summaries spend one bounded repair budget for this whole Turn. */
-    malformedSummaryFailure;
-    constructor(headAnchor, priorContentEvents, capacity) {
+    compactionAttemptedThisSend = false;
+    /**
+     * A folded projection was actually selected in this send.
+     *
+     * Distinct from the attempt: a fold that fails open leaves the request
+     * carrying its full raw history, so nothing may be concluded from a later
+     * rejection about what remains in it.
+     */
+    compactionAppliedThisSend = false;
+    /**
+     * Input tokens of the last request a provider accepted before this send.
+     *
+     * Input against input, across the send boundary: the first request of a send
+     * has no earlier step to compare with, and `baselineTokens` counts the reply
+     * too, which the next request does not always carry.
+     */
+    priorAcceptedInputTokens;
+    constructor(headAnchor, priorContentEvents, priorInvocations, 
+    /**
+     * The Maka window: the context window the USER declared for this model,
+     * a compaction target and nothing else. Absent when none is declared,
+     * and then no proactive fold ever runs — the provider decides (#4559).
+     */
+    capacity) {
         this.headAnchor = headAnchor;
         this.priorContentEvents = priorContentEvents;
+        this.priorInvocations = priorInvocations;
         this.capacity = capacity;
     }
+    compactionPhase(stepNumber) {
+        return stepNumber === 0 &&
+            !this.priorContentEvents.some((event) => event.id === this.headAnchor.id)
+            ? 'pre_turn'
+            : 'mid_turn';
+    }
 }
 /**
- * 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
- * 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.
+ * The baseline one accepted request leaves for the next: its real input plus
+ * its real output tokens. Output is counted whole, reasoning included — a wire
+ * that does not resend reasoning makes this err high, and high is the safe
+ * direction for a trigger that can only ask for a compaction (#4559).
  */
-function midTurnRequestPayloadChars(messages, providerTools, activeTools, systemPromptChars) {
-    return (Math.max(0, Math.floor(systemPromptChars)) +
-        JSON.stringify(messages).length +
-        toolSchemaCharsForDiagnostics(providerTools, activeTools));
+/**
+ * Room to leave for the next reply, from the size of the last real one.
+ *
+ * Two real numbers and one bound: twice the last reply absorbs an answer that
+ * grows, and the cap keeps a single long reply from turning the reserve into
+ * the window. No previous reply means no reserve, never a guessed one.
+ */
+const MAX_REPLY_RESERVE_TOKENS = 8_000;
+function replyReserveTokens(lastReplyTokens) {
+    if (lastReplyTokens === undefined || !Number.isFinite(lastReplyTokens) || lastReplyTokens <= 0) {
+        return 0;
+    }
+    return Math.min(lastReplyTokens * 2, MAX_REPLY_RESERVE_TOKENS);
+}
+function usageBaselineTokens(usage) {
+    if (!usage)
+        return undefined;
+    const input = usage.inputTokens;
+    if (!Number.isFinite(input) || input <= 0)
+        return undefined;
+    const output = Number.isFinite(usage.outputTokens) ? Math.max(0, usage.outputTokens) : 0;
+    return input + output;
+}
+/**
+ * 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, invocations, 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 route = invocations.find((candidate) => candidate.runId === event?.runId)?.opening.route;
+        if (route?.provenance !== 'runtime' ||
+            route.modelId !== modelId ||
+            route.llmConnectionId !== connectionId) {
+            return undefined;
+        }
+        return anchor;
+    }
+    return undefined;
 }
 /**
  * The `decision: 'replaced'` diagnostic patch for a durable active-send fold,