@myagentroam/agent 0.11.61 → 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

@@ -9,6 +9,7 @@ import { readModelCatalog, writeModelCatalog } from './catalog-file.js';
 import { AgentError, createAgent, agentReasoningEffortSchema, resolveModelDefaultReasoningEffort, SecretValue, testAgentModelTransport } from '../index.js';
 import { CodexAuthFileCredentialProvider } from './codex-auth-file.js';
 import { generateSessionTitle } from '../shared/auto-title.js';
+import { TerminalInput, TerminalInputClosed } from './terminal-input.js';
 const HELP = `maragent - MAR coding agent
 
 Usage:
@@ -146,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,
@@ -261,21 +263,22 @@ async function main() {
     // `run` does not need stdin until a question occurs. Create
     // readline lazily so a closed or pseudo-TTY stream in an external harness
     // cannot fail the execution before its first model request.
-    let terminal;
-    const requireTerminal = () => (terminal ??= createInterface({ input: stdin, output: stdout }));
+    const terminal = new TerminalInput(() => createInterface({ input: stdin, output: stdout }));
     const host = new LocalAgentHost({
         homeDirectory: home,
         workspace,
-        question: async (request) => {
+        question: async (request, signal) => {
             if (!stdin.isTTY)
                 throw new AgentError('MAR_AGENT_USER_INPUT_UNAVAILABLE', 'Interactive input is unavailable.');
-            const answers = {};
-            for (const question of request.questions) {
-                const value = question;
-                const id = typeof value.id === 'string' ? value.id : String(Object.keys(answers).length);
-                answers[id] = await requireTerminal().question(`${typeof value.question === 'string' ? value.question : JSON.stringify(question)} `);
-            }
-            return answers;
+            return terminal.run(signal, async (ask) => {
+                const answers = {};
+                for (const question of request.questions) {
+                    const value = question;
+                    const id = typeof value.id === 'string' ? value.id : String(Object.keys(answers).length);
+                    answers[id] = await ask(`${typeof value.question === 'string' ? value.question : JSON.stringify(question)} `);
+                }
+                return answers;
+            });
         }
     });
     const runtime = runtimeModels(catalog.models, codexAuthFile);
@@ -311,7 +314,7 @@ async function main() {
             const listed = (await agent.listSessions());
             for (const item of listed.sessions ?? [])
                 stdout.write(`${item.id}\t${item.title}\t${item.lastActivityAt}\n`);
-            resumeId = (await requireTerminal().question('Session ID: ')).trim();
+            resumeId = (await terminal.run(undefined, (ask) => ask('Session ID: '))).trim();
             if (!resumeId)
                 throw new AgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', 'Session id is required.');
         }
@@ -329,7 +332,7 @@ async function main() {
             if (activeHandle)
                 activeHandle.cancel();
             else
-                terminal?.close();
+                terminal.close();
             titleController?.abort();
             process.exitCode = 130;
             if (interrupts > 1)
@@ -338,8 +341,16 @@ async function main() {
         process.on('SIGINT', interrupt);
         try {
             do {
-                if (interactive)
-                    prompt = await requireTerminal().question('> ');
+                if (interactive) {
+                    try {
+                        prompt = await terminal.run(undefined, (ask) => ask('> '));
+                    }
+                    catch (error) {
+                        if (error instanceof TerminalInputClosed)
+                            break;
+                        throw error;
+                    }
+                }
                 if (!prompt.trim())
                     break;
                 const invocation = parseExecutionInvocation(prompt);
@@ -409,7 +420,7 @@ async function main() {
         }
     }
     finally {
-        terminal?.close();
+        terminal.close();
         await agent.dispose();
     }
 }

package/dist/cli/subagent/control.js

@@ -49,7 +49,7 @@ export function registerControlTools(context, agent, observations, warmObservati
         name: 'agent_send',
         description: 'Send a message to a direct child or report to the direct parent.',
         allowedCallers: ['direct', 'programmatic'],
-        parallelSafety: 'serial',
+        parallelSafety: 'safe',
         inputSchema: {
             type: 'object',
             properties: {
@@ -70,7 +70,7 @@ export function registerControlTools(context, agent, observations, warmObservati
         name: 'agent_stop',
         description: 'Stop a direct child execution and wait for its cleanup.',
         allowedCallers: ['direct', 'programmatic'],
-        parallelSafety: 'serial',
+        parallelSafety: 'safe',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/cli/subagent/start.js

@@ -44,7 +44,7 @@ export function registerStart(context, agent, admission) {
         name: 'agent_start',
         description: 'Start a child Session and return its identity without waiting for completion.',
         allowedCallers: ['direct', 'programmatic'],
-        parallelSafety: 'serial',
+        parallelSafety: 'safe',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/cli/terminal-input.d.ts

@@ -0,0 +1,12 @@
+import { createInterface } from 'node:readline/promises';
+export declare class TerminalInputClosed extends Error {
+    constructor();
+}
+/** One interactive transaction at a time per terminal, including multi-question requests. */
+export declare class TerminalInput {
+    #private;
+    private readonly create;
+    constructor(create: () => ReturnType<typeof createInterface>);
+    run<T>(signal: AbortSignal | undefined, work: (ask: (prompt: string) => Promise<string>) => Promise<T>): Promise<T>;
+    close(): void;
+}

package/dist/cli/terminal-input.js

@@ -0,0 +1,86 @@
+export class TerminalInputClosed extends Error {
+    constructor() {
+        super('Terminal input is closed.');
+    }
+}
+/** One interactive transaction at a time per terminal, including multi-question requests. */
+export class TerminalInput {
+    create;
+    #terminal;
+    #tail = Promise.resolve();
+    #lines = [];
+    #waiter;
+    #closed = false;
+    constructor(create) {
+        this.create = create;
+    }
+    run(signal, work) {
+        const operation = this.#tail.then(async () => {
+            signal?.throwIfAborted();
+            return work((prompt) => this.#ask(prompt, signal));
+        });
+        this.#tail = operation.then(() => undefined, () => undefined);
+        if (!signal)
+            return operation;
+        return new Promise((resolve, reject) => {
+            const aborted = () => reject(signal.reason);
+            if (signal.aborted)
+                aborted();
+            else
+                signal.addEventListener('abort', aborted, { once: true });
+            operation.then(resolve, reject).finally(() => signal.removeEventListener('abort', aborted));
+        });
+    }
+    #ask(prompt, signal) {
+        signal?.throwIfAborted();
+        if (this.#closed) {
+            const line = this.#lines.shift();
+            return line === undefined ? Promise.reject(new TerminalInputClosed()) : Promise.resolve(line);
+        }
+        if (!this.#terminal) {
+            this.#terminal = this.create();
+            this.#terminal.on('line', (line) => {
+                const waiter = this.#waiter;
+                if (waiter) {
+                    this.#waiter = undefined;
+                    waiter.resolve(line);
+                }
+                else
+                    this.#lines.push(line);
+            });
+            this.#terminal.on('close', () => {
+                this.#closed = true;
+                const waiter = this.#waiter;
+                this.#waiter = undefined;
+                waiter?.reject(new TerminalInputClosed());
+            });
+        }
+        this.#terminal.setPrompt(prompt);
+        this.#terminal.prompt();
+        const line = this.#lines.shift();
+        if (line !== undefined)
+            return Promise.resolve(line);
+        return new Promise((resolve, reject) => {
+            const finish = (callback) => {
+                signal?.removeEventListener('abort', abort);
+                callback();
+            };
+            const abort = () => {
+                this.#waiter = undefined;
+                finish(() => reject(signal.reason));
+            };
+            this.#waiter = {
+                resolve: (value) => finish(() => resolve(value)),
+                reject: (error) => finish(() => reject(error))
+            };
+            signal?.addEventListener('abort', abort, { once: true });
+            if (signal?.aborted)
+                abort();
+        });
+    }
+    close() {
+        this.#closed = true;
+        this.#lines = [];
+        this.#terminal?.close();
+    }
+}

package/dist/host/local-tool-registry.js

@@ -71,8 +71,8 @@ export class LocalToolRegistry {
             ],
             [
                 'apply_patch',
-                async (arguments_) => {
-                    const result = await patch.execute(applyPatchToolInput(arguments_));
+                async (arguments_, context) => {
+                    const result = await patch.execute(applyPatchToolInput(arguments_), context.signal);
                     return { content: JSON.stringify(result), data: result };
                 }
             ],

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;