@myagentroam/agent 0.10.59 → 0.10.60

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

@@ -1,4 +1,3 @@
-import { createHash } from 'node:crypto';
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { codeCallEvidence, codePartialPatchCallEvidence, callsFromRecord, codeObservationEvidence, observationsFromRecord, retainedCodeInputs } from './context-gc-observations.js';
@@ -10,7 +9,7 @@ export const CONTEXT_GC_MAX_TARGETS = 4_096;
 /** Disposable memoization for one evaluation's immutable record snapshot. */
 export class ContextGcCheckpointCache {
     #snapshot;
-    read(records, boundarySequence = records.at(-1)?.sequence ?? 0, workspace = sessionWorkspace(records)) {
+    read(records, boundarySequence = records.at(-1)?.sequence ?? 0, workspace) {
         const cached = this.#snapshot;
         if (cached?.records === records &&
             cached.boundarySequence === boundarySequence &&
@@ -24,18 +23,6 @@ export class ContextGcCheckpointCache {
 export function contextGcMinimumUsageGrowth(contextWindowTokens) {
     return Math.max(2_000, Math.floor(contextWindowTokens * 0.05));
 }
-const PROJECTION_RECORD_TYPES = new Set([
-    'compact.completed',
-    'context.environment',
-    'execution.header',
-    'message.completed',
-    'model.context',
-    'plan.completed',
-    'turn.user'
-]);
-export function contextGcRecordSourceHash(record) {
-    return createHash('sha256').update(stableJson(record.payload)).digest('hex');
-}
 export function contextGcLogicalPathKey(path, workspace, platform) {
     if (!path || !workspace || path.includes('\0') || workspace.includes('\0'))
         return undefined;
@@ -76,32 +63,34 @@ export function contextGcBaseFromRecords(records, boundarySequence = records.at(
 export function contextGcBaseSequence(base) {
     return base.type === 'COMPACT' ? base.sequence : base.firstSequence;
 }
-export function contextGcSourceProjectionHash(records, boundarySequence, base = contextGcBaseFromRecords(records, boundarySequence)) {
-    if (!base || !isValidBoundary(boundarySequence))
-        return undefined;
-    const baseSequence = contextGcBaseSequence(base);
-    if (!sameContextGcBase(base, contextGcBaseFromRecords(records, boundarySequence)))
-        return undefined;
-    const source = records
-        .filter((record) => record.sequence >= baseSequence &&
-        record.sequence <= boundarySequence &&
-        PROJECTION_RECORD_TYPES.has(record.type))
-        .map((record) => ({
-        sequence: record.sequence,
-        recordId: record.recordId,
-        type: record.type,
-        payload: record.payload
-    }));
-    return createHash('sha256').update(stableJson(source)).digest('hex');
-}
 export function normalizeContextGcReplacements(replacements) {
     const normalized = new Map();
+    const readItems = new Map();
     for (const replacement of replacements) {
         if (!isContextGcReplacement(replacement))
             return undefined;
-        normalized.set(contextGcReplacementKey(replacement), structuredClone(replacement));
+        const value = structuredClone(replacement);
+        const key = contextGcReplacementKey(value);
+        if (value.kind === 'READ_OUTPUT_ITEMS') {
+            const items = normalized.get(key)?.kind === 'READ_OUTPUT_ITEMS'
+                ? readItems.get(key)
+                : new Map();
+            for (const item of value.items)
+                items.set(item.index, item);
+            readItems.set(key, items);
+        }
+        normalized.set(key, value);
     }
-    const values = [...normalized.values()];
+    const values = [...normalized].map(([key, value]) => {
+        if (value.kind !== 'READ_OUTPUT_ITEMS')
+            return value;
+        const items = [...readItems.get(key).values()];
+        return {
+            ...value,
+            items,
+            evidenceSequences: [...new Set(items.map((item) => item.evidenceSequence))]
+        };
+    });
     const targets = new Set(values.flatMap((replacement) => [
         contextGcTargetKey(replacement.target),
         ...(replacement.kind === 'TOOL_CALL_INPUT'
@@ -122,7 +111,6 @@ export function parseContextGcCheckpoint(record) {
         !isPositiveInteger(payload.generation) ||
         !isContextGcBase(payload.base) ||
         !isPositiveInteger(payload.boundarySequence) ||
-        !isSha256(payload.sourceProjectionHash) ||
         !Array.isArray(payload.replacements) ||
         payload.replacements.length === 0 ||
         !isContextGcTrigger(payload.trigger) ||
@@ -138,14 +126,13 @@ export function parseContextGcCheckpoint(record) {
         generation: payload.generation,
         base: structuredClone(payload.base),
         boundarySequence: payload.boundarySequence,
-        sourceProjectionHash: payload.sourceProjectionHash,
         replacements,
         trigger: structuredClone(payload.trigger),
         economics: structuredClone(payload.economics),
         metrics: structuredClone(payload.metrics)
     };
 }
-export function validateContextGcCheckpoint(records, record, workspace = sessionWorkspace(records)) {
+export function validateContextGcCheckpoint(records, record, workspace = sessionWorkspace(records), committedReplacements = []) {
     const payload = parseContextGcCheckpoint(record);
     if (!payload || payload.boundarySequence >= record.sequence)
         return undefined;
@@ -153,28 +140,45 @@ export function validateContextGcCheckpoint(records, record, workspace = session
     if (!sameContextGcBase(payload.base, base))
         return undefined;
     const baseSequence = contextGcBaseSequence(payload.base);
-    if (contextGcSourceProjectionHash(records, payload.boundarySequence, payload.base) !==
-        payload.sourceProjectionHash)
-        return undefined;
     // Later cell completion cannot retroactively authorize an earlier checkpoint.
     records = records.filter((item) => item.sequence <= payload.boundarySequence);
     const recordsBySequence = new Map(records.map((item) => [item.sequence, item]));
     if (!triggerMatchesRecords(records, recordsBySequence, payload))
         return undefined;
+    const committed = new Map(committedReplacements.map((replacement) => [contextGcReplacementKey(replacement), replacement]));
+    const changed = payload.replacements.flatMap((replacement) => {
+        const previous = committed.get(contextGcReplacementKey(replacement));
+        if (isDeepStrictEqual(previous, replacement))
+            return [];
+        if (previous?.kind === 'READ_OUTPUT_ITEMS' && replacement.kind === 'READ_OUTPUT_ITEMS') {
+            const retained = new Map(previous.items.map((item) => [item.index, item]));
+            const items = replacement.items.filter((item) => !isDeepStrictEqual(retained.get(item.index), item));
+            if (items.length > 0)
+                return [
+                    {
+                        ...replacement,
+                        items,
+                        evidenceSequences: [...new Set(items.map((item) => item.evidenceSequence))]
+                    }
+                ];
+        }
+        return [replacement];
+    });
     const targets = payload.replacements.flatMap((replacement) => [
         replacement.target,
         ...(replacement.kind === 'TOOL_CALL_INPUT' ? replacement.providerAliasTargets : [])
     ]);
     if (new Set(targets.map(contextGcTargetKey)).size !== targets.length)
         return undefined;
-    for (const target of targets) {
-        const source = recordsBySequence.get(target.sequence);
-        if (!source ||
-            source.sequence > payload.boundarySequence ||
-            !targetMatchesRecord(target, source))
-            return undefined;
-    }
-    for (const replacement of payload.replacements) {
+    for (const replacement of changed) {
+        for (const target of [
+            replacement.target,
+            ...(replacement.kind === 'TOOL_CALL_INPUT' ? replacement.providerAliasTargets : [])
+        ]) {
+            const source = recordsBySequence.get(target.sequence);
+            if (!source || !targetMatchesRecord(target, source))
+                return undefined;
+        }
         const evidence = replacement.kind === 'READ_OUTPUT_ITEMS'
             ? replacement.evidenceSequences
             : [
@@ -194,18 +198,23 @@ export function validateContextGcCheckpoint(records, record, workspace = session
     }
     return payload;
 }
-export function latestValidContextGcCheckpoint(records, boundarySequence = records.at(-1)?.sequence ?? 0, workspace = sessionWorkspace(records)) {
+export function latestValidContextGcCheckpoint(records, boundarySequence = records.at(-1)?.sequence ?? 0, _workspace) {
     const base = contextGcBaseFromRecords(records, boundarySequence);
     if (!base)
         return undefined;
-    const candidates = records
-        .filter((record) => record.sequence <= boundarySequence &&
-        record.sequence >= contextGcBaseSequence(base) &&
-        record.type === 'context.gc.completed')
-        .toReversed();
-    for (const record of candidates) {
-        const payload = validateContextGcCheckpoint(records, record, workspace);
-        if (payload && sameContextGcBase(payload.base, base))
+    const baseSequence = contextGcBaseSequence(base);
+    // Committed local checkpoints are trusted; historical evidence is checked at commit only.
+    for (let index = records.length - 1; index >= 0; index--) {
+        const record = records[index];
+        if (record.sequence < baseSequence)
+            break;
+        if (record.sequence > boundarySequence || record.type !== 'context.gc.completed')
+            continue;
+        const payload = parseContextGcCheckpoint(record);
+        if (payload &&
+            payload.boundarySequence >= baseSequence &&
+            payload.boundarySequence < record.sequence &&
+            sameContextGcBase(payload.base, base))
             return { record, payload };
     }
     return undefined;
@@ -222,7 +231,6 @@ export function sameContextGcBase(left, right) {
 function targetMatchesRecord(target, record) {
     if (record.type !== 'model.context' ||
         record.recordId !== target.recordId ||
-        contextGcRecordSourceHash(record) !== target.sourceHash ||
         !isRecord(record.payload) ||
         record.payload.role !== target.role)
         return false;
@@ -283,10 +291,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
                     contextGcStaleReadReplacement({
                         path: item.path,
                         content: original.content,
-                        evidenceSequence: item.evidenceSequence,
-                        supersededByCallId: evidence.callId,
-                        operation: evidence.file.operation,
-                        formatVersion: staleReadReplacementFormatVersion(item.replacement)
+                        operation: evidence.file.operation
                     }));
         });
     }
@@ -296,7 +301,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
         return (evidence?.callId === replacement.callId &&
             evidence.call.sequence === replacement.target.sequence &&
             result !== undefined &&
-            isDeepStrictEqual(replacement.replacementArguments, contextGcApplyPatchInputReplacement(source.payload.arguments, result, replacement.evidenceSequence, applyPatchReplacementFormatVersion(replacement.replacementArguments))));
+            isDeepStrictEqual(replacement.replacementArguments, contextGcApplyPatchInputReplacement(source.payload.arguments, result)));
     }
     if (replacement.kind === 'TOOL_CALL_INPUT' && replacement.toolName === 'code_exec') {
         const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, replacement.toolName);
@@ -363,10 +368,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
                 contextGcSubagentOutputReplacement({
                     sourceContent: sourceEvidence.result.payload.content,
                     source: sourceSnapshot,
-                    terminal: terminalSnapshot,
-                    terminalCallId: replacement.terminalCallId,
-                    evidenceSequence: replacement.evidenceSequence,
-                    formatVersion: subagentReplacementFormatVersion(replacement.replacementContent)
+                    terminal: terminalSnapshot
                 }));
     }
     if (replacement.kind === 'WEB_OUTPUT') {
@@ -387,50 +389,12 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
     if (!isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence))
         return false;
     if (replacement.kind === 'TOOL_CALL_INPUT')
-        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, execInputReplacementFormatVersion(replacement.replacementArguments), replacement.toolName));
+        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, replacement.toolName));
     const targetEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec', replacement.callId) ??
         successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec_wait', replacement.callId);
     const result = normalizeContextGcExecResult(source.payload.content, targetEvidence?.completed.payload);
     return (result !== undefined &&
-        replacement.replacementContent ===
-            contextGcExecOutputReplacement(result, execOutputReplacementFormatVersion(replacement.replacementContent)));
-}
-function staleReadReplacementFormatVersion(value) {
-    return value.includes(' formatVersion="2"') ? 2 : 1;
-}
-function applyPatchReplacementFormatVersion(value) {
-    return typeof value === 'string' && value.includes(' formatVersion="2"') ? 2 : 1;
-}
-function subagentReplacementFormatVersion(value) {
-    try {
-        const parsed = JSON.parse(value);
-        return isRecord(parsed) && isRecord(parsed.contextGc) && parsed.contextGc.formatVersion === 2
-            ? 2
-            : 1;
-    }
-    catch {
-        return 1;
-    }
-}
-function execInputReplacementFormatVersion(value) {
-    if (typeof value === 'string' && value.includes(' formatVersion="3"'))
-        return 3;
-    if (!isRecord(value) || !isRecord(value.contextGc))
-        return 1;
-    return value.contextGc.formatVersion === 3 ? 3 : value.contextGc.formatVersion === 2 ? 2 : 1;
-}
-function execOutputReplacementFormatVersion(value) {
-    try {
-        const parsed = JSON.parse(value);
-        return isRecord(parsed) && parsed.contextGcFormatVersion === 3
-            ? 3
-            : isRecord(parsed) && parsed.contextGcFormatVersion === 2
-                ? 2
-                : 1;
-    }
-    catch {
-        return 1;
-    }
+        replacement.replacementContent === contextGcExecOutputReplacement(result));
 }
 function toolNameForCallId(records, callId, beforeSequence) {
     const call = modelToolCallForCallId(records, callId, beforeSequence);
@@ -713,7 +677,7 @@ function isContextGcReplacement(value) {
     if (value.kind === 'READ_OUTPUT_ITEMS') {
         const items = value.items;
         const evidenceSequences = value.evidenceSequences;
-        return (hasOnlyKeys(value, ['kind', 'callId', 'target', 'items', 'evidenceSequences']) &&
+        if (!(hasOnlyKeys(value, ['kind', 'callId', 'target', 'items', 'evidenceSequences']) &&
             value.target.role === 'tool' &&
             Array.isArray(items) &&
             items.length > 0 &&
@@ -732,11 +696,14 @@ function isContextGcReplacement(value) {
                 isPositiveInteger(item.evidenceSequence)) &&
             Array.isArray(evidenceSequences) &&
             evidenceSequences.length > 0 &&
-            evidenceSequences.every(isPositiveInteger) &&
-            new Set(items.map((item) => item.index)).size === items.length &&
-            new Set(evidenceSequences).size === evidenceSequences.length &&
-            items.every((item) => evidenceSequences.includes(item.evidenceSequence)) &&
-            evidenceSequences.every((sequence) => items.some((item) => item.evidenceSequence === sequence)));
+            evidenceSequences.every(isPositiveInteger)))
+            return false;
+        const evidence = new Set(evidenceSequences);
+        const usedEvidence = new Set(items.map((item) => item.evidenceSequence));
+        return (new Set(items.map((item) => item.index)).size === items.length &&
+            evidence.size === evidenceSequences.length &&
+            usedEvidence.size === evidence.size &&
+            evidenceSequences.every((sequence) => usedEvidence.has(sequence)));
     }
     if (value.kind === 'TOOL_CALL_INPUT')
         return (hasOnlyKeys(value, [
@@ -829,23 +796,14 @@ function isContextGcReplacement(value) {
 }
 function isContextGcTarget(value) {
     return (isRecord(value) &&
-        hasOnlyKeys(value, [
-            'sequence',
-            'recordId',
-            'role',
-            'callId',
-            'toolName',
-            'sourceHash',
-            'observationId'
-        ]) &&
+        hasOnlyKeys(value, ['sequence', 'recordId', 'role', 'callId', 'toolName', 'observationId']) &&
         (value.observationId === undefined ||
             (value.role === 'tool' && isNonemptyString(value.observationId))) &&
         isPositiveInteger(value.sequence) &&
         isNonemptyString(value.recordId) &&
         (value.role === 'tool_call' || value.role === 'tool' || value.role === 'provider') &&
         (value.callId === undefined || isNonemptyString(value.callId)) &&
-        (value.toolName === undefined || isNonemptyString(value.toolName)) &&
-        isSha256(value.sourceHash));
+        (value.toolName === undefined || isNonemptyString(value.toolName)));
 }
 function isContextGcBase(value) {
     return (isRecord(value) &&
@@ -928,9 +886,6 @@ function hasOnlyKeys(value, keys) {
 function isNonemptyString(value) {
     return typeof value === 'string' && value.length > 0;
 }
-function isSha256(value) {
-    return typeof value === 'string' && /^[a-f0-9]{64}$/u.test(value);
-}
 function isPositiveInteger(value) {
     return Number.isSafeInteger(value) && Number(value) > 0;
 }
@@ -943,13 +898,3 @@ function isNonnegativeFinite(value) {
 function isValidBoundary(value) {
     return Number.isSafeInteger(value) && value > 0;
 }
-function stableJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(stableJson).join(',')}]`;
-    if (value !== null && typeof value === 'object')
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
-            .join(',')}}`;
-    return JSON.stringify(value) ?? 'undefined';
-}

package/dist/agent-core/session/context-gc-observations.d.ts

@@ -1,4 +1,4 @@
-import type { SessionRecord } from './jsonl-store.js';
+import type { SessionRecord } from './store/index.js';
 import { type CodeObservation, type CodeToolCallRecord } from '../tools/code-mode/observations.js';
 /** Resolve private observation identity to real dispatch facts, not Provider tool calls. */
 export declare function codeObservationEvidence(records: readonly SessionRecord[], result: SessionRecord, observation: Extract<CodeObservation, {

package/dist/agent-core/session/context-gc-replacements.d.ts

@@ -47,19 +47,16 @@ export type ContextGcExecResult = {
 };
 export declare function contextGcPatchResultFromCompletedPayload(payload: unknown): ContextGcPatchResult | undefined;
 export declare function contextGcPatchResultFromFailedPayload(payload: unknown): ContextGcPatchResult | undefined;
-export declare function contextGcApplyPatchInputReplacement(arguments_: unknown, result: ContextGcPatchResult, evidenceSequence: number, formatVersion?: 1 | 2): string;
+export declare function contextGcApplyPatchInputReplacement(arguments_: unknown, result: ContextGcPatchResult): string;
 export declare function contextGcStaleReadReplacement(input: {
     readonly path: string;
     readonly content: string;
-    readonly evidenceSequence: number;
-    readonly supersededByCallId: string;
     readonly operation: Exclude<ContextGcPatchFile['operation'], 'added'>;
-    readonly formatVersion?: 1 | 2;
 }): string;
 export declare function contextGcWebOutputReplacement(toolName: ContextGcWebToolName, originalContent: string, truncated: boolean): string;
-export declare function contextGcExecInputReplacement(arguments_: unknown, formatVersion?: 1 | 2 | 3, toolName?: string): unknown;
-export declare function contextGcExecOutputReplacement(result: ContextGcExecResult, formatVersion?: 1 | 2 | 3): string;
+export declare function contextGcExecInputReplacement(arguments_: unknown, toolName?: string): unknown;
+export declare function contextGcExecOutputReplacement(result: ContextGcExecResult): string;
 export declare function normalizeContextGcExecResult(modelContent: unknown, completedPayload: unknown): ContextGcExecResult | undefined;
 export declare function parseContextGcExecResult(value: unknown): ContextGcExecResult | undefined;
 /** A returned tool wait is not proof that its retained JavaScript cell finished. */
-export declare function codeCellCompletionSequence(records: readonly import('./jsonl-store.js').SessionRecord[], completed: import('./jsonl-store.js').SessionRecord): number | undefined;
+export declare function codeCellCompletionSequence(records: readonly import('./store/index.js').SessionRecord[], completed: import('./store/index.js').SessionRecord): number | undefined;

package/dist/agent-core/session/context-gc-replacements.js

@@ -1,5 +1,4 @@
 import { contextGcMarkup } from './context-gc-markup.js';
-import { createHash } from 'node:crypto';
 import { parseApplyPatchResult, parseApplyPatchPartialResult } from '../tools/shared/patch-result.js';
 const RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS = 256;
 const EXEC_INPUT_COMPLETE_CHARACTERS = 512;
@@ -51,31 +50,22 @@ export function contextGcPatchResultFromFailedPayload(payload) {
         return undefined;
     return parseApplyPatchPartialResult(payload.data);
 }
-export function contextGcApplyPatchInputReplacement(arguments_, result, evidenceSequence, formatVersion = 2) {
+export function contextGcApplyPatchInputReplacement(arguments_, result) {
     const original = typeof arguments_ === 'string' ? arguments_ : stableJson(arguments_);
     const summary = result.files
         .map((file) => `${file.operation} ${file.path}${file.targetPath ? ` -> ${file.targetPath}` : ''} (+${file.addedLines}/-${file.deletedLines})`)
         .join('; ');
     return contextGcMarkup('successful_apply_patch_input', {
-        ...(formatVersion === 2 ? { formatVersion: 2 } : {}),
+        formatVersion: 2,
         originalBytes: Buffer.byteLength(original),
-        ...(formatVersion === 1 ? { originalSha256: sha256(original), evidenceSequence } : {}),
         contextGc: `Applied successfully: ${summary}. Totals: ${result.totals.files} files, +${result.totals.addedLines}/-${result.totals.deletedLines}. The original patch body was reclaimed.`
     });
 }
 export function contextGcStaleReadReplacement(input) {
-    const formatVersion = input.formatVersion ?? 2;
     return contextGcMarkup('stale_read', {
         path: input.path,
-        ...(formatVersion === 2 ? { formatVersion: 2 } : {}),
+        formatVersion: 2,
         originalBytes: Buffer.byteLength(input.content),
-        ...(formatVersion === 1
-            ? {
-                originalSha256: sha256(input.content),
-                supersededByCallId: input.supersededByCallId,
-                evidenceSequence: input.evidenceSequence
-            }
-            : {}),
         operation: input.operation,
         contextGc: 'This read predates a successful apply_patch. Re-read the path before relying on its contents.'
     });
@@ -92,12 +82,11 @@ export function contextGcWebOutputReplacement(toolName, originalContent, truncat
         contextGc: 'Detailed web tool output was reclaimed after six successful rollouts. An incomplete preview is not the complete search result or page, and GC did not access the network.'
     });
 }
-export function contextGcExecInputReplacement(arguments_, formatVersion = 3, toolName = 'exec') {
+export function contextGcExecInputReplacement(arguments_, toolName = 'exec') {
     if (!isRecord(arguments_))
         return contextGcMarkup('terminal_exec_input', {
-            ...(formatVersion === 3 ? { formatVersion: 3 } : {}),
-            originalBytes: Buffer.byteLength(stableJson(arguments_)),
-            ...(formatVersion === 3 ? {} : { originalSha256: sha256(stableJson(arguments_)) })
+            formatVersion: 3,
+            originalBytes: Buffer.byteLength(stableJson(arguments_))
         });
     const action = typeof arguments_.action === 'string'
         ? arguments_.action
@@ -111,21 +100,20 @@ export function contextGcExecInputReplacement(arguments_, formatVersion = 3, too
         action,
         contextGc: {
             kind: 'terminal_exec_input',
-            ...(formatVersion >= 2 ? { formatVersion } : {}),
-            originalBytes: Buffer.byteLength(original),
-            ...(formatVersion <= 2 ? { originalSha256: sha256(original) } : {})
+            formatVersion: 3,
+            originalBytes: Buffer.byteLength(original)
         }
     };
     for (const key of ['cwd', 'processId', 'timeoutMs', 'yieldMs'])
         if (arguments_[key] !== undefined)
             retained[key] = arguments_[key];
     if (typeof arguments_.command === 'string')
-        retainExecText(retained, 'command', arguments_.command, formatVersion);
+        retainExecText(retained, 'command', arguments_.command);
     if (typeof arguments_.data === 'string')
-        retainExecText(retained, 'data', arguments_.data, formatVersion);
+        retainExecText(retained, 'data', arguments_.data);
     return retained;
 }
-export function contextGcExecOutputReplacement(result, formatVersion = 3) {
+export function contextGcExecOutputReplacement(result) {
     if (result.source === 'MODEL_CONTEXT_TRUNCATED')
         return JSON.stringify({
             status: result.status,
@@ -139,8 +127,7 @@ export function contextGcExecOutputReplacement(result, formatVersion = 3) {
             modelContextTruncated: true,
             modelContextBytes: Buffer.byteLength(result.modelContextContent),
             modelContextPreview: unicodeHeadTail(result.modelContextContent, RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS),
-            ...(formatVersion >= 2 ? { contextGcFormatVersion: formatVersion } : {}),
-            ...(formatVersion <= 2 ? { modelContextSha256: sha256(result.modelContextContent) } : {}),
+            contextGcFormatVersion: 3,
             contextGc: 'The model-visible terminal result was truncated after execution and is no longer valid JSON. Detailed terminal input/output was reclaimed after the process reached a stable terminal state. Re-run the command if full output is required.'
         });
     const stdout = result.stdout;
@@ -156,32 +143,20 @@ export function contextGcExecOutputReplacement(result, formatVersion = 3) {
         stderrBytes: nonnegativeNumber(result.stderrBytes) ?? Buffer.byteLength(stderr),
         stdoutDroppedBytes: nonnegativeNumber(result.stdoutDroppedBytes) ?? 0,
         stderrDroppedBytes: nonnegativeNumber(result.stderrDroppedBytes) ?? 0,
-        ...(formatVersion <= 2
-            ? {
-                stdoutSha256: sha256(stdout),
-                stderrSha256: sha256(stderr)
-            }
-            : {}),
         stdoutPreview,
         stderrPreview,
-        ...(formatVersion >= 2
-            ? {
-                stdoutLines: lineCount(stdout),
-                stderrLines: lineCount(stderr),
-                stdoutPreviewComplete: result.truncated === false &&
-                    result.stdoutDroppedBytes === 0 &&
-                    result.stdoutBytes === Buffer.byteLength(stdout) &&
-                    stdoutPreview === stdout,
-                stderrPreviewComplete: result.truncated === false &&
-                    result.stderrDroppedBytes === 0 &&
-                    result.stderrBytes === Buffer.byteLength(stderr) &&
-                    stderrPreview === stderr,
-                contextGcFormatVersion: formatVersion
-            }
-            : {}),
-        contextGc: formatVersion >= 2
-            ? 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. An incomplete preview is not the complete result. Re-run the command if full output is required.'
-            : 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. Re-run the command if full output is required.'
+        stdoutLines: lineCount(stdout),
+        stderrLines: lineCount(stderr),
+        stdoutPreviewComplete: result.truncated === false &&
+            result.stdoutDroppedBytes === 0 &&
+            result.stdoutBytes === Buffer.byteLength(stdout) &&
+            stdoutPreview === stdout,
+        stderrPreviewComplete: result.truncated === false &&
+            result.stderrDroppedBytes === 0 &&
+            result.stderrBytes === Buffer.byteLength(stderr) &&
+            stderrPreview === stderr,
+        contextGcFormatVersion: 3,
+        contextGc: 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. An incomplete preview is not the complete result. Re-run the command if full output is required.'
     });
 }
 export function normalizeContextGcExecResult(modelContent, completedPayload) {
@@ -277,19 +252,13 @@ function unicodeHeadTail(value, count) {
         .slice(-count)
         .join('')}`;
 }
-function retainExecText(retained, key, value, formatVersion) {
-    if (formatVersion === 1) {
-        retained[`${key}Prefix`] = [...value].slice(0, EXEC_INPUT_PREVIEW_CHARACTERS).join('');
-        return;
-    }
+function retainExecText(retained, key, value) {
     if ([...value].length <= EXEC_INPUT_COMPLETE_CHARACTERS) {
         retained[key] = value;
         return;
     }
     retained[`${key}Preview`] = unicodeHeadTail(value, EXEC_INPUT_PREVIEW_CHARACTERS);
     retained[`${key}Bytes`] = Buffer.byteLength(value);
-    if (formatVersion === 2)
-        retained[`${key}Sha256`] = sha256(value);
 }
 function lineCount(value) {
     return value.length === 0 ? 0 : value.split('\n').length;
@@ -297,9 +266,6 @@ function lineCount(value) {
 function nonnegativeNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
-function sha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
 function stableJson(value) {
     if (Array.isArray(value))
         return `[${value.map(stableJson).join(',')}]`;

package/dist/agent-core/session/context-gc-subagent.d.ts

@@ -50,7 +50,4 @@ export declare function contextGcSubagentOutputReplacement(input: {
     readonly sourceContent: string;
     readonly source: ContextGcSubagentSnapshot;
     readonly terminal: ContextGcSubagentSnapshot;
-    readonly terminalCallId: string;
-    readonly evidenceSequence: number;
-    readonly formatVersion?: 1 | 2;
 }): string;

package/dist/agent-core/session/context-gc-subagent.js

@@ -1,4 +1,3 @@
-import { createHash } from 'node:crypto';
 export function normalizeContextGcSubagentSnapshot(modelContent, completedPayload, toolName) {
     if (typeof modelContent !== 'string' ||
         !isRecord(completedPayload) ||
@@ -92,7 +91,6 @@ export function contextGcSubagentSnapshotIsPreciselyCovered(source, retained) {
 }
 export function contextGcSubagentOutputReplacement(input) {
     const latestMessage = input.source.latestMessage;
-    const formatVersion = input.formatVersion ?? 2;
     return JSON.stringify({
         agentId: input.source.agentId,
         description: input.source.description,
@@ -115,12 +113,10 @@ export function contextGcSubagentOutputReplacement(input) {
                     turnId: latestMessage.turnId,
                     phase: latestMessage.phase,
                     timestamp: latestMessage.timestamp,
-                    ...(formatVersion === 1 ? { itemId: latestMessage.itemId } : {}),
                     ...(latestMessage.truncated === undefined
                         ? {}
                         : { truncated: latestMessage.truncated }),
-                    textBytes: Buffer.byteLength(latestMessage.text),
-                    ...(formatVersion === 1 ? { textSha256: sha256(latestMessage.text) } : {})
+                    textBytes: Buffer.byteLength(latestMessage.text)
                 }
             }),
         ...(input.source.latestActivity === undefined
@@ -128,18 +124,11 @@ export function contextGcSubagentOutputReplacement(input) {
             : { latestActivity: input.source.latestActivity }),
         contextGc: {
             kind: 'superseded_subagent_snapshot',
-            ...(formatVersion === 2 ? { formatVersion } : {}),
+            formatVersion: 2,
             originalBytes: Buffer.byteLength(input.sourceContent),
-            ...(formatVersion === 1 ? { originalSha256: sha256(input.sourceContent) } : {}),
             terminalStatus: input.terminal.status,
             terminalTurnId: contextGcCompletedSubagentTurnId(input.terminal) ??
                 contextGcSubagentSnapshotTurnId(input.terminal),
-            ...(formatVersion === 1
-                ? {
-                    terminalCallId: input.terminalCallId,
-                    evidenceSequence: input.evidenceSequence
-                }
-                : {}),
             note: input.terminal.status === 'completed'
                 ? 'This intermediate child-agent snapshot was superseded by retained completed evidence; complete Turn results remain in retained completed snapshots.'
                 : 'This duplicate child-agent snapshot was superseded by a retained non-completed terminal snapshot. Only fields exactly covered by the retained snapshot were reclaimed.'
@@ -327,9 +316,6 @@ function evidenceIsCovered(source, terminal) {
     return (source === undefined ||
         source.every((item) => terminal?.some((candidate) => stableJson(candidate) === stableJson(item))));
 }
-function sha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
 function stableJson(value) {
     if (Array.isArray(value))
         return `[${value.map(stableJson).join(',')}]`;

package/dist/agent-core/session/deferred-input.d.ts

@@ -1,4 +1,4 @@
-import type { SessionRecord } from './jsonl-store.js';
+import type { SessionRecord } from './store/index.js';
 /** The application is self-contained; the receive record may precede the Compact window. */
 export declare function appliedInputRecord(record: SessionRecord): SessionRecord | undefined;
 /** Only the last checkpoint and its tail are needed, never a historical consume index. */