@myagentroam/agent 0.11.61 → 0.11.63

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/dist/tools/agent/question.js

@@ -4,7 +4,7 @@ import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const questionToolDefinition = {
     name: 'question',
     allowedCallers: ['direct'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: 'Pause for one to three tightly related user-owned decisions that materially change the result and cannot be inferred from the request, conversation, or relevant safe discovery. Prefer asking over guessing in Plan mode; do not avoid clarification by inventing configuration, branches, abstractions, or support for multiple outcomes. Provide 2-3 mutually exclusive options with consequences, put the recommended option first and identify it in its label or description, and use another question round if key ambiguity remains. This is not a permission/approval tool and should not interrupt routine in-scope work.',
     inputSchema: {
         type: 'object',

package/dist/tools/agent/sleep.js

@@ -4,7 +4,7 @@ import { waitForToolCondition } from '../wait.js';
 export const sleepToolDefinition = {
     name: 'sleep',
     allowedCallers: ['direct'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: 'Pause for up to durationMs milliseconds. Returns early when user input or a new public subagent message is available. Returns elapsed time and the wake reason.',
     inputSchema: {
         type: 'object',

package/dist/tools/agent/todo-write.js

@@ -3,7 +3,7 @@ import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const todoWriteToolDefinition = {
     name: 'todo_write',
     allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: 'Replace this session’s entire Todo list with the supplied items; no prior read is required. Preserve stable IDs and statuses only when extending the same objective. For a materially different objective, include only the new objective’s items. Do not retain completed items from an earlier objective; when all current items are completed, default a substantive new request to replacement unless the user explicitly asks to continue, extend, verify, or follow up. Use only after Todo has been chosen for coordination-heavy work; straightforward bounded work does not need it. Keep at most one in_progress item and update statuses after meaningful stage changes. When another substantive tool call is already ready and does not depend on the Todo result, include both in the same model response instead of spending a response only for Todo bookkeeping.',
     inputSchema: {
         type: 'object',

package/dist/tools/code-mode/index.js

@@ -78,7 +78,7 @@ observe.result(patched);
         additionalProperties: false
     },
     allowedCallers: ['direct'],
-    parallelSafety: 'serial'
+    parallelSafety: 'safe'
 };
 export const codeExecWaitToolDefinition = {
     name: 'code_exec_wait',

package/dist/tools/contracts.d.ts

@@ -13,6 +13,7 @@ export interface ClientToolDefinition extends ModelToolDefinition {
     eventInputFields?: readonly string[];
     /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
     codeModeExposure?: 'both';
+    /** Runtime-only scheduling policy; defaults to safe. Serial calls are exclusive barriers. */
     parallelSafety?: 'safe' | 'serial';
     /** Preserved business-schema eligibility after framework metadata projection. */
     parameterless?: boolean;

package/dist/tools/local/apply-patch.d.ts

@@ -15,5 +15,5 @@ export declare class ApplyPatchTool {
     #private;
     private readonly paths;
     constructor(paths: WorkspacePathResolver, operations?: Partial<PatchFileOperations>);
-    execute(patch: string): Promise<ApplyPatchResult>;
+    execute(patch: string, signal?: AbortSignal): Promise<ApplyPatchResult>;
 }

package/dist/tools/local/apply-patch.js

@@ -10,7 +10,7 @@ export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
     codeModeExposure: 'both',
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch, each marker on its own line. Surrounding marker whitespace and an optional trailing *** are accepted; incomplete markers or extra text are rejected. Add File content lines, including blank lines, must start with +. Syntax errors include line/column and a bounded excerpt of the submitted patch with a caret at the error. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>. Context-only hunks, including trailing hunks, and unchanged file sections are validated in order but are not written or reported as edits. The patch must include a change or move. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',
     outputSchema: {
@@ -67,11 +67,20 @@ const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
 export class ApplyPatchTool {
     paths;
     #fileOperations;
+    #tail = Promise.resolve();
     constructor(paths, operations = {}) {
         this.paths = paths;
         this.#fileOperations = { ...defaultFileOperations, ...operations };
     }
-    async execute(patch) {
+    execute(patch, signal) {
+        const result = this.#tail.then(() => {
+            signal?.throwIfAborted();
+            return this.#apply(patch);
+        });
+        this.#tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async #apply(patch) {
         const changes = parsePatch(patch);
         reserveFileChangePaths(changes.flatMap((change) => change.kind === 'update' && change.targetPath
             ? [change.path, change.targetPath]

package/dist/tools/mcp/tool-search.js

@@ -25,7 +25,7 @@ export const toolSearchToolDefinition = {
         additionalProperties: false
     },
     allowedCallers: ['direct'],
-    parallelSafety: 'serial',
+    parallelSafety: 'safe',
     nativeType: 'tool_search'
 };
 export function parseToolSearchInput(input) {

package/dist/tools/scheduler.js

@@ -35,7 +35,7 @@ export function createSessionToolScheduler() {
         const inherited = leases.getStore();
         const parent = inherited?.ingress === sessionToolIngress.getStore() ? inherited : undefined;
         const result = (parent?.active ? parent.schedule : root)({
-            name: definition?.parallelSafety === 'safe' ? 'safe' : 'serial',
+            name: definition?.parallelSafety === 'serial' ? 'serial' : 'safe',
             run
         });
         if (parent?.active) {
@@ -52,7 +52,7 @@ export function createToolCallScheduler(definitions, execute) {
     let barrier = Promise.resolve();
     const readers = new Set();
     return (call) => {
-        const safe = safety.get(call.name) === 'safe';
+        const safe = safety.get(call.name) !== 'serial';
         const gate = safe ? barrier : Promise.all([barrier, ...readers]).then(() => undefined);
         const result = gate.then(() => execute(call));
         const settled = result.then(() => undefined, () => undefined);
@@ -72,13 +72,13 @@ export async function scheduleToolCallBatch(calls, definitions, execute) {
     const results = new Array(calls.length);
     let index = 0;
     while (index < calls.length) {
-        if (safety.get(calls[index].name) !== 'safe') {
+        if (safety.get(calls[index].name) === 'serial') {
             results[index] = await execute(calls[index]);
             index++;
             continue;
         }
         let end = index + 1;
-        while (end < calls.length && safety.get(calls[end].name) === 'safe')
+        while (end < calls.length && safety.get(calls[end].name) !== 'serial')
             end++;
         const segment = await Promise.all(calls.slice(index, end).map((call) => execute(call)));
         for (let segmentIndex = 0; segmentIndex < segment.length; segmentIndex++)

package/package.json

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