@myagentroam/agent 0.11.52 → 0.11.54

package/dist/model/anthropic-messages.d.ts

@@ -8,3 +8,7 @@ export declare class AnthropicMessagesAdapter implements ModelAdapter {
     private startAttempt;
 }
 export declare function isAnthropicRecoverableStreamError(error: unknown): error is AgentError;
+export declare function anthropicMessages(messages: ModelRequest['messages'], images?: ModelRequest['images'], tools?: ModelRequest['tools'], modelId?: string, automaticCache?: boolean, cachePrefixMessages?: number): {
+    role: string;
+    content: unknown;
+}[];

package/dist/model/anthropic-messages.js

@@ -536,7 +536,7 @@ function boundedError(value, maximum) {
         return undefined;
     return [...normalized].slice(0, maximum).join('');
 }
-function anthropicMessages(messages, images, tools = [], modelId, automaticCache = true, cachePrefixMessages) {
+export function anthropicMessages(messages, images, tools = [], modelId, automaticCache = true, cachePrefixMessages) {
     if (cachePrefixMessages !== undefined &&
         (!Number.isSafeInteger(cachePrefixMessages) ||
             cachePrefixMessages < 0 ||

package/dist/model/native-context.d.ts

@@ -1,3 +1,9 @@
 import type { ModelMessage } from './contracts.js';
+/** Adapters persist native items at completion; consumers need only type and identity. */
+export declare function completedNativeThinkingIdentity(payload: {
+    role?: unknown;
+    provider?: unknown;
+    item?: unknown;
+}, recordId: string): string | undefined;
 /** Interpret only the existing native context record shapes and their model ownership. */
 export declare function restoreNativeModelContext(payload: Record<string, unknown>, activeModelId?: string): ModelMessage | undefined;

package/dist/model/native-context.js

@@ -1,4 +1,19 @@
 import { anthropicThinkingBlock } from './anthropic-thinking.js';
+/** Adapters persist native items at completion; consumers need only type and identity. */
+export function completedNativeThinkingIdentity(payload, recordId) {
+    if (payload.role !== 'provider')
+        return undefined;
+    const item = payload.item;
+    if (!item || typeof item !== 'object' || Array.isArray(item))
+        return undefined;
+    const block = item;
+    if (payload.provider === 'ANTHROPIC_MESSAGES') {
+        return block.type === 'thinking' || block.type === 'redacted_thinking' ? recordId : undefined;
+    }
+    if (payload.provider !== 'OPENAI_RESPONSES' || block.type !== 'reasoning')
+        return undefined;
+    return typeof block.id === 'string' ? block.id : recordId;
+}
 /** Interpret only the existing native context record shapes and their model ownership. */
 export function restoreNativeModelContext(payload, activeModelId) {
     const modelId = typeof payload.providerModelId === 'string' && payload.providerModelId.length > 0

package/dist/runtime/compaction/retained-context.d.ts

@@ -1,5 +1,10 @@
 import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
 import type { CompactSnapshotAnchor } from '../events.js';
+/** Keep the live suffix intact, extending into the snapshot only to fill three native blocks. */
+export declare function compactRetainedStart(messages: readonly ModelMessage[], snapshotLength: number, model: {
+    readonly id: string;
+    readonly protocol: ModelMessage['provider'];
+}): number;
 /** Use a public native identity, never private context text, as the visible boundary. */
 export declare function compactSnapshotAnchor(messages: readonly ModelMessage[], sources: WeakMap<ModelMessage, import('../../session/record-contract.js').SessionRecord>): CompactSnapshotAnchor | undefined;
 /** Decode the SDK-owned checkpoint suffix without promoting contextual text to real input. */

package/dist/runtime/compaction/retained-context.js

@@ -1,6 +1,49 @@
 import { parseModelInputMetadata } from '../../session/record-projection.js';
-import { restoreModelContext } from '../context/projection.js';
+import { providerToolCallId, restoreModelContext } from '../context/projection.js';
 import { parseModelImages } from '../../model/image.js';
+import { completedNativeThinkingIdentity } from '../../model/native-context.js';
+/** Keep the live suffix intact, extending into the snapshot only to fill three native blocks. */
+export function compactRetainedStart(messages, snapshotLength, model) {
+    let start = snapshotLength;
+    const thinking = new Set();
+    for (let index = messages.length - 1; index >= 0 && thinking.size < 3; index--) {
+        const message = messages[index];
+        if (message.provider !== model.protocol ||
+            (message.providerModelId !== undefined && message.providerModelId !== model.id))
+            continue;
+        const identity = completedNativeThinkingIdentity(message, `message:${index}`);
+        if (identity === undefined || thinking.has(identity))
+            continue;
+        thinking.add(identity);
+        start = Math.min(start, index);
+    }
+    // The existing snapshot boundary already closes tool groups.
+    if (start === snapshotLength)
+        return start;
+    // A native item can follow text or tool calls within the same assistant response.
+    while (start > 0 && messages[start - 1].role !== 'user' && messages[start - 1].role !== 'tool')
+        start--;
+    // Resolve any retained result back to its call's assistant group in two linear passes.
+    const calls = new Map();
+    let responseStart = 0;
+    for (let index = 0; index < start; index++) {
+        const message = messages[index];
+        if (message.role === 'user' || message.role === 'tool')
+            responseStart = index + 1;
+        const callId = message.role === 'tool_call' ? message.callId : providerToolCallId(message);
+        if (callId !== undefined && !calls.has(callId))
+            calls.set(callId, responseStart);
+    }
+    for (let index = messages.length - 1; index >= start; index--) {
+        const message = messages[index];
+        if (message.role !== 'tool' || message.callId === undefined)
+            continue;
+        const callStart = calls.get(message.callId);
+        if (callStart !== undefined)
+            start = Math.min(start, callStart);
+    }
+    return start;
+}
 /** Use a public native identity, never private context text, as the visible boundary. */
 export function compactSnapshotAnchor(messages, sources) {
     for (let index = messages.length - 1; index >= 0; index--) {

package/dist/runtime/context/gc-candidates-code.js

@@ -1,8 +1,8 @@
 import { retainedCodeInputs } from '../../session/context-gc-observations.js';
 import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
-import { codeCellCompletionSequence, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, normalizeContextGcCodeModeInput } from '../../session/context-gc-replacements.js';
+import { codeCellCompletionSequence, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, hasGenericContextGcPreview, normalizeContextGcCodeModeInput } from '../../session/context-gc-replacements.js';
 import { CONTEXT_GC_POLICY } from './gc-economics.js';
-import { successfulRolloutsAfter, targetFor, isRecord } from './gc-candidates.js';
+import { targetFor, isRecord } from './gc-candidates.js';
 export function collectCodeModeCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
@@ -10,22 +10,12 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
     for (const group of [...groups.values()].filter((item) => ['code_exec', 'code_exec_wait'].includes(item.toolName))) {
         if (!group.call ||
             !group.result ||
-            group.failed ||
-            !group.completed ||
             group.call.message.role !== 'tool_call' ||
             group.result.message.role !== 'tool' ||
             typeof group.result.message.content !== 'string')
             continue;
-        const code = normalizeContextGcCodeModeInput(group.call.message.arguments);
-        const completedPayload = group.completed.payload;
-        const completionSequence = codeCellCompletionSequence(input.records, group.completed);
-        if ((group.toolName !== 'code_exec_wait' && !code) ||
-            completionSequence === undefined ||
-            !isRecord(completedPayload) ||
-            typeof completedPayload.truncated !== 'boolean')
-            continue;
         for (const observation of group.result.message.observations ?? []) {
-            if (observation.type !== 'value')
+            if (observation.type !== 'value' || !hasGenericContextGcPreview(observation.value))
                 continue;
             const target = targetFor(group.result.record, {
                 ...group.result.message,
@@ -34,29 +24,41 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
             if (!target || existingTargets.has(contextGcTargetKey(target)))
                 continue;
             const evidenceSequence = group.result.record.sequence;
+            const protection = input.protection.after(evidenceSequence);
             const candidate = {
                 replacements: [
                     {
                         kind: 'CODE_MODE_OUTPUT',
                         callId: group.callId,
                         target,
-                        replacementContent: contextGcCodeModeOutputReplacement(observation.value, observation.truncated === true),
+                        replacementContent: contextGcCodeModeOutputReplacement(observation.value, observation.truncated === true, true),
                         evidenceSequence
                     }
                 ],
-                observedRollouts: successfulRolloutsAfter(input.records, Math.max(evidenceSequence, completionSequence), input.modelId, input.contextWindowTokens),
+                observedRollouts: protection.rollouts,
                 evidenceSequence
             };
             const reclaimedTokens = candidateSavings(candidate);
             if (reclaimedTokens <= 0)
                 continue;
-            if (candidate.observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
+            if (candidate.observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
+                protection.thinking >= 3)
                 eligible.push(candidate);
-            else {
+            else if (candidate.observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
                 protectedTokens += reclaimedTokens;
                 retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - candidate.observedRollouts);
             }
         }
+        if (group.failed || !group.completed)
+            continue;
+        const code = normalizeContextGcCodeModeInput(group.call.message.arguments);
+        const completedPayload = group.completed.payload;
+        const completionSequence = codeCellCompletionSequence(input.records, group.completed);
+        if ((group.toolName !== 'code_exec_wait' && !code) ||
+            completionSequence === undefined ||
+            !isRecord(completedPayload) ||
+            typeof completedPayload.truncated !== 'boolean')
+            continue;
         const callTarget = targetFor(group.call.record, group.call.message);
         const resultTarget = targetFor(group.result.record, group.result.message);
         if (!callTarget || !resultTarget)
@@ -69,7 +71,18 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
                 toolName: group.toolName,
                 callId: group.callId,
                 target: callTarget,
-                replacementArguments: contextGcCodeModeInputReplacement(code, group.result.message.observations ? retainedCodeInputs(input.records, group.callId) : []),
+                replacementArguments: contextGcCodeModeInputReplacement(code, group.result.message.observations
+                    ? retainedCodeInputs(input.records, group.callId, (original, successor) => {
+                        const maturity = input.protection.after(Math.max(evidenceSequence, completionSequence, original.sequence, successor.sequence));
+                        return maturity.rollouts >= 6 && maturity.thinking >= 3;
+                    }, {
+                        activeProcessIds: input.activeProcessIds,
+                        evidenceMature: (sequence) => {
+                            const maturity = input.protection.after(Math.max(evidenceSequence, completionSequence, sequence));
+                            return maturity.rollouts >= 6 && maturity.thinking >= 3;
+                        }
+                    })
+                    : []),
                 providerAliasTargets: group.aliases
                     .map(({ record, message }) => targetFor(record, message))
                     .filter((target) => target !== undefined),
@@ -86,14 +99,16 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
             });
         if (replacements.length === 0)
             continue;
-        const observedRollouts = successfulRolloutsAfter(input.records, Math.max(evidenceSequence, completionSequence), input.modelId, input.contextWindowTokens);
+        const protection = input.protection.after(Math.max(evidenceSequence, completionSequence));
+        const observedRollouts = protection.rollouts;
         const candidate = { replacements, observedRollouts, evidenceSequence };
         const reclaimedTokens = candidateSavings(candidate);
         if (reclaimedTokens <= 0)
             continue;
-        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
+        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
+            protection.thinking >= 3)
             eligible.push(candidate);
-        else {
+        else if (observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
             protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
         }

package/dist/runtime/context/gc-candidates-exec.js

@@ -1,7 +1,8 @@
 import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
 import { contextGcExecInputReplacement, contextGcExecOutputReplacement, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
 import { CONTEXT_GC_POLICY } from './gc-economics.js';
-import { successfulRolloutsAfter, targetFor, isRecord } from './gc-candidates.js';
+import { targetFor, isRecord } from './gc-candidates.js';
+import { terminalExecLifecycles } from '../../session/context-gc-exec-lifecycle.js';
 export function collectExecCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
@@ -28,56 +29,18 @@ export function collectExecCandidates(input, groups, existingTargets, candidateS
                 result
             });
     }
-    for (const startGroup of execGroups) {
-        const start = invocations.get(startGroup.callId);
-        if (!start)
-            continue;
-        const isStart = start.group.toolName === 'exec' &&
-            (start.input.action === 'start' ||
-                (start.input.action == null && typeof start.input.command === 'string'));
-        const processId = typeof start.input.processId === 'string'
-            ? start.input.processId
-            : typeof start.result.processId === 'string'
-                ? start.result.processId
-                : undefined;
-        if (!isStart) {
-            if (start.group.toolName !== 'exec_wait' || !processId)
-                continue;
-            // A process may start inside a cell or before the visible history boundary.
-            // Begin with its first visible wait, but never split an unfinished lifecycle.
-            const previous = execGroups.findLast((group) => (group.call?.record.sequence ?? Infinity) < start.group.call.record.sequence &&
-                ((isRecord(group.call?.message.arguments) &&
-                    group.call.message.arguments.processId === processId) ||
-                    invocations.get(group.callId)?.result.processId === processId));
-            const previousStatus = previous && invocations.get(previous.callId)?.result.status;
-            if (previous && previousStatus !== 'completed' && previousStatus !== 'cancelled')
-                continue;
-        }
-        const lifecycle = [start];
-        let terminal = start.result.status !== 'running';
-        if (!terminal) {
-            if (!processId)
-                continue;
-            const relatedGroups = execGroups.filter((group) => (group.call?.record.sequence ?? 0) > start.group.call.record.sequence &&
-                isRecord(group.call?.message.arguments) &&
-                group.call.message.arguments.processId === processId);
-            if (relatedGroups.some((group) => !invocations.has(group.callId)) ||
-                relatedGroups.length === 0)
-                continue;
-            for (const relatedGroup of relatedGroups) {
-                const invocation = invocations.get(relatedGroup.callId);
-                lifecycle.push(invocation);
-                if (invocation.result.status !== 'running') {
-                    terminal = true;
-                    break;
-                }
-            }
-        }
-        if (!terminal || (processId && input.activeProcessIds.has(processId)))
-            continue;
+    const facts = execGroups.map((group) => ({
+        value: group,
+        callId: group.callId,
+        toolName: group.toolName,
+        sequence: group.call?.record.sequence ?? Number.MAX_SAFE_INTEGER,
+        ...(isRecord(group.call?.message.arguments) ? { input: group.call.message.arguments } : {}),
+        ...(invocations.get(group.callId) ? { result: invocations.get(group.callId).result } : {})
+    }));
+    for (const selected of terminalExecLifecycles(facts, input.activeProcessIds)) {
+        const lifecycle = selected.map((fact) => invocations.get(fact.callId));
         const final = lifecycle.at(-1);
         const evidenceSequence = final.group.result.record.sequence;
-        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
         for (const invocation of lifecycle) {
             if (invocation.group.evidenceOnly)
@@ -112,20 +75,34 @@ export function collectExecCandidates(input, groups, existingTargets, candidateS
         }
         if (replacements.length === 0)
             continue;
+        const mature = [];
+        const awaitingRollouts = [];
+        let observedRollouts = Infinity;
+        for (const replacement of replacements) {
+            const protection = input.protection.after(Math.max(evidenceSequence, replacement.target.sequence));
+            if (protection.rollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
+                protection.thinking >= 3) {
+                mature.push(replacement);
+                observedRollouts = Math.min(observedRollouts, protection.rollouts);
+            }
+            else if (protection.rollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+                awaitingRollouts.push(replacement);
+                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - protection.rollouts);
+            }
+        }
+        if (awaitingRollouts.length)
+            protectedTokens += Math.max(0, candidateSavings({ replacements: awaitingRollouts, observedRollouts: 0, evidenceSequence }));
+        if (!mature.length)
+            continue;
         const candidate = {
-            replacements,
+            replacements: mature,
             observedRollouts,
             evidenceSequence
         };
         const reclaimedTokens = candidateSavings(candidate);
         if (reclaimedTokens <= 0)
             continue;
-        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
-            eligible.push(candidate);
-        else {
-            protectedTokens += reclaimedTokens;
-            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
-        }
+        eligible.push(candidate);
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }

package/dist/runtime/context/gc-candidates-read-patch.d.ts

@@ -1,6 +1,6 @@
 import { type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
 import { type ContextGcPlannerInput, type ContextCandidate, type CandidateSavings, type ToolGroup } from './gc-contracts.js';
-export declare function collectStageACandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingReplacements: readonly ContextGcReplacement[], existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
+export declare function collectDeterministicCandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingReplacements: readonly ContextGcReplacement[], existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
     eligible: ContextCandidate[];
     protectedTokens: number;
     retryAfterRollouts: number;

package/dist/runtime/context/gc-candidates-read-patch.js

@@ -1,18 +1,20 @@
 import { contextGcLogicalPathKey, contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
-import { contextGcApplyPatchInputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement } from '../../session/context-gc-replacements.js';
+import { contextGcApplyPatchInputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcReadRangeCovers, contextGcCoveredReadReplacement } from '../../session/context-gc-replacements.js';
 import { parseReadContextOutput } from '../../prompts/read-context.js';
 import { CONTEXT_GC_POLICY } from './gc-economics.js';
-import { successfulRolloutsAfter, targetFor } from './gc-candidates.js';
-export function collectStageACandidates(input, groups, existingReplacements, existingTargets, candidateSavings) {
+import { targetFor } from './gc-candidates.js';
+export function collectDeterministicCandidates(input, groups, existingReplacements, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
     const existingReadReplacements = new Map(existingReplacements.flatMap((replacement) => replacement.kind === 'READ_OUTPUT_ITEMS'
         ? [[contextGcTargetKey(replacement.target), replacement]]
         : []));
-    const reads = [...groups.values()].filter((group) => group.toolName === 'read' &&
+    const reads = [...groups.values()]
+        .filter((group) => group.toolName === 'read' &&
         group.call?.message.role === 'tool_call' &&
-        group.result?.message.role === 'tool');
+        group.result?.message.role === 'tool')
+        .sort((left, right) => left.result.record.sequence - right.result.record.sequence);
     const claimedReadItems = new Set([...existingReadReplacements.values()].flatMap((replacement) => replacement.items.map((item) => `${replacement.target.recordId}:${replacement.target.observationId ?? ''}:${item.index}`)));
     const patches = [...groups.values()]
         .flatMap((patch) => {
@@ -31,7 +33,6 @@ export function collectStageACandidates(input, groups, existingReplacements, exi
         .sort((left, right) => left.evidenceSequence - right.evidenceSequence);
     for (const { patch, result, terminal, evidenceSequence } of patches) {
         const patchCall = patch.call;
-        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
         const candidateReadItems = new Set();
         const patchTarget = targetFor(patchCall.record, patchCall.message);
@@ -75,7 +76,7 @@ export function collectStageACandidates(input, groups, existingReplacements, exi
                             operation: matched.operation
                         }),
                         evidenceSequence,
-                        ...(read.result.message.observationId ? { supersededByCallId: patch.callId } : {})
+                        supersededByCallId: patch.callId
                     }
                 ];
             });
@@ -97,21 +98,103 @@ export function collectStageACandidates(input, groups, existingReplacements, exi
         }
         if (replacements.length === 0)
             continue;
+        const mature = [];
+        const awaitingRollouts = [];
+        let observedRollouts = Infinity;
+        for (const replacement of replacements) {
+            const protection = input.protection.after(Math.max(evidenceSequence, replacement.target.sequence));
+            if (protection.rollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
+                protection.thinking >= 3) {
+                mature.push(replacement);
+                observedRollouts = Math.min(observedRollouts, protection.rollouts);
+            }
+            else if (protection.rollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+                awaitingRollouts.push(replacement);
+                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - protection.rollouts);
+            }
+        }
+        if (awaitingRollouts.length) {
+            protectedTokens += Math.max(0, candidateSavings({ replacements: awaitingRollouts, observedRollouts: 0, evidenceSequence }));
+        }
+        if (!mature.length)
+            continue;
         const candidate = {
-            replacements,
+            replacements: mature,
             observedRollouts,
             evidenceSequence
         };
         const reclaimedTokens = candidateSavings(candidate);
         if (reclaimedTokens <= 0)
             continue;
-        for (const itemKey of candidateReadItems)
-            claimedReadItems.add(itemKey);
-        if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
-            eligible.push(candidate);
-        else {
-            protectedTokens += reclaimedTokens;
-            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
+        for (const replacement of mature) {
+            if (replacement.kind !== 'READ_OUTPUT_ITEMS')
+                continue;
+            for (const item of replacement.items) {
+                const key = `${replacement.target.recordId}:${replacement.target.observationId ?? ''}:${item.index}`;
+                if (candidateReadItems.has(key))
+                    claimedReadItems.add(key);
+            }
+        }
+        eligible.push(candidate);
+    }
+    const visibleReads = reads.flatMap((group) => {
+        if (group.evidenceOnly || group.failed || !group.completed)
+            return [];
+        const target = targetFor(group.result.record, group.result.message);
+        const parsed = parseReadContextOutput(group.result.message.content);
+        return target && parsed ? [{ group, target, items: parsed.items }] : [];
+    });
+    for (const [index, old] of visibleReads.entries()) {
+        for (const item of old.items) {
+            const itemKey = `${old.target.recordId}:${old.target.observationId ?? ''}:${item.index}`;
+            if (claimedReadItems.has(itemKey) || item.content.startsWith('<mar_context_gc '))
+                continue;
+            const pathKey = contextGcLogicalPathKey(item.path, input.workspace, input.platform);
+            if (!pathKey)
+                continue;
+            const later = visibleReads
+                .slice(index + 1)
+                .filter((entry) => entry.items.some((candidate) => contextGcLogicalPathKey(candidate.path, input.workspace, input.platform) ===
+                pathKey &&
+                contextGcReadRangeCovers(item, candidate) &&
+                !existingReadReplacements
+                    .get(contextGcTargetKey(entry.target))
+                    ?.items.some((prior) => prior.index === candidate.index)));
+            const successor = later.findLast((entry) => {
+                const count = input.protection.after(entry.target.sequence);
+                return count.rollouts >= 6 && count.thinking >= 3;
+            });
+            if (!successor)
+                continue;
+            const existingRead = existingReadReplacements.get(contextGcTargetKey(old.target));
+            const evidenceSequence = successor.target.sequence;
+            const replacement = {
+                kind: 'READ_OUTPUT_ITEMS',
+                callId: old.group.callId,
+                target: old.target,
+                items: [
+                    ...(existingRead?.items ?? []),
+                    {
+                        index: item.index,
+                        path: item.path,
+                        replacement: contextGcCoveredReadReplacement(item, successor.group.callId),
+                        evidenceSequence,
+                        supersededByCallId: successor.group.callId
+                    }
+                ],
+                evidenceSequences: [
+                    ...new Set([...(existingRead?.evidenceSequences ?? []), evidenceSequence])
+                ]
+            };
+            const candidate = {
+                replacements: [replacement],
+                observedRollouts: input.protection.after(evidenceSequence).rollouts,
+                evidenceSequence
+            };
+            if (candidateSavings(candidate) > 0) {
+                eligible.push(candidate);
+                claimedReadItems.add(itemKey);
+            }
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };