@myagentroam/agent 0.11.52 → 0.11.53

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

@@ -1,7 +1,8 @@
 import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
-import { contextGcWebOutputReplacement, contextGcToolOutputReplacement, isGenericContextGcTool } from '../../session/context-gc-replacements.js';
+import { completedTodoWrite, todoInputReplacement, todoSnapshotReplacement, visibleTodoSnapshot } from '../../session/context-gc-todo.js';
+import { contextGcWebOutputReplacement, contextGcToolOutputReplacement, contextGcSkillOutputReplacement, hasGenericContextGcPreview, isGenericContextGcTool } 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 collectWebCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
@@ -26,7 +27,8 @@ export function collectWebCandidates(input, groups, existingTargets, candidateSa
         if (!target || existingTargets.has(contextGcTargetKey(target)))
             continue;
         const evidenceSequence = group.result.record.sequence;
-        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
+        const protection = input.protection.after(Math.max(evidenceSequence, target.sequence));
+        const observedRollouts = protection.rollouts;
         const candidate = {
             replacements: [
                 {
@@ -44,9 +46,10 @@ export function collectWebCandidates(input, groups, existingTargets, candidateSa
         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);
         }
@@ -58,6 +61,164 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
+    const searches = [...groups.values()]
+        .filter((group) => group.toolName === 'tool_search' &&
+        !group.failed &&
+        group.completed &&
+        group.call &&
+        group.result?.message.role === 'tool' &&
+        group.result.message.toolSearchTools !== undefined)
+        .sort((left, right) => left.result.record.sequence - right.result.record.sequence);
+    for (const group of searches) {
+        const result = group.result;
+        const target = targetFor(result.record, result.message);
+        const definitions = result.message.toolSearchTools;
+        if (!target || definitions.length === 0)
+            continue;
+        const retainedToolNames = [];
+        const evidence = [];
+        for (const tool of definitions) {
+            const successor = searches.findLast((candidate) => candidate.result.record.sequence > result.record.sequence &&
+                candidate.result.message.toolSearchTools.some((item) => item.name === tool.name) &&
+                (() => {
+                    const count = input.protection.after(Math.max(target.sequence, candidate.result.record.sequence));
+                    return count.rollouts >= 6 && count.thinking >= 3;
+                })());
+            if (successor)
+                evidence.push(successor.result.record.sequence);
+            else
+                retainedToolNames.push(tool.name);
+        }
+        if (evidence.length === 0)
+            continue;
+        const evidenceSequence = Math.max(...evidence);
+        const observedRollouts = input.protection.after(Math.max(target.sequence, evidenceSequence)).rollouts;
+        const candidate = {
+            replacements: [
+                {
+                    kind: 'TOOL_OUTPUT',
+                    toolName: 'tool_search',
+                    callId: group.callId,
+                    target,
+                    replacementContent: result.message.content,
+                    retainedToolNames,
+                    evidenceSequence
+                }
+            ],
+            observedRollouts,
+            evidenceSequence
+        };
+        if (candidateSavings(candidate) > 0)
+            eligible.push(candidate);
+    }
+    const writes = input.records.flatMap((record) => {
+        const fact = completedTodoWrite(record);
+        return fact ? [{ record, ...fact }] : [];
+    });
+    for (const group of groups.values()) {
+        if (group.failed || !group.completed || !group.call || group.call.message.role !== 'tool_call')
+            continue;
+        const ownWrite = completedTodoWrite(group.completed);
+        const snapshot = group.toolName === 'todo_read' && group.result?.message.role === 'tool'
+            ? visibleTodoSnapshot(group.result.message.content)
+            : undefined;
+        const currentRevision = group.toolName === 'todo_write' ? ownWrite?.revision : snapshot?.revision;
+        if (currentRevision === undefined)
+            continue;
+        const targetEntry = group.toolName === 'todo_write' ? group.call : group.result;
+        if (!targetEntry)
+            continue;
+        const target = targetFor(targetEntry.record, targetEntry.message);
+        if (!target || existingTargets.has(contextGcTargetKey(target)))
+            continue;
+        const successor = writes
+            .filter((write) => write.revision > currentRevision &&
+            input.protection.after(Math.max(target.sequence, group.completed.sequence, write.record.sequence)).rollouts >= 6 &&
+            input.protection.after(Math.max(target.sequence, group.completed.sequence, write.record.sequence)).thinking >= 3)
+            .sort((a, b) => b.revision - a.revision)[0];
+        if (!successor)
+            continue;
+        const evidenceSequence = successor.record.sequence;
+        const observedRollouts = input.protection.after(Math.max(target.sequence, group.completed.sequence, evidenceSequence)).rollouts;
+        let replacement;
+        if (group.toolName === 'todo_write') {
+            const args = group.call.message.arguments;
+            if (!isRecord(args) || !Array.isArray(args.items))
+                continue;
+            replacement = {
+                kind: 'TOOL_CALL_INPUT',
+                toolName: 'todo_write',
+                callId: group.callId,
+                target,
+                replacementArguments: todoInputReplacement(currentRevision, args.items.length, successor.revision),
+                providerAliasTargets: group.aliases
+                    .map(({ record, message }) => targetFor(record, message))
+                    .filter((value) => value !== undefined),
+                evidenceSequence
+            };
+        }
+        else {
+            if (!snapshot)
+                continue;
+            replacement = {
+                kind: 'TOOL_OUTPUT',
+                toolName: 'todo_read',
+                callId: group.callId,
+                target,
+                replacementContent: todoSnapshotReplacement(currentRevision, snapshot.count, successor.revision),
+                evidenceSequence
+            };
+        }
+        const candidate = { replacements: [replacement], observedRollouts, evidenceSequence };
+        if (candidateSavings(candidate) > 0)
+            eligible.push(candidate);
+    }
+    const skills = [...groups.values()]
+        .filter((group) => group.toolName === 'skill' &&
+        group.call?.message.role === 'tool_call' &&
+        isRecord(group.call.message.arguments) &&
+        typeof group.call.message.arguments.name === 'string' &&
+        group.result?.message.role === 'tool' &&
+        group.completed &&
+        !group.failed &&
+        !group.evidenceOnly)
+        .sort((left, right) => left.result.record.sequence - right.result.record.sequence);
+    for (const [index, group] of skills.entries()) {
+        const target = targetFor(group.result.record, group.result.message);
+        if (!target || existingTargets.has(contextGcTargetKey(target)))
+            continue;
+        const args = group.call.message.arguments;
+        const later = skills.slice(index + 1).filter((candidate) => {
+            const laterTarget = targetFor(candidate.result.record, candidate.result.message);
+            return (laterTarget &&
+                candidate.call.message.arguments.name === args.name &&
+                !existingTargets.has(contextGcTargetKey(laterTarget)));
+        });
+        const successor = later.findLast((candidate) => {
+            const count = input.protection.after(Math.max(target.sequence, candidate.result.record.sequence));
+            return count.rollouts >= 6 && count.thinking >= 3;
+        });
+        if (!successor)
+            continue;
+        const evidenceSequence = successor.result.record.sequence;
+        const observedRollouts = input.protection.after(Math.max(target.sequence, evidenceSequence)).rollouts;
+        const candidate = {
+            replacements: [
+                {
+                    kind: 'TOOL_OUTPUT',
+                    toolName: 'skill',
+                    callId: group.callId,
+                    target,
+                    replacementContent: contextGcSkillOutputReplacement(args.name, group.result.message.content, successor.callId),
+                    evidenceSequence
+                }
+            ],
+            observedRollouts,
+            evidenceSequence
+        };
+        if (candidateSavings(candidate) > 0)
+            eligible.push(candidate);
+    }
     for (const group of groups.values()) {
         if (!isGenericContextGcTool(group.toolName) ||
             group.evidenceOnly ||
@@ -68,6 +229,7 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
             group.call.message.role !== 'tool_call' ||
             group.result.message.role !== 'tool' ||
             typeof group.result.message.content !== 'string' ||
+            !hasGenericContextGcPreview(group.result.message.content) ||
             !isRecord(group.completed.payload) ||
             group.completed.payload.type !== 'tool.completed' ||
             group.completed.payload.callId !== group.callId ||
@@ -78,7 +240,8 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
         if (!target || existingTargets.has(contextGcTargetKey(target)))
             continue;
         const evidenceSequence = group.result.record.sequence;
-        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
+        const protection = input.protection.after(Math.max(evidenceSequence, target.sequence));
+        const observedRollouts = protection.rollouts;
         const candidate = {
             replacements: [
                 {
@@ -96,9 +259,10 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
         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-contracts.d.ts

@@ -3,6 +3,7 @@ import type { SessionModelMessage as ModelMessage } from '../../session/model-re
 import type { ModelUsage } from '../../model/contracts.js';
 import { ContextGcCheckpointCache, type ContextGcCheckpointDraft, type ContextGcMetrics, type ContextGcPlatform, type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
 import type { SessionRecord } from '../../session/record-contract.js';
+import type { buildContextGcProtection } from '../../session/context-gc-protection.js';
 export interface ContextGcPlan {
     readonly stage: ContextGcMetrics['stage'];
     readonly draft: ContextGcCheckpointDraft;
@@ -29,6 +30,7 @@ export interface ContextGcPlannerInput {
     readonly activeProcessIds: ReadonlySet<string>;
     readonly tokenCache?: Map<string, number>;
     readonly checkpointCache?: ContextGcCheckpointCache;
+    readonly protection?: ReturnType<typeof buildContextGcProtection>;
 }
 export interface ContextCandidate {
     readonly replacements: readonly ContextGcReplacement[];

package/dist/runtime/context/gc-economics.d.ts

@@ -24,16 +24,10 @@ export interface ContextGcEconomicsResult {
     readonly grossReductionRate: number;
     readonly passes: boolean;
 }
-interface ContextGcCacheEconomicsProfile {
-    readonly reclaimedTokens: number;
-    readonly reclaimedCachedTokens: number;
-    readonly cacheRebuildPenaltyCostUnits: number;
-}
 export declare function evaluateContextGcEconomics(input: ContextGcEconomicsInput): ContextGcEconomicsResult;
 export declare function contextGcMinimumGrossReductionRate(usageRatio: number): number;
 export declare function contextGcMinimumReclaimedTokens(contextUsageTokens: number, contextWindowTokens: number): number;
 export declare function contextGcEligibleUsage(usage: ModelUsage, contextWindowTokens: number): number | undefined;
-export declare function contextGcMarginalCacheInvestmentPaysBack(current: ContextGcCacheEconomicsProfile, combined: ContextGcCacheEconomicsProfile): boolean;
 export declare function contextGcImminentCompactAvoidanceCredit(input: {
     readonly contextUsageTokens: number;
     readonly contextWindowTokens: number;

package/dist/runtime/context/gc-economics.js

@@ -5,7 +5,7 @@ export const CONTEXT_GC_POLICY = {
     contextGrowthSampleWindow: 16,
     minimumContextGrowthSamples: 6,
     minimumObservationRollouts: 1,
-    stageAProtectionRollouts: 2,
+    stageAProtectionRollouts: 6,
     largeExecProtectionRollouts: 6,
     normalInputCostRate: 1,
     cacheReadCostRate: 0.1,
@@ -107,28 +107,6 @@ export function contextGcEligibleUsage(usage, contextWindowTokens) {
         return undefined;
     return contextUsageTokens;
 }
-export function contextGcMarginalCacheInvestmentPaysBack(current, combined) {
-    const marginalPenalty = combined.cacheRebuildPenaltyCostUnits - current.cacheRebuildPenaltyCostUnits;
-    if (marginalPenalty <= 0)
-        return true;
-    const firstRolloutSavings = (profile) => {
-        const reclaimedCachedTokens = clamp(profile.reclaimedCachedTokens, 0, Math.max(0, profile.reclaimedTokens));
-        return (reclaimedCachedTokens * CONTEXT_GC_POLICY.cacheReadCostRate +
-            Math.max(0, profile.reclaimedTokens - reclaimedCachedTokens) *
-                CONTEXT_GC_POLICY.normalInputCostRate);
-    };
-    const marginalFirstRolloutSavings = firstRolloutSavings(combined) - firstRolloutSavings(current);
-    const marginalSteadyRolloutSavings = Math.max(0, combined.reclaimedTokens - current.reclaimedTokens) *
-        CONTEXT_GC_POLICY.cacheReadCostRate;
-    for (let rollouts = 1; rollouts <= CONTEXT_GC_POLICY.immediatePaybackRollouts; rollouts++) {
-        const net = -marginalPenalty +
-            marginalFirstRolloutSavings +
-            Math.max(0, rollouts - 1) * marginalSteadyRolloutSavings;
-        if (net > 0 && net / marginalPenalty >= CONTEXT_GC_POLICY.minimumCacheInvestmentRoi)
-            return true;
-    }
-    return false;
-}
 export function contextGcImminentCompactAvoidanceCredit(input) {
     if (input.contextUsageTokens >= input.compactThresholdTokens ||
         input.contextGrowthP75Tokens <= 0 ||

package/dist/runtime/context/gc-tokens.js

@@ -1,4 +1,6 @@
 import { openAiInput } from '../../model/openai-responses.js';
+import { anthropicMessages } from '../../model/anthropic-messages.js';
+import { projectCodeModeSearchResult } from '../../session/code-mode-search-projection.js';
 import { countModelTokens } from '../token-budget.js';
 import { observationModelParts, observationModelText } from '../../session/code-observation-projection.js';
 export { MODEL_TOKEN_ESTIMATOR as CONTEXT_GC_TOKEN_ESTIMATOR } from '../token-budget.js';
@@ -23,6 +25,8 @@ function serializedEntries(input, messages) {
             }))
         }
         : message);
+    const codeMode = input.tools.some((tool) => tool.name === 'code_exec');
+    messages = messages.map((message) => projectCodeModeSearchResult(message, codeMode));
     const responses = input.modelProtocol === 'OPENAI_RESPONSES' ||
         (input.modelProtocol === undefined &&
             (input.messages ?? messages).some((message) => message.provider === 'OPENAI_RESPONSES'));
@@ -31,14 +35,20 @@ function serializedEntries(input, messages) {
             const contentParts = message.role === 'tool' ? observationModelParts(message) : undefined;
             return contentParts === undefined ? message : { ...message, contentParts };
         }), undefined, input.modelId, true, input.responsesConfigurationUpdates !== false)
-        : messages
-            .filter((message) => message.role !== 'provider' ||
-            (message.provider === 'ANTHROPIC_MESSAGES' && message.providerModelId === input.modelId))
-            .map((original) => {
-            const { observations: _observations, observationId: _observationId, ...message } = original;
-            const content = original.role === 'tool' ? observationModelText(original) : undefined;
-            return content === undefined ? message : { ...message, content };
-        });
+        : input.modelProtocol === 'ANTHROPIC_MESSAGES'
+            ? anthropicMessages(messages.map((message) => {
+                const contentParts = message.role === 'tool' ? observationModelParts(message) : undefined;
+                return contentParts === undefined ? message : { ...message, contentParts };
+            }), undefined, input.tools, input.modelId, false)
+            : messages
+                .filter((message) => message.role !== 'provider' ||
+                (message.provider === 'ANTHROPIC_MESSAGES' &&
+                    message.providerModelId === input.modelId))
+                .map((original) => {
+                const { observations: _observations, observationId: _observationId, toolSearchTools: _toolSearchTools, ...message } = original;
+                const content = original.role === 'tool' ? observationModelText(original) : undefined;
+                return content === undefined ? message : { ...message, content };
+            });
     return values.map((value, index) => {
         const item = value;
         const callId = item.call_id ?? item.callId;

package/dist/runtime/context/gc.d.ts

@@ -1,7 +1,5 @@
-import { type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
 import { type ContextGcPlan, type ContextGcInspection, type ContextGcPlannerInput } from './gc-contracts.js';
-export { CONTEXT_GC_POLICY, type ContextGcEconomicsResult, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcMarginalCacheInvestmentPaysBack, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
+export { CONTEXT_GC_POLICY, type ContextGcEconomicsResult, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
 export { type ContextGcPlan, type ContextGcInspection, type ContextGcPlannerInput } from './gc-contracts.js';
 export declare function planContextGc(input: ContextGcPlannerInput): ContextGcPlan | undefined;
 export declare function inspectContextGc(input: ContextGcPlannerInput): ContextGcInspection;
-export declare function contextGcEarliestReplacementSequence(replacements: readonly ContextGcReplacement[]): number;

package/dist/runtime/context/gc.js

@@ -1,13 +1,14 @@
 import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcCheckpointIntervalEligible, contextGcMinimumUsageGrowth, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
+import { buildContextGcProtection } from '../../session/context-gc-protection.js';
 import { CONTEXT_GC_TOKEN_ESTIMATOR, contextGcCacheImpact, contextGcMessageTokens, contextGcPrefixTokens, contextGcReclaimedTokens } from './gc-tokens.js';
 import { applyContextGcReplacementsToMessages, providerToolCallId } from './projection.js';
-import { CONTEXT_GC_POLICY, COMPACT_CREDIT_ACTIVATION_RATIO, COMPACT_THRESHOLD_RATIO, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcMarginalCacheInvestmentPaysBack, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits, modelContextUsage, clamp } from './gc-economics.js';
+import { CONTEXT_GC_POLICY, COMPACT_CREDIT_ACTIVATION_RATIO, COMPACT_THRESHOLD_RATIO, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits, modelContextUsage, clamp } from './gc-economics.js';
 import { buildToolGroups, countSuccessfulNormalRollouts, isRecord } from './gc-candidates.js';
 import { collectCodeModeCandidates } from './gc-candidates-code.js';
-import { collectStageACandidates } from './gc-candidates-read-patch.js';
+import { collectDeterministicCandidates } from './gc-candidates-read-patch.js';
 import { collectExecCandidates } from './gc-candidates-exec.js';
 import { collectToolOutputCandidates, collectWebCandidates } from './gc-candidates-web.js';
-export { CONTEXT_GC_POLICY, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcMarginalCacheInvestmentPaysBack, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
+export { CONTEXT_GC_POLICY, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
 export function planContextGc(input) {
     return inspectContextGc(input).plan;
 }
@@ -69,7 +70,8 @@ function inspectTextGc(input) {
     input = {
         ...input,
         tokenCache: new Map(),
-        checkpointCache: input.checkpointCache ?? new ContextGcCheckpointCache()
+        checkpointCache: input.checkpointCache ?? new ContextGcCheckpointCache(),
+        protection: buildContextGcProtection(input.records, input.modelId, input.contextWindowTokens)
     };
     const usageRatio = contextUsageTokens / input.contextWindowTokens;
     const usageRecord = latestUsageRecord(input.records, input.modelId);
@@ -108,85 +110,42 @@ function inspectTextGc(input) {
             ? replacement.providerAliasTargets.map(contextGcTargetKey)
             : [])
     ]));
-    const stageA = collectStageACandidates(input, groups, existing, existingTargets, candidateSavings);
-    const deterministicCandidates = stageA.eligible;
-    const deterministicProtectedTokens = stageA.protectedTokens;
-    const stageAPlan = evaluateCandidateSet(input, existing, deterministicCandidates, {
-        stage: 'STAGE_A',
-        contextUsageTokens,
-        usageRatio,
-        usageRecord,
-        normalRolloutOrdinal,
-        protectedCandidateTokens: deterministicProtectedTokens
-    });
-    if (stageAPlan?.economics.passes) {
-        const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
-        const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
-        const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
-        const tools = collectToolOutputCandidates(input, groups, existingTargets, candidateSavings);
-        const protectedCandidateTokens = deterministicProtectedTokens +
-            exec.protectedTokens +
-            codeMode.protectedTokens +
-            web.protectedTokens +
-            tools.protectedTokens;
-        const stageAPlanWithProtectedCandidates = evaluateCandidateSet(input, existing, deterministicCandidates, {
-            stage: 'STAGE_A',
-            contextUsageTokens,
-            usageRatio,
-            usageRecord,
-            normalRolloutOrdinal,
-            protectedCandidateTokens
-        }) ?? stageAPlan;
-        const marginal = mergeMarginalLargeOutputCandidates(input, existing, deterministicCandidates, [...exec.eligible, ...codeMode.eligible, ...web.eligible, ...tools.eligible], stageAPlanWithProtectedCandidates, {
-            contextUsageTokens,
-            usageRatio,
-            usageRecord,
-            normalRolloutOrdinal,
-            protectedCandidateTokens
-        });
-        const plan = checkpointEligible
-            ? finalizePlan(input, marginal ?? stageAPlanWithProtectedCandidates)
-            : undefined;
-        const retryAfterRollouts = Math.min(exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts, tools.retryAfterRollouts);
-        if (!plan && checkpointEligible)
-            return {};
-        return {
-            ...(plan ? { plan } : {}),
-            ...(protectedCandidateTokens > 0 && Number.isFinite(retryAfterRollouts)
-                ? { retryAfterRollouts }
-                : {})
-        };
-    }
+    const deterministic = collectDeterministicCandidates(input, groups, existing, existingTargets, candidateSavings);
     const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
     const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
     const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
     const tools = collectToolOutputCandidates(input, groups, existingTargets, candidateSavings);
-    const protectedCandidateTokens = deterministicProtectedTokens +
+    const protectedCandidateTokens = deterministic.protectedTokens +
         exec.protectedTokens +
         codeMode.protectedTokens +
         web.protectedTokens +
         tools.protectedTokens;
     const combined = evaluateCandidateSet(input, existing, [
-        ...deterministicCandidates,
+        ...deterministic.eligible,
         ...exec.eligible,
         ...codeMode.eligible,
         ...web.eligible,
         ...tools.eligible
     ], {
-        stage: 'STAGE_A_AND_EXEC',
+        stage: 'UNIFIED',
         contextUsageTokens,
         usageRatio,
         usageRecord,
         normalRolloutOrdinal,
         protectedCandidateTokens
     });
+    const retryAfterRollouts = Math.min(deterministic.retryAfterRollouts, exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts, tools.retryAfterRollouts);
     if (combined?.economics.passes && checkpointEligible) {
         const plan = finalizePlan(input, combined);
-        return plan ? { plan } : {};
+        return plan
+            ? {
+                plan,
+                ...(protectedCandidateTokens > 0 && Number.isFinite(retryAfterRollouts)
+                    ? { retryAfterRollouts }
+                    : {})
+            }
+            : {};
     }
-    const retryAfterRollouts = Math.min(stageA.retryAfterRollouts, exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts, tools.retryAfterRollouts);
-    // A worthwhile mixed set retains every positive protected candidate's retry
-    // hint even when the checkpoint interval prevents a durable draft.
     return protectedCandidateTokens > 0 &&
         (combined?.economics.passes ||
             protectedCandidateTokens >=
@@ -195,42 +154,6 @@ function inspectTextGc(input) {
         ? { retryAfterRollouts }
         : {};
 }
-function mergeMarginalLargeOutputCandidates(input, existing, deterministicCandidates, execCandidates, stageAPlan, state) {
-    let selected = [...deterministicCandidates];
-    let current = stageAPlan;
-    const stageAEarliestSequence = contextGcEarliestReplacementSequence(deterministicCandidates.flatMap((candidate) => candidate.replacements));
-    for (const candidate of [...execCandidates].sort((left, right) => right.evidenceSequence - left.evidenceSequence)) {
-        const evaluated = evaluateCandidateSet(input, existing, [...selected, candidate], {
-            stage: 'STAGE_A_AND_EXEC',
-            ...state
-        });
-        if (!evaluated?.economics.passes || evaluated.reclaimedTokens <= current.reclaimedTokens)
-            continue;
-        const doesNotMoveInvalidationEarlier = contextGcEarliestReplacementSequence(candidate.replacements) >= stageAEarliestSequence;
-        if (!doesNotMoveInvalidationEarlier &&
-            !contextGcMarginalCacheInvestmentPaysBack({
-                reclaimedTokens: current.reclaimedTokens,
-                reclaimedCachedTokens: current.reclaimedCachedTokens,
-                cacheRebuildPenaltyCostUnits: current.economics.cacheRebuildPenaltyCostUnits
-            }, {
-                reclaimedTokens: evaluated.reclaimedTokens,
-                reclaimedCachedTokens: evaluated.reclaimedCachedTokens,
-                cacheRebuildPenaltyCostUnits: evaluated.economics.cacheRebuildPenaltyCostUnits
-            }))
-            continue;
-        selected = [...selected, candidate];
-        current = evaluated;
-    }
-    return current === stageAPlan ? undefined : current;
-}
-export function contextGcEarliestReplacementSequence(replacements) {
-    return Math.min(...replacements.flatMap((replacement) => [
-        replacement.target.sequence,
-        ...(replacement.kind === 'TOOL_CALL_INPUT'
-            ? replacement.providerAliasTargets.map((target) => target.sequence)
-            : [])
-    ]));
-}
 function finalizePlan(input, evaluated, includeMedia = false) {
     if (!evaluated)
         return undefined;

package/dist/runtime/context/projection.js

@@ -105,7 +105,17 @@ export function applyContextGcReplacementsToMessages(messages, messageSources, r
                 replacement.kind === 'SUBAGENT_OUTPUT' ||
                 replacement.kind === 'WEB_OUTPUT') &&
                 next.role === 'tool')
-                next = { ...next, content: replacement.replacementContent };
+                next = {
+                    ...next,
+                    content: replacement.replacementContent,
+                    ...(replacement.kind === 'TOOL_OUTPUT' &&
+                        replacement.retainedToolNames !== undefined &&
+                        next.toolSearchTools !== undefined
+                        ? {
+                            toolSearchTools: next.toolSearchTools.filter((tool) => replacement.retainedToolNames.includes(tool.name))
+                        }
+                        : {})
+                };
         }
         if (next.textBlocks !== undefined && next.content !== message.content)
             next = {

package/dist/session/code-mode-search-projection.d.ts

@@ -0,0 +1,5 @@
+import type { ClientToolDefinition } from '../tools/contracts.js';
+import type { SessionModelMessage as ModelMessage } from './model-request.js';
+export declare function projectProgrammaticTool(tool: ClientToolDefinition): Pick<ClientToolDefinition, 'name' | 'description' | 'inputSchema'>;
+/** Preserve native search definitions while providing the same discovery evidence to other protocols. */
+export declare function projectCodeModeSearchResult(message: ModelMessage, codeModeEnabled: boolean): ModelMessage;

package/dist/session/code-mode-search-projection.js

@@ -0,0 +1,46 @@
+import { stableToolDefinition, stableToolSchema } from '../model/tool-definition-projection.js';
+import { allowsDirectTool, allowsToolCaller } from './tool-callers.js';
+export function projectProgrammaticTool(tool) {
+    return {
+        name: tool.name,
+        description: `${allowsDirectTool(tool, true) ? `Call directly or as tools.${tool.name} inside code_exec.` : `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.`}\n${tool.description}`,
+        inputSchema: stableToolSchema(tool.inputSchema)
+    };
+}
+/** Preserve native search definitions while providing the same discovery evidence to other protocols. */
+export function projectCodeModeSearchResult(message, codeModeEnabled) {
+    if (!message.toolSearchTools)
+        return message;
+    if (!codeModeEnabled)
+        return {
+            ...message,
+            toolSearchTools: message.toolSearchTools
+                .filter((tool) => allowsToolCaller(tool, 'direct'))
+                .map(stableToolDefinition)
+        };
+    const tools = message.toolSearchTools.map((tool) => ({
+        ...(allowsToolCaller(tool, 'programmatic')
+            ? {
+                ...projectProgrammaticTool(tool),
+                ...(allowsDirectTool(tool, true)
+                    ? { inputMode: tool.inputMode ?? 'json' }
+                    : {})
+            }
+            : {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: stableToolSchema(tool.inputSchema),
+                inputMode: tool.inputMode ?? 'json'
+            }),
+        caller: allowsToolCaller(tool, 'programmatic')
+            ? allowsDirectTool(tool, true)
+                ? 'both'
+                : 'programmatic'
+            : 'direct'
+    }));
+    return {
+        ...message,
+        content: JSON.stringify({ tools }),
+        toolSearchTools: tools.map(({ caller: _caller, ...tool }) => tool)
+    };
+}