@myagentroam/agent 0.11.62 → 0.11.63

package/dist/cli/catalog-file.d.ts

@@ -30,6 +30,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
     defaultReasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max" | "ultra" | undefined;
     titleGeneration: boolean;
     codeMode: boolean;
+    gcEnabled?: boolean | undefined;
     fastMode?: boolean | undefined;
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
@@ -65,6 +66,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
     defaultReasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max" | "ultra" | undefined;
     titleGeneration: boolean;
     codeMode: boolean;
+    gcEnabled?: boolean | undefined;
     fastMode?: boolean | undefined;
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;

package/dist/cli/main.js

@@ -147,6 +147,7 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
     const defaultReasoningEffortOption = option('--default-reasoning-effort');
     const model = {
         useResourceUrl: existing?.useResourceUrl ?? false,
+        gcEnabled: existing?.gcEnabled ?? true,
         id,
         name: required(option('--name', existing?.name), '--name'),
         protocol,

package/dist/model/configuration.d.ts

@@ -56,6 +56,7 @@ declare const rawModelSchema: z.ZodObject<{
     subagentModel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     titleGeneration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     codeMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    gcEnabled: z.ZodOptional<z.ZodBoolean>;
     useResourceUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     fastMode: z.ZodOptional<z.ZodBoolean>;
     serviceTier: z.ZodOptional<z.ZodEnum<{

package/dist/model/configuration.js

@@ -38,6 +38,7 @@ const modelFieldsSchema = z
     subagentModel: z.boolean().optional().default(false),
     titleGeneration: z.boolean().optional().default(false),
     codeMode: z.boolean().optional().default(false),
+    gcEnabled: z.boolean().optional(),
     useResourceUrl: z.boolean().optional().default(false),
     fastMode: z.boolean().optional(),
     serviceTier: z.enum(['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast']).optional(),

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

@@ -0,0 +1,5 @@
+import type { ModelUsage } from '../../model/contracts.js';
+export declare const COMPACT_THRESHOLD_RATIO: number;
+export declare function contextGcMinimumReclaimedTokens(contextWindowTokens: number): number;
+export declare function contextGcEligibleUsage(usage: ModelUsage, contextWindowTokens: number): number | undefined;
+export declare function modelContextUsage(value: ModelUsage | Record<string, unknown>): number | undefined;

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

@@ -0,0 +1,23 @@
+import { AGENT_EXECUTION_POLICY } from '../execution-policy.js';
+const CONTEXT_GC_START_RATIO = 0.5;
+export const COMPACT_THRESHOLD_RATIO = AGENT_EXECUTION_POLICY.backgroundCompactionPercent / 100;
+export function contextGcMinimumReclaimedTokens(contextWindowTokens) {
+    return Math.floor(contextWindowTokens / 10) + 1;
+}
+export function contextGcEligibleUsage(usage, contextWindowTokens) {
+    const contextUsageTokens = modelContextUsage(usage);
+    if (contextUsageTokens === undefined ||
+        !Number.isSafeInteger(contextWindowTokens) ||
+        contextWindowTokens <= 0)
+        return undefined;
+    const usageRatio = contextUsageTokens / contextWindowTokens;
+    if (usageRatio < CONTEXT_GC_START_RATIO || usageRatio >= COMPACT_THRESHOLD_RATIO)
+        return undefined;
+    return contextUsageTokens;
+}
+export function modelContextUsage(value) {
+    const context = value.contextInputTokens ?? value.inputTokens;
+    return typeof context === 'number' && Number.isSafeInteger(context) && context >= 0
+        ? context
+        : undefined;
+}

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

@@ -1,8 +1,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 { CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS, contextGcProtectionMature } from '../../session/context-gc-protection.js';
 import { targetFor, isRecord } from './gc-candidates.js';
 export function collectCodeModeCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
@@ -44,9 +43,9 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
                 continue;
             if (contextGcProtectionMature(protection))
                 eligible.push(candidate);
-            else if (candidate.observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+            else if (candidate.observedRollouts < CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS) {
                 protectedTokens += reclaimedTokens;
-                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - candidate.observedRollouts);
+                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS - candidate.observedRollouts);
             }
         }
         if (group.failed || !group.completed)
@@ -107,9 +106,9 @@ export function collectCodeModeCandidates(input, groups, existingTargets, candid
             continue;
         if (contextGcProtectionMature(protection))
             eligible.push(candidate);
-        else if (observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+        else if (observedRollouts < CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS) {
             protectedTokens += reclaimedTokens;
-            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };

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

@@ -1,7 +1,6 @@
 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 { CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS, 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) {
@@ -85,9 +84,9 @@ export function collectExecCandidates(input, groups, existingTargets, candidateS
                 mature.push(replacement);
                 observedRollouts = Math.min(observedRollouts, protection.rollouts);
             }
-            else if (protection.rollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+            else if (protection.rollouts < CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS) {
                 awaitingRollouts.push(replacement);
-                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - protection.rollouts);
+                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS - protection.rollouts);
             }
         }
         if (awaitingRollouts.length)

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

@@ -1,8 +1,7 @@
 import { contextGcLogicalPathKey, contextGcTargetKey } from '../../session/context-gc-checkpoint.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 { contextGcProtectionMature } from '../../session/context-gc-protection.js';
+import { CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS, contextGcProtectionMature } from '../../session/context-gc-protection.js';
 import { targetFor } from './gc-candidates.js';
 export function collectDeterministicCandidates(input, groups, existingReplacements, existingTargets, candidateSavings) {
     const eligible = [];
@@ -108,9 +107,9 @@ export function collectDeterministicCandidates(input, groups, existingReplacemen
                 mature.push(replacement);
                 observedRollouts = Math.min(observedRollouts, protection.rollouts);
             }
-            else if (protection.rollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+            else if (protection.rollouts < CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS) {
                 awaitingRollouts.push(replacement);
-                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - protection.rollouts);
+                retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS - protection.rollouts);
             }
         }
         if (awaitingRollouts.length) {

package/dist/runtime/context/gc-candidates-web.d.ts

@@ -4,7 +4,7 @@ export declare function collectWebCandidates(input: ContextGcPlannerInput, group
     protectedTokens: number;
     retryAfterRollouts: number;
 };
-/** Generic successful tool results share output economics, without inferring resource state. */
+/** Generic successful tool results share output retention rules, without inferring resource state. */
 export declare function collectToolOutputCandidates(input: ContextGcPlannerInput, groups: ReadonlyMap<string, ToolGroup>, existingTargets: ReadonlySet<string>, candidateSavings: CandidateSavings): {
     eligible: ContextCandidate[];
     protectedTokens: number;

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

@@ -1,8 +1,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 { CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS, contextGcProtectionMature } from '../../session/context-gc-protection.js';
 import { targetFor, isRecord } from './gc-candidates.js';
 export function collectWebCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
@@ -49,14 +48,14 @@ export function collectWebCandidates(input, groups, existingTargets, candidateSa
             continue;
         if (contextGcProtectionMature(protection))
             eligible.push(candidate);
-        else if (observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+        else if (observedRollouts < CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS) {
             protectedTokens += reclaimedTokens;
-            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
-/** Generic successful tool results share output economics, without inferring resource state. */
+/** Generic successful tool results share output retention rules, without inferring resource state. */
 export function collectToolOutputCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
@@ -260,9 +259,9 @@ export function collectToolOutputCandidates(input, groups, existingTargets, cand
             continue;
         if (contextGcProtectionMature(protection))
             eligible.push(candidate);
-        else if (observedRollouts < CONTEXT_GC_POLICY.largeExecProtectionRollouts) {
+        else if (observedRollouts < CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS) {
             protectedTokens += reclaimedTokens;
-            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };

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

@@ -1,20 +1,16 @@
 import { isDeepStrictEqual } from 'node:util';
-import { ContextGcCheckpointCache, contextGcMinimumUsageGrowth, contextGcReplacementKey } from '../../session/context-gc-checkpoint.js';
-import { CONTEXT_GC_POLICY, contextGcEligibleUsage, inspectContextGc } from './gc.js';
+import { ContextGcCheckpointCache, contextGcReplacementKey } from '../../session/context-gc-checkpoint.js';
+import { contextGcEligibleUsage, inspectContextGc } from './gc.js';
 import { buildContextProjection } from './projection.js';
 /** Only scheduling metadata survives a call; records and validation caches do not. */
 export class ContextGcRuntime {
     #scope = '';
     #lastUsage;
-    #checkpoint;
-    #rolloutsSinceCheckpoint = 0;
     #failures = 0;
     #remaining = 0;
     reset() {
         this.#scope = '';
         this.#lastUsage = undefined;
-        this.#checkpoint = undefined;
-        this.#rolloutsSinceCheckpoint = 0;
         this.#failures = 0;
         this.#remaining = 0;
     }
@@ -44,40 +40,18 @@ export class ContextGcRuntime {
             this.#remaining = 0;
         }
         this.#lastUsage = usage;
-        if (this.#checkpoint)
-            this.#rolloutsSinceCheckpoint++;
         const maximumInterval = usage / input.contextWindowTokens >= 0.8 ? 2 : 8;
         this.#remaining = Math.min(this.#remaining, maximumInterval - 1);
         if (this.#remaining > 0 && !mediaRequired) {
             this.#remaining--;
             return false;
         }
-        if (!mediaRequired &&
-            this.#checkpoint?.trigger.modelId === input.modelId &&
-            this.#checkpoint.trigger.contextWindowTokens === input.contextWindowTokens &&
-            !this.#checkpoint.protectedCandidatesPending &&
-            this.#rolloutsSinceCheckpoint < CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
-            usage - this.#checkpoint.trigger.contextInputTokens <
-                contextGcMinimumUsageGrowth(input.contextWindowTokens))
-            return false;
         const attempt = await attemptContextGc(input);
         if (attempt.result) {
-            this.#checkpoint = {
-                trigger: { ...attempt.result.projection.checkpoint.trigger },
-                protectedCandidatesPending: attempt.result.projection.checkpoint.metrics.protectedCandidateTokens > 0
-            };
-            this.#rolloutsSinceCheckpoint = 0;
             this.#failures = 0;
-            this.#remaining = 1;
+            this.#remaining = 0;
         }
         else {
-            if (attempt.checkpointTrigger)
-                this.#checkpoint = {
-                    trigger: { ...attempt.checkpointTrigger },
-                    protectedCandidatesPending: attempt.protectedCandidatesPending === true
-                };
-            if (attempt.checkpointTrigger)
-                this.#rolloutsSinceCheckpoint = 0;
             this.#failures = Math.min(3, this.#failures + 1);
             this.#remaining =
                 Math.min(2 ** this.#failures, maximumInterval, attempt.retryAfterRollouts ?? Infinity) - 1;
@@ -107,30 +81,6 @@ async function attemptContextGc(input) {
         records =
             input.records ?? (await input.store.readExecutionState(input.sessionId)).contextRecords;
         const checkpointCache = new ContextGcCheckpointCache();
-        const previous = checkpointCache.read(records);
-        if (previous) {
-            deferred = {
-                ...deferred,
-                checkpointTrigger: previous.payload.trigger,
-                protectedCandidatesPending: previous.payload.metrics.protectedCandidateTokens > 0
-            };
-        }
-        if (!mediaRequired &&
-            previous?.payload.trigger.modelId === input.modelId &&
-            previous.payload.trigger.contextWindowTokens === input.contextWindowTokens) {
-            const rolloutGrowth = records.filter((record) => record.sequence > previous.record.sequence &&
-                record.type === 'model.attempt' &&
-                isRecord(record.payload) &&
-                record.payload.purpose === 'EXECUTION' &&
-                record.payload.state === 'SUCCEEDED').length;
-            const minimumRollouts = previous.payload.metrics.protectedCandidateTokens > 0
-                ? 2
-                : CONTEXT_GC_POLICY.largeExecProtectionRollouts;
-            if (rolloutGrowth < minimumRollouts &&
-                contextUsage - previous.payload.trigger.contextInputTokens <
-                    contextGcMinimumUsageGrowth(input.contextWindowTokens))
-                return deferred;
-        }
         const projection = buildContextProjection(records, checkpointCache);
         const messages = projection.entries.map((entry) => entry.message);
         const inspection = inspectContextGc({
@@ -155,11 +105,8 @@ async function attemptContextGc(input) {
         if (inspection.retryAfterRollouts !== undefined)
             deferred = {
                 ...deferred,
-                protectedCandidatesPending: true,
                 retryAfterRollouts: inspection.retryAfterRollouts
             };
-        else if (!inspection.plan)
-            deferred = { ...deferred, protectedCandidatesPending: false };
         const plan = inspection.plan;
         if (!plan)
             return deferred;
@@ -206,7 +153,6 @@ async function matchingCheckpointWasPersisted(store, sessionId, draft, records,
     if (latest?.payload.boundarySequence !== draft.boundarySequence ||
         !isDeepStrictEqual(latest.payload.base, draft.base) ||
         !isDeepStrictEqual(latest.payload.trigger, draft.trigger) ||
-        !isDeepStrictEqual(latest.payload.economics, draft.economics) ||
         !isDeepStrictEqual(latest.payload.inlineMedia, draft.inlineMedia) ||
         !isDeepStrictEqual(latest.payload.metrics, draft.metrics))
         return false;

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

@@ -20,7 +20,3 @@ export declare function contextGcTokenEntries(input: TokenContext, messages: rea
 export declare function contextGcReclaimedTokens(input: TokenContext, before: readonly ModelMessage[], after: readonly ModelMessage[]): number;
 export declare function contextGcPrefixTokens(input: TokenContext): number;
 export declare function contextGcMessageTokens(input: TokenContext, messages: readonly ModelMessage[]): number;
-export declare function contextGcCacheImpact(input: TokenContext, before: readonly ModelMessage[], after: readonly ModelMessage[], cacheRead: number, reclaimedTokens: number): {
-    preservedCachedPrefixTokens: number;
-    reclaimedCachedTokens: number;
-};

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

@@ -83,24 +83,6 @@ export function contextGcPrefixTokens(input) {
 export function contextGcMessageTokens(input, messages) {
     return contextGcTokenEntries(input, messages).reduce((sum, entry) => sum + entry.tokens, 0);
 }
-export function contextGcCacheImpact(input, before, after, cacheRead, reclaimedTokens) {
-    const afterByKey = new Map(contextGcTokenEntries(input, after).map((entry) => [entry.key, entry]));
-    let offset = contextGcPrefixTokens(input);
-    let earliest = cacheRead;
-    let reclaimedCachedTokens = 0;
-    for (const entry of contextGcTokenEntries(input, before)) {
-        const replacement = afterByKey.get(entry.key);
-        if (entry.text !== replacement?.text) {
-            earliest = Math.min(earliest, offset);
-            reclaimedCachedTokens += Math.min(Math.max(0, entry.tokens - (replacement?.tokens ?? 0)), Math.max(0, cacheRead - offset));
-        }
-        offset += entry.tokens;
-    }
-    return {
-        preservedCachedPrefixTokens: Math.max(0, Math.min(cacheRead, earliest)),
-        reclaimedCachedTokens: Math.min(reclaimedTokens, reclaimedCachedTokens)
-    };
-}
 function tokensFor(input, text) {
     const cached = input.tokenCache?.get(text);
     if (cached !== undefined)

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, contextGcMinimumReclaimedTokens, contextGcEligibleUsage } from './gc-economics.js';
+export { contextGcMinimumReclaimedTokens, contextGcEligibleUsage } from './gc-admission.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

@@ -1,14 +1,14 @@
-import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcCheckpointIntervalEligible, contextGcMinimumUsageGrowth, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
+import { ContextGcCheckpointCache, contextGcBaseFromRecords, 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 { CONTEXT_GC_TOKEN_ESTIMATOR, contextGcMessageTokens, contextGcPrefixTokens, contextGcReclaimedTokens } from './gc-tokens.js';
 import { applyContextGcReplacementsToMessages, providerToolCallId } from './projection.js';
-import { CONTEXT_GC_POLICY, COMPACT_THRESHOLD_RATIO, evaluateContextGcEconomics, contextGcMinimumReclaimedTokens, contextGcEligibleUsage, modelContextUsage } from './gc-economics.js';
+import { contextGcMinimumReclaimedTokens, contextGcEligibleUsage, modelContextUsage } from './gc-admission.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, contextGcMinimumReclaimedTokens, contextGcEligibleUsage } from './gc-economics.js';
+export { contextGcMinimumReclaimedTokens, contextGcEligibleUsage } from './gc-admission.js';
 export function planContextGc(input) {
     return inspectContextGc(input).plan;
 }
@@ -36,20 +36,8 @@ export function inspectContextGc(input) {
         protectedCandidateTokens: text.plan?.metrics.protectedCandidateTokens ?? 0
     };
     if (text.plan) {
-        const combined = evaluateCandidateSet(input, [], [
-            {
-                replacements: text.plan.draft.replacements,
-                observedRollouts: text.plan.metrics.minimumObservedRollouts,
-                evidenceSequence: text.plan.draft.boundarySequence
-            }
-        ], state, media.project);
-        if (combined?.economics.passes) {
-            const plan = finalizePlan(input, combined, true);
-            if (plan)
-                return { plan };
-        }
-        if (media.reason === 'TEXT_GC')
-            return text;
+        const { project: _project, ...inlineMedia } = media;
+        return { ...text, plan: { ...text.plan, draft: { ...text.plan.draft, inlineMedia } } };
     }
     // Byte pressure has its own admission signal; it never relaxes text GC eligibility.
     const onlyMedia = evaluateCandidateSet(input, input.checkpointCache.read(input.records)?.payload.replacements ?? [], [
@@ -60,7 +48,7 @@ export function inspectContextGc(input) {
         }
     ], { ...state, stage: 'INLINE_MEDIA', mediaOnly: true }, media.project);
     const plan = onlyMedia && finalizePlan(input, onlyMedia, true);
-    return plan ? { plan } : text;
+    return plan ? { ...text, plan } : text;
 }
 function inspectTextGc(input) {
     const contextUsageTokens = contextGcEligibleUsage(input.usage, input.contextWindowTokens);
@@ -77,26 +65,6 @@ function inspectTextGc(input) {
         return {};
     const normalRolloutOrdinal = countSuccessfulNormalRollouts(input.records, input.modelId, input.contextWindowTokens);
     const previous = input.checkpointCache.read(input.records);
-    const checkpointEligible = contextGcCheckpointIntervalEligible({
-        usageSequence: usageRecord.sequence,
-        contextInputTokens: contextUsageTokens,
-        contextWindowTokens: input.contextWindowTokens,
-        normalRolloutOrdinal,
-        modelId: input.modelId,
-        platform: input.platform
-    }, previous?.payload.trigger);
-    // Discovery and economic evaluation have their own low-growth opportunities;
-    // neither a protected candidate nor periodic discovery makes a draft eligible.
-    if (previous?.payload.trigger.modelId === input.modelId &&
-        previous.payload.trigger.contextWindowTokens === input.contextWindowTokens) {
-        const rolloutGrowth = normalRolloutOrdinal - previous.payload.trigger.normalRolloutOrdinal;
-        if (rolloutGrowth < 2 ||
-            (previous.payload.metrics.protectedCandidateTokens === 0 &&
-                rolloutGrowth < CONTEXT_GC_POLICY.largeExecProtectionRollouts &&
-                contextUsageTokens - previous.payload.trigger.contextInputTokens <
-                    contextGcMinimumUsageGrowth(input.contextWindowTokens)))
-            return {};
-    }
     if (input.messages.length !== input.messageSources.length)
         return {};
     const groups = buildToolGroups(input.records, input.messages, input.messageSources);
@@ -118,13 +86,14 @@ function inspectTextGc(input) {
         codeMode.protectedTokens +
         web.protectedTokens +
         tools.protectedTokens;
-    const combined = evaluateCandidateSet(input, existing, [
+    const eligible = [
         ...deterministic.eligible,
         ...exec.eligible,
         ...codeMode.eligible,
         ...web.eligible,
         ...tools.eligible
-    ], {
+    ];
+    const combined = evaluateCandidateSet(input, existing, eligible, {
         stage: 'UNIFIED',
         contextUsageTokens,
         usageRecord,
@@ -132,7 +101,7 @@ function inspectTextGc(input) {
         protectedCandidateTokens
     });
     const retryAfterRollouts = Math.min(deterministic.retryAfterRollouts, exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts, tools.retryAfterRollouts);
-    if (combined?.economics.passes && checkpointEligible) {
+    if (combined) {
         const plan = finalizePlan(input, combined);
         return plan
             ? {
@@ -143,10 +112,11 @@ function inspectTextGc(input) {
             }
             : {};
     }
-    return protectedCandidateTokens > 0 &&
-        (combined?.economics.passes ||
-            protectedCandidateTokens >= contextGcMinimumReclaimedTokens(input.contextWindowTokens)) &&
-        Number.isFinite(retryAfterRollouts)
+    // An already mature but sub-threshold batch can combine with newly mature
+    // candidates on the next rollout; no-candidate backoff must not delay it.
+    if (eligible.length > 0)
+        return { retryAfterRollouts: 1 };
+    return protectedCandidateTokens > 0 && Number.isFinite(retryAfterRollouts)
         ? { retryAfterRollouts }
         : {};
 }
@@ -170,23 +140,15 @@ function finalizePlan(input, evaluated, includeMedia = false) {
         beforeTokens: evaluated.beforeTokens,
         afterTokens: evaluated.afterTokens,
         reclaimedTokens: evaluated.reclaimedTokens,
-        grossReductionRate: evaluated.economics.grossReductionRate,
-        minimumRequiredReclaimedTokens: evaluated.minimumReclaimedTokens,
-        cacheRebuildPenaltyCostUnits: evaluated.economics.cacheRebuildPenaltyCostUnits,
-        requiredPositiveNetRollouts: evaluated.economics.requiredPositiveNetRollouts,
-        projectedRolloutsUntilCompactAfterGc: evaluated.projectedRolloutsUntilCompactAfterGc,
-        projectedTokensBeforeGc: evaluated.projectedTokensBeforeGc,
-        projectedTokensAfterGc: evaluated.projectedTokensAfterGc,
-        contextGrowthSampleCount: evaluated.contextGrowthSamples.length,
-        contextGrowthP75Tokens: evaluated.contextGrowthP75Tokens,
-        expectedNetSavedCostUnits: evaluated.economics.expectedNetSavedCostUnits,
+        ...(evaluated.mediaOnly
+            ? {}
+            : { minimumRequiredReclaimedTokens: evaluated.minimumReclaimedTokens }),
         minimumObservedRollouts: evaluated.minimumObservedRollouts,
         protectedCandidateTokens: evaluated.protectedCandidateTokens,
         eligibleCandidateCount: evaluated.eligibleCandidateCount,
         eligibleTargetCount: replacements.reduce((count, replacement) => count +
             1 +
-            (replacement.kind === 'TOOL_CALL_INPUT' ? replacement.providerAliasTargets.length : 0), 0),
-        cachePenaltyKnown: input.usage.cacheReadTokens !== undefined
+            (replacement.kind === 'TOOL_CALL_INPUT' ? replacement.providerAliasTargets.length : 0), 0)
     };
     const draft = {
         ...(inlineMedia ? { inlineMedia } : {}),
@@ -206,7 +168,6 @@ function finalizePlan(input, evaluated, includeMedia = false) {
             modelId: input.modelId,
             platform: input.platform
         },
-        economics: CONTEXT_GC_POLICY,
         metrics
     };
     return { stage: evaluated.stage, draft, metrics };
@@ -222,48 +183,23 @@ function evaluateCandidateSet(input, existing, candidates, state, mediaProjectio
         return undefined;
     const projected = applyContextGcReplacementsToMessages(input.messages, input.messageSources, replacements);
     const projectedMessages = mediaProjection?.(projected.messages) ?? projected.messages;
-    const reclaimedTokens = contextGcReclaimedTokens(input, input.messages, projectedMessages);
+    const baseline = applyContextGcReplacementsToMessages(input.messages, input.messageSources, existing);
+    const baselineMessages = mediaProjection?.(baseline.messages) ?? baseline.messages;
+    const reclaimedTokens = contextGcReclaimedTokens(input, baselineMessages, projectedMessages);
     const minimumReclaimedTokens = contextGcMinimumReclaimedTokens(input.contextWindowTokens);
     if (!state.mediaOnly && reclaimedTokens < minimumReclaimedTokens)
         return undefined;
-    const beforeTokens = contextGcPrefixTokens(input) + contextGcMessageTokens(input, input.messages);
+    const beforeTokens = contextGcPrefixTokens(input) + contextGcMessageTokens(input, baselineMessages);
     const afterTokens = contextGcPrefixTokens(input) + contextGcMessageTokens(input, projectedMessages);
     if (!state.mediaOnly && reclaimedTokens === 0)
         return undefined;
-    const cache = contextGcCacheImpact(input, input.messages, projectedMessages, input.usage.cacheReadTokens ?? 0, reclaimedTokens);
-    const growthSamples = collectContextGrowthSamples(input.records, input.modelId, input.contextWindowTokens, input.checkpointCache);
-    const contextGrowthP75Tokens = percentile75(growthSamples);
-    const compactThresholdTokens = Math.floor(input.contextWindowTokens * COMPACT_THRESHOLD_RATIO);
-    // Usage describes the request before its generated output and tool results.
-    const pendingMessages = input.messages.filter((_message, index) => input.messageSources[index].sequence > state.usageRecord.sequence);
-    const pendingTokens = Math.max(0, input.usage.outputTokens ?? 0) + contextGcMessageTokens(input, pendingMessages);
-    const projectedTokensBeforeGc = state.contextUsageTokens + pendingTokens;
-    const projectedTokensAfterGc = Math.max(0, projectedTokensBeforeGc - reclaimedTokens);
-    const projectedRolloutsUntilCompactAfterGc = contextGrowthP75Tokens <= 0
-        ? 0
-        : Math.max(0, Math.floor((compactThresholdTokens - projectedTokensAfterGc) / Math.max(1, contextGrowthP75Tokens)));
-    const economics = evaluateContextGcEconomics({
-        contextUsageTokens: state.contextUsageTokens,
-        contextWindowTokens: input.contextWindowTokens,
-        reclaimedTokens,
-        reclaimedCachedTokens: cache.reclaimedCachedTokens,
-        cacheReadTokens: input.usage.cacheReadTokens ?? 0,
-        preservedCachedPrefixTokens: cache.preservedCachedPrefixTokens
-    });
     return {
         ...state,
-        economics,
-        reclaimedCachedTokens: cache.reclaimedCachedTokens,
         replacements,
         beforeTokens,
         afterTokens,
         reclaimedTokens,
-        contextGrowthSamples: growthSamples,
-        contextGrowthP75Tokens,
         minimumReclaimedTokens,
-        projectedRolloutsUntilCompactAfterGc,
-        projectedTokensBeforeGc,
-        projectedTokensAfterGc,
         boundarySequence: input.records.at(-1)?.sequence ?? state.usageRecord.sequence,
         minimumObservedRollouts: Math.min(...candidates.map((candidate) => candidate.observedRollouts)),
         eligibleCandidateCount: candidates.length
@@ -286,51 +222,6 @@ function latestUsageRecord(records, selectedModelId) {
     }
     return latest;
 }
-function collectContextGrowthSamples(records, modelId, contextWindowTokens, checkpointCache) {
-    const previous = checkpointCache.read(records);
-    const base = contextGcBaseFromRecords(records);
-    const startSequence = previous?.record.sequence ?? (base?.type === 'COMPACT' ? base.sequence : base?.firstSequence);
-    let activeModelId = modelId;
-    let activeWindow = contextWindowTokens;
-    let previousUsage;
-    const samples = [];
-    for (const record of records) {
-        if (startSequence !== undefined && record.sequence <= startSequence)
-            continue;
-        if (record.type === 'execution.header' && isRecord(record.payload)) {
-            const nextModel = modelIdFromRecord(record);
-            const nextWindow = record.payload.contextWindowTokens;
-            if (nextModel !== modelId ||
-                (typeof nextWindow === 'number' && nextWindow !== contextWindowTokens)) {
-                activeModelId = nextModel ?? activeModelId;
-                activeWindow =
-                    typeof nextWindow === 'number' && Number.isSafeInteger(nextWindow)
-                        ? nextWindow
-                        : activeWindow;
-                previousUsage = undefined;
-            }
-            else {
-                activeModelId = modelId;
-                activeWindow = contextWindowTokens;
-            }
-            continue;
-        }
-        if (activeModelId !== modelId ||
-            activeWindow !== contextWindowTokens ||
-            !isRecord(record.payload) ||
-            record.payload.type !== 'usage.updated')
-            continue;
-        const usage = modelContextUsage(record.payload);
-        if (usage === undefined) {
-            previousUsage = undefined;
-            continue;
-        }
-        if (previousUsage !== undefined && usage > previousUsage)
-            samples.push(usage - previousUsage);
-        previousUsage = usage;
-    }
-    return samples.slice(-CONTEXT_GC_POLICY.contextGrowthSampleWindow);
-}
 /** Measure only affected call families, retaining native aliases for provider lowering. */
 function createCandidateSavingsEstimator(input, existing) {
     const byCall = new Map();
@@ -377,9 +268,3 @@ function modelIdFromRecord(record) {
         return undefined;
     return typeof record.payload.modelId === 'string' ? record.payload.modelId : undefined;
 }
-function percentile75(values) {
-    if (values.length === 0)
-        return 0;
-    const sorted = [...values].sort((left, right) => left - right);
-    return sorted[Math.max(0, Math.ceil(sorted.length * 0.75) - 1)];
-}

package/dist/sdk/execution-context-coordinator.d.ts

@@ -23,6 +23,7 @@ export declare class ExecutionContextCoordinator {
         readonly requests: Pick<CompactRequests, 'drain'>;
         readonly signal: AbortSignal;
         readonly window: number;
+        readonly gcEnabled?: boolean;
         readonly gc: Pick<ContextGcRuntime, 'run'>;
         readonly gcBase: Omit<ContextGcRuntimeInput, 'system' | 'tools' | 'usage' | 'inlineMedia' | 'mediaView' | 'getActiveProcessIds'>;
         start(input?: {

package/dist/sdk/execution-context-coordinator.js

@@ -80,10 +80,12 @@ export class ExecutionContextCoordinator {
                 this.ports.signal.throwIfAborted();
                 this.ports.execution.assertContextValid();
             });
-        if (!this.ports.compact.pending)
+        if (this.ports.gcEnabled !== false && !this.ports.compact.pending)
             await this.gc(round, usage, await this.ports.resources.gcCandidate(), true);
     }
     async gc(round, usage, media, includeProcesses = false) {
+        if (this.ports.gcEnabled === false || this.ports.compact.pending)
+            return false;
         const appendBoundary = this.ports.execution.appendBoundary;
         const committed = await this.ports.gc.run({
             ...this.ports.gcBase,

package/dist/sdk/session-execution-factory.js

@@ -571,6 +571,7 @@ export function createSessionExecutionFactory(ports) {
                         requests: compactRequests,
                         signal: controller.signal,
                         window: selectedModel.contextWindowTokens,
+                        gcEnabled: selectedModel.gcEnabled ?? true,
                         gc: contextGc,
                         gcBase: {
                             store,
@@ -724,7 +725,9 @@ export function createSessionExecutionFactory(ports) {
                         },
                         prepareResources: async ({ candidateRequest, request, toolScope }) => {
                             resourceInput.observe(candidateRequest.messages);
-                            const media = await resourceInput.gcCandidate(request, candidateRequest.images);
+                            const media = selectedModel.gcEnabled === false
+                                ? undefined
+                                : await resourceInput.gcCandidate(request, candidateRequest.images);
                             if (media?.reason === 'HARD_LIMIT') {
                                 const committed = await contextCoordinator.gc({ request, toolScope }, modelLifecycle.usage, media);
                                 if (committed)

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

@@ -1,5 +1,5 @@
 import type { SessionRecord } from './record-contract.js';
-import type { ContextGcPlatform, ContextGcBase, ContextGcTarget, ContextGcReplacement, ContextGcCheckpointDraft, ContextGcCheckpointPayload } from './context-gc-contract.js';
+import type { ContextGcPlatform, ContextGcBase, ContextGcTarget, ContextGcReplacement, ContextGcCheckpointPayload } from './context-gc-contract.js';
 export type { ContextGcPlatform, ContextGcEconomicsPolicy, ContextGcBase, ContextGcTarget, ContextGcReadItemReplacement, ContextGcReplacement, ContextGcMetrics, ContextGcCheckpointDraft, ContextGcCheckpointPayload } from './context-gc-contract.js';
 export declare const CONTEXT_GC_CHECKPOINT_VERSION: 1;
 export declare const CONTEXT_GC_MAX_TARGETS = 4096;
@@ -8,9 +8,6 @@ export declare class ContextGcCheckpointCache {
     #private;
     read(records: readonly SessionRecord[], boundarySequence?: number): ReturnType<typeof latestValidContextGcCheckpoint>;
 }
-export declare function contextGcMinimumUsageGrowth(contextWindowTokens: number): number;
-/** Compare adjacent checkpoint triggers only within the same model/window scope. */
-export declare function contextGcCheckpointIntervalEligible(trigger: ContextGcCheckpointDraft['trigger'], previous?: ContextGcCheckpointDraft['trigger']): boolean;
 export declare function contextGcLogicalPathKey(path: string, workspace: string, platform?: ContextGcPlatform): string | undefined;
 export declare function contextGcTargetKey(target: ContextGcTarget): string;
 export declare function contextGcReplacementKey(replacement: ContextGcReplacement): string;

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

@@ -22,19 +22,6 @@ export class ContextGcCheckpointCache {
         return value;
     }
 }
-export function contextGcMinimumUsageGrowth(contextWindowTokens) {
-    return Math.max(2_000, Math.floor(contextWindowTokens * 0.05));
-}
-/** Compare adjacent checkpoint triggers only within the same model/window scope. */
-export function contextGcCheckpointIntervalEligible(trigger, previous) {
-    if (!previous ||
-        trigger.modelId !== previous.modelId ||
-        trigger.contextWindowTokens !== previous.contextWindowTokens)
-        return true;
-    return (trigger.normalRolloutOrdinal - previous.normalRolloutOrdinal >= 2 &&
-        trigger.contextInputTokens - previous.contextInputTokens >=
-            contextGcMinimumUsageGrowth(trigger.contextWindowTokens));
-}
 export function contextGcLogicalPathKey(path, workspace, platform) {
     if (!path || !workspace || path.includes('\0') || workspace.includes('\0'))
         return undefined;
@@ -126,7 +113,7 @@ export function parseContextGcCheckpoint(record) {
         !Array.isArray(payload.replacements) ||
         (payload.replacements.length === 0 && payload.inlineMedia === undefined) ||
         !isContextGcTrigger(payload.trigger) ||
-        !isContextGcEconomicsPolicy(payload.economics) ||
+        (payload.economics !== undefined && !isContextGcEconomicsPolicy(payload.economics)) ||
         !isContextGcMetrics(payload.metrics) ||
         (payload.inlineMedia !== undefined && !parseInlineMediaGc(payload.inlineMedia)))
         return undefined;
@@ -141,7 +128,7 @@ export function parseContextGcCheckpoint(record) {
         boundarySequence: payload.boundarySequence,
         replacements,
         trigger: structuredClone(payload.trigger),
-        economics: structuredClone(payload.economics),
+        ...(payload.economics === undefined ? {} : { economics: structuredClone(payload.economics) }),
         metrics: structuredClone(payload.metrics),
         ...(payload.inlineMedia === undefined
             ? {}
@@ -1129,17 +1116,17 @@ function isContextGcMetrics(value) {
         'beforeTokens',
         'afterTokens',
         'reclaimedTokens',
-        'grossReductionRate',
-        'cacheRebuildPenaltyCostUnits',
-        'projectedRolloutsUntilCompactAfterGc',
-        'contextGrowthSampleCount',
-        'contextGrowthP75Tokens',
         'minimumObservedRollouts',
         'protectedCandidateTokens',
         'eligibleCandidateCount',
         'eligibleTargetCount'
     ];
     const optionalNonnegative = [
+        'grossReductionRate',
+        'cacheRebuildPenaltyCostUnits',
+        'projectedRolloutsUntilCompactAfterGc',
+        'contextGrowthSampleCount',
+        'contextGrowthP75Tokens',
         'effectiveMinimumGrossReductionRate',
         'compactDeferralCreditCostUnits',
         'minimumRequiredReclaimedTokens',
@@ -1150,11 +1137,12 @@ function isContextGcMetrics(value) {
     ];
     return (nonnegative.every((key) => isNonnegativeFinite(value[key])) &&
         [
-            'requiredPositiveNetRollouts',
+            ...(value.requiredPositiveNetRollouts === undefined ? [] : ['requiredPositiveNetRollouts']),
             ...(value.requiredTargetRoiRollouts === undefined ? [] : ['requiredTargetRoiRollouts'])
         ].every((key) => isNonnegativeFinite(value[key]) || (value.stage === 'INLINE_MEDIA' && value[key] === null)) &&
         optionalNonnegative.every((key) => value[key] === undefined || isNonnegativeFinite(value[key])) &&
-        Number.isFinite(value.expectedNetSavedCostUnits) &&
+        (value.expectedNetSavedCostUnits === undefined ||
+            Number.isFinite(value.expectedNetSavedCostUnits)) &&
         (value.cacheInvestmentRoi === undefined || Number.isFinite(value.cacheInvestmentRoi)) &&
         (value.tokenEstimator === undefined || value.tokenEstimator === 'UTF8_BYTES_V1') &&
         (value.cachePenaltyKnown === undefined || typeof value.cachePenaltyKnown === 'boolean'));

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

@@ -105,21 +105,21 @@ export interface ContextGcMetrics {
     readonly beforeTokens: number;
     readonly afterTokens: number;
     readonly reclaimedTokens: number;
-    readonly grossReductionRate: number;
+    readonly grossReductionRate?: number;
     readonly effectiveMinimumGrossReductionRate?: number;
     readonly minimumRequiredReclaimedTokens?: number;
-    readonly cacheRebuildPenaltyCostUnits: number;
+    readonly cacheRebuildPenaltyCostUnits?: number;
     readonly compactDeferralCreditCostUnits?: number;
     readonly imminentCompactAvoidanceCreditCostUnits?: number;
     readonly appliedCompactCreditCostUnits?: number;
-    readonly requiredPositiveNetRollouts: number | null;
+    readonly requiredPositiveNetRollouts?: number | null;
     readonly requiredTargetRoiRollouts?: number | null;
-    readonly projectedRolloutsUntilCompactAfterGc: number;
+    readonly projectedRolloutsUntilCompactAfterGc?: number;
     readonly projectedTokensBeforeGc?: number;
     readonly projectedTokensAfterGc?: number;
-    readonly contextGrowthSampleCount: number;
-    readonly contextGrowthP75Tokens: number;
-    readonly expectedNetSavedCostUnits: number;
+    readonly contextGrowthSampleCount?: number;
+    readonly contextGrowthP75Tokens?: number;
+    readonly expectedNetSavedCostUnits?: number;
     readonly cacheInvestmentRoi?: number;
     readonly minimumObservedRollouts: number;
     readonly protectedCandidateTokens: number;
@@ -141,7 +141,7 @@ export interface ContextGcCheckpointDraft {
         readonly modelId: string;
         readonly platform: ContextGcPlatform;
     };
-    readonly economics: ContextGcEconomicsPolicy;
+    readonly economics?: ContextGcEconomicsPolicy;
     readonly metrics: ContextGcMetrics;
 }
 export interface ContextGcCheckpointPayload extends ContextGcCheckpointDraft {

package/dist/session/store/jsonl/jsonl-store.js

@@ -9,7 +9,7 @@ import { cloneCoreJson } from '../../extension-checkpoint.js';
 import { acquireFileLock } from '../../../storage/file-lock.js';
 import { todoItemsFromSnapshot } from '../../todo.js';
 import { applyCodeModeStateMutations, parseCodeModeStateMutations, restoreCodeModeState } from '../../code-state.js';
-import { contextGcBaseFromRecords, contextGcCheckpointIntervalEligible, latestValidContextGcCheckpoint, normalizeContextGcReplacements, sameContextGcBase, validateContextGcCheckpoint } from '../../context-gc-checkpoint.js';
+import { contextGcBaseFromRecords, latestValidContextGcCheckpoint, normalizeContextGcReplacements, sameContextGcBase, validateContextGcCheckpoint } from '../../context-gc-checkpoint.js';
 import { recordToolResources, readToolResultResource, writeToolResultResource } from '../../tool-result-resources.js';
 import { beginTreeDeleteTransaction, finishTreeDelete, finishTreeDeletePreparation, readTreeDeleteTransaction, recoverSessionStorageTransaction, stageTreeDelete } from './transaction-recovery.js';
 import { extensionCheckpointFromPayload, indexExtensionCheckpoint, restoreExtensionCheckpoint, updateSessionCurrentState } from '../current-state.js';
@@ -1293,9 +1293,6 @@ export class JsonlSessionStore {
                 !sameContextGcBase(contextGcBaseFromRecords(records, boundarySequence), draft.base))
                 throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Context GC planning boundary is invalid.');
             const previous = latestValidContextGcCheckpoint(records, boundarySequence);
-            if ((!draft.inlineMedia || draft.inlineMedia.reason === 'TEXT_GC') &&
-                !contextGcCheckpointIntervalEligible(draft.trigger, previous?.payload.trigger))
-                throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Context GC checkpoint interval validation failed.');
             const plannedReplacements = normalizeContextGcReplacements(draft.replacements);
             if (!plannedReplacements || (plannedReplacements.length === 0 && !draft.inlineMedia))
                 throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Context GC checkpoint must contain a replacement.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.62",
+  "version": "0.11.63",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",

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

@@ -1,35 +0,0 @@
-import type { ModelUsage } from '../../model/contracts.js';
-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;
-    readonly contextWindowTokens: number;
-    readonly reclaimedTokens: number;
-    readonly reclaimedCachedTokens: number;
-    readonly cacheReadTokens: number;
-    readonly preservedCachedPrefixTokens: number;
-}
-export interface ContextGcEconomicsResult {
-    readonly cacheRebuildPenaltyCostUnits: number;
-    readonly requiredPositiveNetRollouts: number | null;
-    readonly expectedNetSavedCostUnits: number;
-    readonly grossReductionRate: number;
-    readonly passes: boolean;
-}
-export declare function evaluateContextGcEconomics(input: ContextGcEconomicsInput): ContextGcEconomicsResult;
-export declare function contextGcMinimumReclaimedTokens(contextWindowTokens: number): number;
-export declare function contextGcEligibleUsage(usage: ModelUsage, contextWindowTokens: number): number | undefined;
-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,93 +0,0 @@
-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,
-    minimumPaybackRollouts: 30,
-    maximumPaybackRollouts: 60,
-    contextGrowthSampleWindow: 16,
-    minimumContextGrowthSamples: 6,
-    minimumObservationRollouts: 1,
-    stageAProtectionRollouts: CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS,
-    largeExecProtectionRollouts: CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS,
-    normalInputCostRate: 1,
-    cacheReadCostRate: 0.05
-};
-const CONTEXT_GC_START_RATIO = 0.5;
-export const COMPACT_THRESHOLD_RATIO = AGENT_EXECUTION_POLICY.backgroundCompactionPercent / 100;
-export function evaluateContextGcEconomics(input) {
-    const reclaimedTokens = Math.max(0, input.reclaimedTokens);
-    const cacheReadTokens = Math.max(0, input.cacheReadTokens);
-    const preservedCachedPrefixTokens = clamp(input.preservedCachedPrefixTokens, 0, cacheReadTokens);
-    const invalidatedCachedSuffixTokens = cacheReadTokens - preservedCachedPrefixTokens;
-    const reclaimedCachedTokens = clamp(input.reclaimedCachedTokens, 0, invalidatedCachedSuffixTokens);
-    const invalidatedRetainedCachedTokens = Math.max(0, invalidatedCachedSuffixTokens - reclaimedCachedTokens);
-    // Calculate token-derived costs in cache-read units to keep exact zero exact.
-    const unitsPerNormalInput = CONTEXT_GC_POLICY.normalInputCostRate / CONTEXT_GC_POLICY.cacheReadCostRate;
-    const cacheRebuildPenalty = invalidatedRetainedCachedTokens * (unitsPerNormalInput - 1);
-    const cacheRebuildPenaltyCostUnits = cacheRebuildPenalty * CONTEXT_GC_POLICY.cacheReadCostRate;
-    const reclaimedUncachedTokens = Math.max(0, reclaimedTokens - reclaimedCachedTokens);
-    const firstRolloutSavings = reclaimedCachedTokens + reclaimedUncachedTokens * unitsPerNormalInput;
-    const steadyRolloutSavings = reclaimedTokens;
-    const netAt = (rollouts) => rollouts <= 0
-        ? -cacheRebuildPenalty
-        : firstRolloutSavings +
-            Math.max(0, rollouts - 1) * steadyRolloutSavings -
-            cacheRebuildPenalty;
-    let requiredPositiveNetRollouts;
-    if (netAt(1) > 0)
-        requiredPositiveNetRollouts = 1;
-    else if (steadyRolloutSavings <= 0)
-        requiredPositiveNetRollouts = null;
-    else {
-        requiredPositiveNetRollouts = Math.max(2, Math.floor(-netAt(1) / steadyRolloutSavings) + 2);
-        if (netAt(requiredPositiveNetRollouts - 1) > 0)
-            requiredPositiveNetRollouts--;
-        else if (netAt(requiredPositiveNetRollouts) <= 0)
-            requiredPositiveNetRollouts++;
-    }
-    const expectedNetSavedCostUnits = netAt(requiredPositiveNetRollouts ?? 0) * CONTEXT_GC_POLICY.cacheReadCostRate;
-    const grossReductionRate = reclaimedTokens / Math.max(1, Math.max(0, input.contextUsageTokens));
-    const minimumReclaimedTokens = contextGcMinimumReclaimedTokens(input.contextWindowTokens);
-    const usageRatio = input.contextUsageTokens / 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 {
-        cacheRebuildPenaltyCostUnits,
-        requiredPositiveNetRollouts,
-        expectedNetSavedCostUnits,
-        grossReductionRate,
-        passes
-    };
-}
-export function contextGcMinimumReclaimedTokens(contextWindowTokens) {
-    return Math.ceil(contextWindowTokens / 20);
-}
-export function contextGcEligibleUsage(usage, contextWindowTokens) {
-    const contextUsageTokens = modelContextUsage(usage);
-    if (contextUsageTokens === undefined ||
-        !Number.isSafeInteger(contextWindowTokens) ||
-        contextWindowTokens <= 0)
-        return undefined;
-    const usageRatio = contextUsageTokens / contextWindowTokens;
-    if (usageRatio < CONTEXT_GC_START_RATIO || usageRatio >= COMPACT_THRESHOLD_RATIO)
-        return undefined;
-    return contextUsageTokens;
-}
-export function modelContextUsage(value) {
-    const context = value.contextInputTokens ?? value.inputTokens;
-    return typeof context === 'number' && Number.isSafeInteger(context) && context >= 0
-        ? context
-        : undefined;
-}
-export function clamp(value, minimum, maximum) {
-    return Math.min(maximum, Math.max(minimum, value));
-}