@myagentroam/agent 0.11.55 → 0.11.57

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

@@ -2,6 +2,7 @@ import { retainedCodeInputs } from '../../session/context-gc-observations.js';
 import { contextGcTargetKey } from '../../session/context-gc-checkpoint.js';
 import { codeCellCompletionSequence, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, hasGenericContextGcPreview, normalizeContextGcCodeModeInput } from '../../session/context-gc-replacements.js';
 import { CONTEXT_GC_POLICY } from './gc-economics.js';
+import { contextGcProtectionMature } from '../../session/context-gc-protection.js';
 import { targetFor, isRecord } from './gc-candidates.js';
 export function collectCodeModeCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
@@ -41,8 +42,7 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
             const reclaimedTokens = candidateSavings(candidate);
             if (reclaimedTokens <= 0)
                 continue;
-            if (candidate.observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
-                protection.thinking >= 3)
+            if (contextGcProtectionMature(protection))
                 eligible.push(candidate);
             else if (candidate.observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
                 protectedTokens += reclaimedTokens;
@@ -74,12 +74,12 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
                 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;
+                        return contextGcProtectionMature(maturity);
                     }, {
                         activeProcessIds: input.activeProcessIds,
                         evidenceMature: (sequence) => {
                             const maturity = input.protection.after(Math.max(evidenceSequence, completionSequence, sequence));
-                            return maturity.rollouts >= 6 && maturity.thinking >= 3;
+                            return contextGcProtectionMature(maturity);
                         }
                     })
                     : []),
@@ -105,8 +105,7 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
         const reclaimedTokens = candidateSavings(candidate);
         if (reclaimedTokens <= 0)
             continue;
-        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
-            protection.thinking >= 3)
+        if (contextGcProtectionMature(protection))
             eligible.push(candidate);
         else if (observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
             protectedTokens += reclaimedTokens;

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

@@ -1,6 +1,7 @@
 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 { contextGcProtectionMature } from '../../session/context-gc-protection.js';
 import { targetFor, isRecord } from './gc-candidates.js';
 import { terminalExecLifecycles } from '../../session/context-gc-exec-lifecycle.js';
 export function collectExecCandidates(input, groups, existingTargets, candidateSavings) {
@@ -80,8 +81,7 @@ export function collectExecCandidates(input, groups, existingTargets, candidateS
         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) {
+            if (contextGcProtectionMature(protection)) {
                 mature.push(replacement);
                 observedRollouts = Math.min(observedRollouts, protection.rollouts);
             }

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

@@ -2,6 +2,7 @@ import { contextGcLogicalPathKey, contextGcTargetKey } from '../../session/conte
 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 { contextGcProtectionMature } from '../../session/context-gc-protection.js';
 import { targetFor } from './gc-candidates.js';
 export function collectDeterministicCandidates(input, groups, existingReplacements, existingTargets, candidateSavings) {
     const eligible = [];
@@ -103,8 +104,7 @@ export function collectDeterministicCandidates(input, groups, existingReplacemen
         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) {
+            if (contextGcProtectionMature(protection)) {
                 mature.push(replacement);
                 observedRollouts = Math.min(observedRollouts, protection.rollouts);
             }
@@ -162,7 +162,7 @@ export function collectDeterministicCandidates(input, groups, existingReplacemen
                     ?.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;
+                return contextGcProtectionMature(count);
             });
             if (!successor)
                 continue;

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

@@ -2,6 +2,7 @@ import { contextGcTargetKey } from '../../session/context-gc-checkpoint.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 { contextGcProtectionMature } from '../../session/context-gc-protection.js';
 import { targetFor, isRecord } from './gc-candidates.js';
 export function collectWebCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
@@ -46,8 +47,7 @@ export function collectWebCandidates(input, groups, existingTargets, candidateSa
         const reclaimedTokens = candidateSavings(candidate);
         if (reclaimedTokens <= 0)
             continue;
-        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
-            protection.thinking >= 3)
+        if (contextGcProtectionMature(protection))
             eligible.push(candidate);
         else if (observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
             protectedTokens += reclaimedTokens;
@@ -82,7 +82,7 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
                 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;
+                    return contextGcProtectionMature(count);
                 })());
             if (successor)
                 evidence.push(successor.result.record.sequence);
@@ -133,8 +133,7 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
             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)
+            contextGcProtectionMature(input.protection.after(Math.max(target.sequence, group.completed.sequence, write.record.sequence))))
             .sort((a, b) => b.revision - a.revision)[0];
         if (!successor)
             continue;
@@ -196,7 +195,7 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
         });
         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;
+            return contextGcProtectionMature(count);
         });
         if (!successor)
             continue;
@@ -259,8 +258,7 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
         const reclaimedTokens = candidateSavings(candidate);
         if (reclaimedTokens <= 0)
             continue;
-        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
-            protection.thinking >= 3)
+        if (contextGcProtectionMature(protection))
             eligible.push(candidate);
         else if (observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
             protectedTokens += reclaimedTokens;

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

@@ -1,7 +1,16 @@
 import type { ModelUsage } from '../../model/contracts.js';
-import { type ContextGcEconomicsPolicy } from '../../session/context-gc-checkpoint.js';
-export declare const CONTEXT_GC_POLICY: ContextGcEconomicsPolicy;
-export declare const COMPACT_CREDIT_ACTIVATION_RATIO = 0.8;
+export declare const CONTEXT_GC_POLICY: {
+    version: 1;
+    minimumPaybackRollouts: number;
+    maximumPaybackRollouts: number;
+    contextGrowthSampleWindow: number;
+    minimumContextGrowthSamples: number;
+    minimumObservationRollouts: number;
+    stageAProtectionRollouts: number;
+    largeExecProtectionRollouts: number;
+    normalInputCostRate: number;
+    cacheReadCostRate: number;
+};
 export declare const COMPACT_THRESHOLD_RATIO: number;
 interface ContextGcEconomicsInput {
     readonly contextUsageTokens: number;
@@ -10,11 +19,6 @@ interface ContextGcEconomicsInput {
     readonly reclaimedCachedTokens: number;
     readonly cacheReadTokens: number;
     readonly preservedCachedPrefixTokens: number;
-    readonly compactDeferralCreditCostUnits: number;
-    readonly projectedRolloutsUntilCompactAfterGc: number;
-    readonly contextGrowthSampleCount: number;
-    readonly minimumGrossReductionRate?: number;
-    readonly minimumReclaimedTokens?: number;
 }
 export interface ContextGcEconomicsResult {
     readonly cacheRebuildPenaltyCostUnits: number;
@@ -24,18 +28,8 @@ export interface ContextGcEconomicsResult {
     readonly passes: boolean;
 }
 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 contextGcMinimumReclaimedTokens(contextWindowTokens: number): number;
 export declare function contextGcEligibleUsage(usage: ModelUsage, contextWindowTokens: number): number | undefined;
-export declare function contextGcImminentCompactAvoidanceCredit(input: {
-    readonly contextUsageTokens: number;
-    readonly contextWindowTokens: number;
-    readonly compactThresholdTokens: number;
-    readonly projectedTokensBeforeGc: number;
-    readonly projectedTokensAfterGc: number;
-    readonly contextGrowthP75Tokens: number;
-}): number;
-export declare function contextGcAppliedCompactCreditCostUnits(compactDeferralCreditCostUnits: number, imminentCompactAvoidanceCreditCostUnits: number): number;
 export declare function modelContextUsage(value: ModelUsage | Record<string, unknown>): number | undefined;
 export declare function clamp(value: number, minimum: number, maximum: number): number;
 export {};

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

@@ -1,25 +1,19 @@
 import { AGENT_EXECUTION_POLICY } from '../execution-policy.js';
+import { CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS } from '../../session/context-gc-protection.js';
 export const CONTEXT_GC_POLICY = {
     version: 1,
-    immediatePaybackRollouts: 3,
-    maximumPaybackRollouts: 20,
+    minimumPaybackRollouts: 30,
+    maximumPaybackRollouts: 60,
     contextGrowthSampleWindow: 16,
     minimumContextGrowthSamples: 6,
     minimumObservationRollouts: 1,
-    stageAProtectionRollouts: 6,
-    largeExecProtectionRollouts: 6,
+    stageAProtectionRollouts: CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS,
+    largeExecProtectionRollouts: CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS,
     normalInputCostRate: 1,
-    cacheReadCostRate: 0.05,
-    outputCostRate: 1,
-    minimumGrossReductionRate: 0.2
+    cacheReadCostRate: 0.05
 };
 const CONTEXT_GC_START_RATIO = 0.5;
-const HIGH_WATER_GROSS_REDUCTION_START_RATIO = 0.7;
-const HIGH_WATER_MINIMUM_GROSS_REDUCTION_RATE = 0.1;
-const MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO = 0.05;
-export const COMPACT_CREDIT_ACTIVATION_RATIO = 0.8;
 export const COMPACT_THRESHOLD_RATIO = AGENT_EXECUTION_POLICY.backgroundCompactionPercent / 100;
-const IMMINENT_COMPACT_CREDIT_DISCOUNT = 0.8;
 export function evaluateContextGcEconomics(input) {
     const reclaimedTokens = Math.max(0, input.reclaimedTokens);
     const cacheReadTokens = Math.max(0, input.cacheReadTokens);
@@ -34,16 +28,13 @@ export function evaluateContextGcEconomics(input) {
     const reclaimedUncachedTokens = Math.max(0, reclaimedTokens - reclaimedCachedTokens);
     const firstRolloutSavings = reclaimedCachedTokens + reclaimedUncachedTokens * unitsPerNormalInput;
     const steadyRolloutSavings = reclaimedTokens;
-    const netAt = (rollouts) => (rollouts <= 0
+    const netAt = (rollouts) => rollouts <= 0
         ? -cacheRebuildPenalty
         : firstRolloutSavings +
             Math.max(0, rollouts - 1) * steadyRolloutSavings -
-            cacheRebuildPenalty) +
-        input.compactDeferralCreditCostUnits / CONTEXT_GC_POLICY.cacheReadCostRate;
+            cacheRebuildPenalty;
     let requiredPositiveNetRollouts;
-    if (netAt(0) > 0)
-        requiredPositiveNetRollouts = 0;
-    else if (netAt(1) > 0)
+    if (netAt(1) > 0)
         requiredPositiveNetRollouts = 1;
     else if (steadyRolloutSavings <= 0)
         requiredPositiveNetRollouts = null;
@@ -56,23 +47,17 @@ export function evaluateContextGcEconomics(input) {
     }
     const expectedNetSavedCostUnits = netAt(requiredPositiveNetRollouts ?? 0) * CONTEXT_GC_POLICY.cacheReadCostRate;
     const grossReductionRate = reclaimedTokens / Math.max(1, Math.max(0, input.contextUsageTokens));
-    const minimumGrossReductionRate = Math.max(0, input.minimumGrossReductionRate ?? CONTEXT_GC_POLICY.minimumGrossReductionRate);
-    const minimumReclaimedTokens = Math.max(0, input.minimumReclaimedTokens ??
-        Math.ceil(Math.max(0, input.contextUsageTokens) * minimumGrossReductionRate));
+    const minimumReclaimedTokens = contextGcMinimumReclaimedTokens(input.contextWindowTokens);
     const usageRatio = input.contextUsageTokens / input.contextWindowTokens;
-    const thresholdPercent = AGENT_EXECUTION_POLICY.backgroundCompactionPercent;
-    const activationPercent = COMPACT_CREDIT_ACTIVATION_RATIO * 100;
-    const withinWindow = requiredPositiveNetRollouts !== null &&
-        (usageRatio <= COMPACT_CREDIT_ACTIVATION_RATIO
-            ? requiredPositiveNetRollouts <= CONTEXT_GC_POLICY.maximumPaybackRollouts
-            : requiredPositiveNetRollouts *
-                (thresholdPercent * input.contextWindowTokens - 100 * input.contextUsageTokens) <=
-                CONTEXT_GC_POLICY.maximumPaybackRollouts *
-                    (thresholdPercent - activationPercent) *
-                    input.contextWindowTokens);
+    const progress = clamp((usageRatio - CONTEXT_GC_START_RATIO) / (COMPACT_THRESHOLD_RATIO - CONTEXT_GC_START_RATIO), 0, 1);
+    const paybackWindow = CONTEXT_GC_POLICY.minimumPaybackRollouts +
+        progress *
+            (CONTEXT_GC_POLICY.maximumPaybackRollouts - CONTEXT_GC_POLICY.minimumPaybackRollouts);
+    const withinWindow = requiredPositiveNetRollouts !== null && requiredPositiveNetRollouts <= paybackWindow;
     const passes = reclaimedTokens > 0 &&
         reclaimedTokens >= minimumReclaimedTokens &&
         Number.isFinite(usageRatio) &&
+        usageRatio >= CONTEXT_GC_START_RATIO &&
         usageRatio < COMPACT_THRESHOLD_RATIO &&
         withinWindow;
     return {
@@ -83,26 +68,8 @@ export function evaluateContextGcEconomics(input) {
         passes
     };
 }
-export function contextGcMinimumGrossReductionRate(usageRatio) {
-    if (!Number.isFinite(usageRatio) || usageRatio <= HIGH_WATER_GROSS_REDUCTION_START_RATIO)
-        return CONTEXT_GC_POLICY.minimumGrossReductionRate;
-    if (usageRatio >= COMPACT_THRESHOLD_RATIO)
-        return HIGH_WATER_MINIMUM_GROSS_REDUCTION_RATE;
-    const progress = (usageRatio - HIGH_WATER_GROSS_REDUCTION_START_RATIO) /
-        (COMPACT_THRESHOLD_RATIO - HIGH_WATER_GROSS_REDUCTION_START_RATIO);
-    return (CONTEXT_GC_POLICY.minimumGrossReductionRate -
-        progress *
-            (CONTEXT_GC_POLICY.minimumGrossReductionRate - HIGH_WATER_MINIMUM_GROSS_REDUCTION_RATE));
-}
-export function contextGcMinimumReclaimedTokens(contextUsageTokens, contextWindowTokens) {
-    if (!Number.isFinite(contextUsageTokens) ||
-        contextUsageTokens < 0 ||
-        !Number.isFinite(contextWindowTokens) ||
-        contextWindowTokens <= 0)
-        return 0;
-    const usageRatio = contextUsageTokens / contextWindowTokens;
-    const required = Math.max(contextUsageTokens * contextGcMinimumGrossReductionRate(usageRatio), contextWindowTokens * MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO);
-    return Math.ceil(required - 1e-9);
+export function contextGcMinimumReclaimedTokens(contextWindowTokens) {
+    return Math.ceil(contextWindowTokens / 20);
 }
 export function contextGcEligibleUsage(usage, contextWindowTokens) {
     const contextUsageTokens = modelContextUsage(usage);
@@ -115,21 +82,6 @@ export function contextGcEligibleUsage(usage, contextWindowTokens) {
         return undefined;
     return contextUsageTokens;
 }
-export function contextGcImminentCompactAvoidanceCredit(input) {
-    if (input.contextUsageTokens >= input.compactThresholdTokens ||
-        input.contextGrowthP75Tokens <= 0 ||
-        input.projectedTokensBeforeGc < input.compactThresholdTokens)
-        return 0;
-    const safetyMarginTokens = Math.max(input.contextWindowTokens * MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO, input.contextGrowthP75Tokens * CONTEXT_GC_POLICY.immediatePaybackRollouts);
-    if (input.projectedTokensAfterGc > input.compactThresholdTokens - safetyMarginTokens)
-        return 0;
-    return (input.contextUsageTokens *
-        CONTEXT_GC_POLICY.normalInputCostRate *
-        IMMINENT_COMPACT_CREDIT_DISCOUNT);
-}
-export function contextGcAppliedCompactCreditCostUnits(compactDeferralCreditCostUnits, imminentCompactAvoidanceCreditCostUnits) {
-    return Math.max(0, compactDeferralCreditCostUnits, imminentCompactAvoidanceCreditCostUnits);
-}
 export function modelContextUsage(value) {
     const context = value.contextInputTokens ?? value.inputTokens;
     return typeof context === 'number' && Number.isSafeInteger(context) && context >= 0

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

@@ -1,5 +1,5 @@
 import { type ContextGcPlan, type ContextGcInspection, type ContextGcPlannerInput } from './gc-contracts.js';
-export { CONTEXT_GC_POLICY, type ContextGcEconomicsResult, evaluateContextGcEconomics, contextGcMinimumGrossReductionRate, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
+export { CONTEXT_GC_POLICY, type ContextGcEconomicsResult, evaluateContextGcEconomics, contextGcMinimumReclaimedTokens, contextGcEligibleUsage } 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;

package/dist/runtime/context/gc.js

@@ -2,13 +2,13 @@ import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcCheckpoint
 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, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits, modelContextUsage, clamp } from './gc-economics.js';
+import { CONTEXT_GC_POLICY, COMPACT_THRESHOLD_RATIO, evaluateContextGcEconomics, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, modelContextUsage } from './gc-economics.js';
 import { buildToolGroups, countSuccessfulNormalRollouts, isRecord } from './gc-candidates.js';
 import { collectCodeModeCandidates } from './gc-candidates-code.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, contextGcImminentCompactAvoidanceCredit, contextGcAppliedCompactCreditCostUnits } from './gc-economics.js';
+export { CONTEXT_GC_POLICY, evaluateContextGcEconomics, contextGcMinimumReclaimedTokens, contextGcEligibleUsage } from './gc-economics.js';
 export function planContextGc(input) {
     return inspectContextGc(input).plan;
 }
@@ -31,7 +31,6 @@ export function inspectContextGc(input) {
     const state = {
         stage: text.plan?.stage ?? 'INLINE_MEDIA',
         contextUsageTokens,
-        usageRatio: contextUsageTokens / input.contextWindowTokens,
         usageRecord,
         normalRolloutOrdinal: countSuccessfulNormalRollouts(input.records, input.modelId, input.contextWindowTokens),
         protectedCandidateTokens: text.plan?.metrics.protectedCandidateTokens ?? 0
@@ -73,7 +72,6 @@ function inspectTextGc(input) {
         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);
     if (!usageRecord)
         return {};
@@ -129,7 +127,6 @@ function inspectTextGc(input) {
     ], {
         stage: 'UNIFIED',
         contextUsageTokens,
-        usageRatio,
         usageRecord,
         normalRolloutOrdinal,
         protectedCandidateTokens
@@ -148,8 +145,7 @@ function inspectTextGc(input) {
     }
     return protectedCandidateTokens > 0 &&
         (combined?.economics.passes ||
-            protectedCandidateTokens >=
-                contextGcMinimumReclaimedTokens(contextUsageTokens, input.contextWindowTokens)) &&
+            protectedCandidateTokens >= contextGcMinimumReclaimedTokens(input.contextWindowTokens)) &&
         Number.isFinite(retryAfterRollouts)
         ? { retryAfterRollouts }
         : {};
@@ -175,12 +171,8 @@ function finalizePlan(input, evaluated, includeMedia = false) {
         afterTokens: evaluated.afterTokens,
         reclaimedTokens: evaluated.reclaimedTokens,
         grossReductionRate: evaluated.economics.grossReductionRate,
-        effectiveMinimumGrossReductionRate: evaluated.minimumGrossReductionRate,
         minimumRequiredReclaimedTokens: evaluated.minimumReclaimedTokens,
         cacheRebuildPenaltyCostUnits: evaluated.economics.cacheRebuildPenaltyCostUnits,
-        compactDeferralCreditCostUnits: evaluated.compactDeferralCreditCostUnits,
-        imminentCompactAvoidanceCreditCostUnits: evaluated.imminentCompactAvoidanceCreditCostUnits,
-        appliedCompactCreditCostUnits: evaluated.appliedCompactCreditCostUnits,
         requiredPositiveNetRollouts: evaluated.economics.requiredPositiveNetRollouts,
         projectedRolloutsUntilCompactAfterGc: evaluated.projectedRolloutsUntilCompactAfterGc,
         projectedTokensBeforeGc: evaluated.projectedTokensBeforeGc,
@@ -231,8 +223,7 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
     const projected = applyContextGcReplacementsToMessages(input.messages, input.messageSources, replacements);
     const projectedMessages = mediaProjection?.(projected.messages) ?? projected.messages;
     const reclaimedTokens = contextGcReclaimedTokens(input, input.messages, projectedMessages);
-    const minimumGrossReductionRate = contextGcMinimumGrossReductionRate(state.usageRatio);
-    const minimumReclaimedTokens = contextGcMinimumReclaimedTokens(state.contextUsageTokens, input.contextWindowTokens);
+    const minimumReclaimedTokens = contextGcMinimumReclaimedTokens(input.contextWindowTokens);
     if (!state.mediaOnly && reclaimedTokens < minimumReclaimedTokens)
         return undefined;
     const beforeTokens = contextGcPrefixTokens(input) + contextGcMessageTokens(input, input.messages);
@@ -251,30 +242,13 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
     const projectedRolloutsUntilCompactAfterGc = contextGrowthP75Tokens <= 0
         ? 0
         : Math.max(0, Math.floor((compactThresholdTokens - projectedTokensAfterGc) / Math.max(1, contextGrowthP75Tokens)));
-    const compactDeferralCreditCostUnits = state.usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-        ? compactDeferralCredit(input, reclaimedTokens, compactThresholdTokens)
-        : 0;
-    const imminentCompactAvoidanceCreditCostUnits = contextGcImminentCompactAvoidanceCredit({
-        contextUsageTokens: state.contextUsageTokens,
-        contextWindowTokens: input.contextWindowTokens,
-        compactThresholdTokens,
-        projectedTokensBeforeGc,
-        projectedTokensAfterGc,
-        contextGrowthP75Tokens
-    });
-    const appliedCompactCreditCostUnits = contextGcAppliedCompactCreditCostUnits(compactDeferralCreditCostUnits, imminentCompactAvoidanceCreditCostUnits);
     const economics = evaluateContextGcEconomics({
         contextUsageTokens: state.contextUsageTokens,
         contextWindowTokens: input.contextWindowTokens,
         reclaimedTokens,
         reclaimedCachedTokens: cache.reclaimedCachedTokens,
         cacheReadTokens: input.usage.cacheReadTokens ?? 0,
-        preservedCachedPrefixTokens: cache.preservedCachedPrefixTokens,
-        compactDeferralCreditCostUnits: appliedCompactCreditCostUnits,
-        projectedRolloutsUntilCompactAfterGc,
-        contextGrowthSampleCount: growthSamples.length,
-        minimumGrossReductionRate,
-        minimumReclaimedTokens
+        preservedCachedPrefixTokens: cache.preservedCachedPrefixTokens
     });
     return {
         ...state,
@@ -286,14 +260,10 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
         reclaimedTokens,
         contextGrowthSamples: growthSamples,
         contextGrowthP75Tokens,
-        minimumGrossReductionRate,
         minimumReclaimedTokens,
         projectedRolloutsUntilCompactAfterGc,
         projectedTokensBeforeGc,
         projectedTokensAfterGc,
-        compactDeferralCreditCostUnits,
-        imminentCompactAvoidanceCreditCostUnits,
-        appliedCompactCreditCostUnits,
         boundarySequence: input.records.at(-1)?.sequence ?? state.usageRecord.sequence,
         minimumObservedRollouts: Math.min(...candidates.map((candidate) => candidate.observedRollouts)),
         eligibleCandidateCount: candidates.length
@@ -361,59 +331,6 @@ function collectContextGrowthSamples(records, modelId, contextWindowTokens, chec
     }
     return samples.slice(-CONTEXT_GC_POLICY.contextGrowthSampleWindow);
 }
-function compactDeferralCredit(input, reclaimedTokens, compactThresholdTokens) {
-    const base = contextGcBaseFromRecords(input.records);
-    if (base?.type !== 'COMPACT')
-        return 0;
-    const compact = input.records.find((record) => record.sequence === base.sequence);
-    if (!compact || !isRecord(compact.payload))
-        return 0;
-    if (compact.payload.modelId !== input.modelId ||
-        compact.payload.contextWindowTokens !== input.contextWindowTokens ||
-        !isRecord(compact.payload.usage))
-        return 0;
-    const usage = compact.payload.usage;
-    const contextInput = modelContextUsage(usage);
-    const cacheRead = nonnegativeNumber(usage.cacheReadTokens);
-    const output = nonnegativeNumber(usage.outputTokens);
-    if (contextInput === undefined || cacheRead === undefined || output === undefined)
-        return 0;
-    const baseline = firstMatchingUsageAfter(input.records, compact.sequence, input.modelId, input.contextWindowTokens);
-    if (baseline === undefined || baseline >= compactThresholdTokens)
-        return 0;
-    const fresh = Math.max(0, contextInput - cacheRead);
-    const compactCost = fresh * CONTEXT_GC_POLICY.normalInputCostRate +
-        cacheRead * CONTEXT_GC_POLICY.cacheReadCostRate +
-        output * CONTEXT_GC_POLICY.outputCostRate;
-    const cycleCapacity = Math.max(1, compactThresholdTokens - baseline);
-    return compactCost * clamp(reclaimedTokens / cycleCapacity, 0, 1);
-}
-function firstMatchingUsageAfter(records, sequence, modelId, contextWindowTokens) {
-    let activeModelId = modelId;
-    let activeContextWindowTokens = contextWindowTokens;
-    for (const record of records) {
-        if (record.sequence <= sequence)
-            continue;
-        if (record.type === 'execution.header' && isRecord(record.payload)) {
-            if (typeof record.payload.modelId === 'string')
-                activeModelId = record.payload.modelId;
-            if (typeof record.payload.contextWindowTokens === 'number' &&
-                Number.isSafeInteger(record.payload.contextWindowTokens) &&
-                record.payload.contextWindowTokens > 0)
-                activeContextWindowTokens = record.payload.contextWindowTokens;
-            continue;
-        }
-        if (activeModelId !== modelId ||
-            activeContextWindowTokens !== contextWindowTokens ||
-            !isRecord(record.payload) ||
-            record.payload.type !== 'usage.updated')
-            continue;
-        const usage = modelContextUsage(record.payload);
-        if (usage !== undefined)
-            return usage;
-    }
-    return undefined;
-}
 /** Measure only affected call families, retaining native aliases for provider lowering. */
 function createCandidateSavingsEstimator(input, existing) {
     const byCall = new Map();
@@ -466,6 +383,3 @@ function percentile75(values) {
     const sorted = [...values].sort((left, right) => left - right);
     return sorted[Math.max(0, Math.ceil(sorted.length * 0.75) - 1)];
 }
-function nonnegativeNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
-}

package/dist/session/context-gc-checkpoint.js

@@ -1,7 +1,7 @@
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { inlineMediaGcAnchored, parseInlineMediaGc } from './inline-media.js';
-import { buildContextGcProtection } from './context-gc-protection.js';
+import { buildContextGcProtection, contextGcProtectionMature } from './context-gc-protection.js';
 import { completedTodoWrite, todoInputReplacement, todoSnapshotReplacement, visibleTodoSnapshot } from './context-gc-todo.js';
 import { contextGcRetainedInputMarkup } from './context-gc-markup.js';
 import { codeCallEvidence, codePartialPatchCallEvidence, callsFromRecord, codeObservationEvidence, observationsFromRecord, retainedCodeInputs } from './context-gc-observations.js';
@@ -239,7 +239,7 @@ export function validateContextGcCheckpoint(records, record, workspace = session
         }
         if (anchors.some((anchor) => {
             const count = protection.after(anchor);
-            return count.rollouts < 6 || count.thinking < 3;
+            return !contextGcProtectionMature(count);
         }))
             return undefined;
         if (!replacementMatchesRecords(replacement, records, recordsBySequence, workspace, payload.trigger.platform, payload.replacements, protection, committed.get(contextGcReplacementKey(replacement))))
@@ -408,12 +408,12 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             isDeepStrictEqual(replacement.replacementArguments, contextGcCodeModeInputReplacement(input, observationsFromRecord(evidence.result)
                 ? retainedCodeInputs(records, replacement.callId, (original, successor) => {
                     const count = protection.after(Math.max(replacement.target.sequence, replacement.evidenceSequence, codeCellCompletionSequence(records, evidence.completed) ?? 0, original.sequence, successor.sequence));
-                    return count.rollouts >= 6 && count.thinking >= 3;
+                    return contextGcProtectionMature(count);
                 }, {
                     activeProcessIds: new Set(),
                     evidenceMature: (sequence) => {
                         const count = protection.after(Math.max(replacement.target.sequence, replacement.evidenceSequence, codeCellCompletionSequence(records, evidence.completed) ?? 0, sequence));
-                        return count.rollouts >= 6 && count.thinking >= 3;
+                        return contextGcProtectionMature(count);
                     },
                     selected: (callId, toolName, summary) => {
                         const argument = replacement.replacementArguments;
@@ -1102,7 +1102,6 @@ function isContextGcEconomicsPolicy(value) {
     return (isRecord(value) &&
         value.version === 1 &&
         [
-            'immediatePaybackRollouts',
             'maximumPaybackRollouts',
             'contextGrowthSampleWindow',
             'minimumContextGrowthSamples',
@@ -1110,13 +1109,14 @@ function isContextGcEconomicsPolicy(value) {
             'stageAProtectionRollouts',
             'largeExecProtectionRollouts'
         ].every((key) => isNonnegativeInteger(value[key])) &&
+        ['minimumPaybackRollouts', 'immediatePaybackRollouts'].every((key) => value[key] === undefined || isNonnegativeInteger(value[key])) &&
+        ['normalInputCostRate', 'cacheReadCostRate'].every((key) => isNonnegativeFinite(value[key])) &&
         [
-            'normalInputCostRate',
-            'cacheReadCostRate',
-            'outputCostRate',
-            'minimumGrossReductionRate'
-        ].every((key) => isNonnegativeFinite(value[key])) &&
-        ['cacheWriteCostRate', 'minimumCacheInvestmentRoi'].every((key) => value[key] === undefined || isNonnegativeFinite(value[key])));
+            'cacheWriteCostRate',
+            'minimumCacheInvestmentRoi',
+            'minimumGrossReductionRate',
+            'outputCostRate'
+        ].every((key) => value[key] === undefined || isNonnegativeFinite(value[key])));
 }
 function isContextGcMetrics(value) {
     if (!isRecord(value) ||
@@ -1131,7 +1131,6 @@ function isContextGcMetrics(value) {
         'reclaimedTokens',
         'grossReductionRate',
         'cacheRebuildPenaltyCostUnits',
-        'compactDeferralCreditCostUnits',
         'projectedRolloutsUntilCompactAfterGc',
         'contextGrowthSampleCount',
         'contextGrowthP75Tokens',
@@ -1142,6 +1141,7 @@ function isContextGcMetrics(value) {
     ];
     const optionalNonnegative = [
         'effectiveMinimumGrossReductionRate',
+        'compactDeferralCreditCostUnits',
         'minimumRequiredReclaimedTokens',
         'imminentCompactAvoidanceCreditCostUnits',
         'appliedCompactCreditCostUnits',

package/dist/session/context-gc-contract.d.ts

@@ -4,7 +4,8 @@ export type ContextGcSubagentToolName = 'agent_start' | 'agent_wait' | 'agent_me
 export type ContextGcPlatform = 'linux' | 'darwin' | 'win32';
 export interface ContextGcEconomicsPolicy {
     readonly version: 1;
-    readonly immediatePaybackRollouts: number;
+    readonly immediatePaybackRollouts?: number;
+    readonly minimumPaybackRollouts?: number;
     readonly maximumPaybackRollouts: number;
     readonly contextGrowthSampleWindow: number;
     readonly minimumContextGrowthSamples: number;
@@ -14,8 +15,8 @@ export interface ContextGcEconomicsPolicy {
     readonly normalInputCostRate: number;
     readonly cacheReadCostRate: number;
     readonly cacheWriteCostRate?: number;
-    readonly outputCostRate: number;
-    readonly minimumGrossReductionRate: number;
+    readonly outputCostRate?: number;
+    readonly minimumGrossReductionRate?: number;
     readonly minimumCacheInvestmentRoi?: number;
 }
 export type ContextGcBase = {
@@ -108,7 +109,7 @@ export interface ContextGcMetrics {
     readonly effectiveMinimumGrossReductionRate?: number;
     readonly minimumRequiredReclaimedTokens?: number;
     readonly cacheRebuildPenaltyCostUnits: number;
-    readonly compactDeferralCreditCostUnits: number;
+    readonly compactDeferralCreditCostUnits?: number;
     readonly imminentCompactAvoidanceCreditCostUnits?: number;
     readonly appliedCompactCreditCostUnits?: number;
     readonly requiredPositiveNetRollouts: number | null;

package/dist/session/context-gc-protection.d.ts

@@ -1,4 +1,9 @@
 import type { SessionRecord } from './record-contract.js';
+export declare const CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS = 10;
+export declare function contextGcProtectionMature(count: {
+    readonly rollouts: number;
+    readonly thinking: number;
+}): boolean;
 /** One immutable boundary index, shared by all candidate anchors in this evaluation. */
 export declare function buildContextGcProtection(records: readonly SessionRecord[], modelId: string, contextWindowTokens: number): {
     after(anchor: number): {