@myagentroam/agent 0.11.52 → 0.11.54

package/dist/sdk/execution-compaction.js

@@ -17,7 +17,6 @@ export function createExecutionCompaction(ports) {
             message.contextKind === 'summary'))
             return false;
         const history = structuredClone(prefix).map(({ images: _images, ...message }) => message);
-        const prefixInputs = modelContext.compactInputs(prefix);
         const tools = structuredClone(ports.snapshotTools());
         const generation = modelContext.worldState.generation;
         const usage = ports.usage();
@@ -62,7 +61,7 @@ export function createExecutionCompaction(ports) {
         await prepare();
         signal.throwIfAborted();
         const resources = await ports.retainedResources();
-        const replacementHistory = buildCompactedHistory(candidate.summary, prefixInputs, ports.userTokenLimit);
+        let replacementHistory;
         let committed = false;
         let retained;
         try {
@@ -72,6 +71,7 @@ export function createExecutionCompaction(ports) {
                 signal,
                 prefix,
                 messages,
+                model: ports.model,
                 generation,
                 messageSources: ports.messageSources,
                 checkpoint: (value) => ports.resourceInput.checkpoint(value),
@@ -85,21 +85,26 @@ export function createExecutionCompaction(ports) {
                     modelContext.replaceCompactMessages(replacementHistory, value);
                     ports.updateBoundary(messages.length - value.length);
                 },
-                draft: () => ({
-                    summary: candidate.summary,
-                    replacementHistory,
-                    pendingInputs: [...ports.pendingInputs.values()],
-                    snapshotMessageCount: prefix.length,
-                    ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
-                    automatic: ports.mode !== 'compact',
-                    environment: ports.environment(),
-                    modelId: ports.model.id,
-                    contextWindowTokens: ports.model.contextWindowTokens,
-                    ...(candidate.usage === undefined ? {} : { usage: candidate.usage }),
-                    executionId: ports.executionId,
-                    turnId: ports.turnId
-                })
+                draft: (retainedStart) => {
+                    replacementHistory = buildCompactedHistory(candidate.summary, modelContext.compactInputs(prefix.slice(0, retainedStart)), ports.userTokenLimit);
+                    return {
+                        summary: candidate.summary,
+                        replacementHistory,
+                        pendingInputs: [...ports.pendingInputs.values()],
+                        snapshotMessageCount: prefix.length,
+                        ...(anchorRecordId ? { snapshotRecordId: anchorRecordId } : {}),
+                        automatic: ports.mode !== 'compact',
+                        environment: ports.environment(),
+                        modelId: ports.model.id,
+                        contextWindowTokens: ports.model.contextWindowTokens,
+                        ...(candidate.usage === undefined ? {} : { usage: candidate.usage }),
+                        executionId: ports.executionId,
+                        turnId: ports.turnId
+                    };
+                }
             });
+            if (!result)
+                return false;
             retained = result.retained;
             await modelContext.adoptCompactCheckpoint(result.record.recordId, replacementHistory, retained, resources);
             ports.invalidateUsage();

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

@@ -165,7 +165,8 @@ export function createSessionExecutionFactory(ports) {
                 const compactMayContainAgentInstructions = contextRecords.some((record) => compactSummaryFromCheckpoint(record) !== undefined);
                 const restored = await restoreMessages(store, sessionId, contextRecords, {
                     messageSources,
-                    includeImages: mode !== 'compact'
+                    // Keep durable references for the retained tail; the Compact snapshot removes images.
+                    includeImages: true
                 });
                 let modelLifecycle;
                 let applyCompactBoundary = () => { };

package/dist/session/code-mode-search-projection.d.ts

@@ -0,0 +1,5 @@
+import type { ClientToolDefinition } from '../tools/contracts.js';
+import type { SessionModelMessage as ModelMessage } from './model-request.js';
+export declare function projectProgrammaticTool(tool: ClientToolDefinition): Pick<ClientToolDefinition, 'name' | 'description' | 'inputSchema'>;
+/** Preserve native search definitions while providing the same discovery evidence to other protocols. */
+export declare function projectCodeModeSearchResult(message: ModelMessage, codeModeEnabled: boolean): ModelMessage;

package/dist/session/code-mode-search-projection.js

@@ -0,0 +1,46 @@
+import { stableToolDefinition, stableToolSchema } from '../model/tool-definition-projection.js';
+import { allowsDirectTool, allowsToolCaller } from './tool-callers.js';
+export function projectProgrammaticTool(tool) {
+    return {
+        name: tool.name,
+        description: `${allowsDirectTool(tool, true) ? `Call directly or as tools.${tool.name} inside code_exec.` : `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.`}\n${tool.description}`,
+        inputSchema: stableToolSchema(tool.inputSchema)
+    };
+}
+/** Preserve native search definitions while providing the same discovery evidence to other protocols. */
+export function projectCodeModeSearchResult(message, codeModeEnabled) {
+    if (!message.toolSearchTools)
+        return message;
+    if (!codeModeEnabled)
+        return {
+            ...message,
+            toolSearchTools: message.toolSearchTools
+                .filter((tool) => allowsToolCaller(tool, 'direct'))
+                .map(stableToolDefinition)
+        };
+    const tools = message.toolSearchTools.map((tool) => ({
+        ...(allowsToolCaller(tool, 'programmatic')
+            ? {
+                ...projectProgrammaticTool(tool),
+                ...(allowsDirectTool(tool, true)
+                    ? { inputMode: tool.inputMode ?? 'json' }
+                    : {})
+            }
+            : {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: stableToolSchema(tool.inputSchema),
+                inputMode: tool.inputMode ?? 'json'
+            }),
+        caller: allowsToolCaller(tool, 'programmatic')
+            ? allowsDirectTool(tool, true)
+                ? 'both'
+                : 'programmatic'
+            : 'direct'
+    }));
+    return {
+        ...message,
+        content: JSON.stringify({ tools }),
+        toolSearchTools: tools.map(({ caller: _caller, ...tool }) => tool)
+    };
+}

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

@@ -1,9 +1,12 @@
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { inlineMediaGcAnchored, parseInlineMediaGc } from './inline-media.js';
+import { buildContextGcProtection } from './context-gc-protection.js';
+import { completedTodoWrite, todoInputReplacement, todoSnapshotReplacement, visibleTodoSnapshot } from './context-gc-todo.js';
+import { contextGcRetainedInputMarkup } from './context-gc-markup.js';
 import { codeCallEvidence, codePartialPatchCallEvidence, callsFromRecord, codeObservationEvidence, observationsFromRecord, retainedCodeInputs } from './context-gc-observations.js';
 import { parseReadContextOutput } from '../prompts/read-context.js';
-import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcToolOutputReplacement, contextGcWebOutputReplacement, isGenericContextGcTool, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from './context-gc-replacements.js';
+import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcReadRangeCovers, contextGcCoveredReadReplacement, contextGcSkillOutputReplacement, contextGcToolOutputReplacement, contextGcWebOutputReplacement, isGenericContextGcTool, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from './context-gc-replacements.js';
 import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, normalizeContextGcSubagentSnapshot } from './context-gc-subagent.js';
 export const CONTEXT_GC_CHECKPOINT_VERSION = 1;
 export const CONTEXT_GC_MAX_TARGETS = 4_096;
@@ -188,6 +191,7 @@ export function validateContextGcCheckpoint(records, record, workspace = session
     ]);
     if (new Set(targets.map(contextGcTargetKey)).size !== targets.length)
         return undefined;
+    const protection = buildContextGcProtection(records, payload.trigger.modelId, payload.trigger.contextWindowTokens);
     for (const replacement of changed) {
         for (const target of [
             replacement.target,
@@ -211,7 +215,34 @@ export function validateContextGcCheckpoint(records, record, workspace = session
             sequence > payload.boundarySequence ||
             !recordsBySequence.has(sequence)))
             return undefined;
-        if (!replacementMatchesRecords(replacement, records, recordsBySequence, workspace, payload.trigger.platform))
+        const anchors = replacement.kind === 'READ_OUTPUT_ITEMS'
+            ? replacement.items.map((item) => Math.max(replacement.target.sequence, item.evidenceSequence))
+            : [Math.max(replacement.target.sequence, ...evidence)];
+        if (replacement.kind === 'TOOL_CALL_INPUT' && replacement.toolName === 'todo_write') {
+            const terminal = records.find((item) => completedTodoWrite(item)?.callId === replacement.callId);
+            if (terminal)
+                anchors[0] = Math.max(anchors[0], terminal.sequence);
+        }
+        if ((replacement.kind === 'TOOL_CALL_INPUT' && replacement.toolName === 'code_exec') ||
+            (replacement.kind === 'CODE_MODE_OUTPUT' && !replacement.target.observationId)) {
+            const result = recordsBySequence.get(replacement.evidenceSequence);
+            if (result && isRecord(result.payload) && typeof result.payload.callId === 'string') {
+                const callId = result.payload.callId;
+                const terminal = records.findLast((item) => item.sequence < result.sequence &&
+                    item.type === 'tool.completed' &&
+                    isRecord(item.payload) &&
+                    item.payload.callId === callId);
+                const completion = terminal && codeCellCompletionSequence(records, terminal);
+                if (completion !== undefined)
+                    anchors[0] = Math.max(anchors[0], completion);
+            }
+        }
+        if (anchors.some((anchor) => {
+            const count = protection.after(anchor);
+            return count.rollouts < 6 || count.thinking < 3;
+        }))
+            return undefined;
+        if (!replacementMatchesRecords(replacement, records, recordsBySequence, workspace, payload.trigger.platform, payload.replacements, protection, committed.get(contextGcReplacementKey(replacement))))
             return undefined;
     }
     return payload;
@@ -260,8 +291,18 @@ function targetMatchesRecord(target, record) {
                 true) &&
         (target.toolName === undefined || target.toolName === messageToolName));
 }
+function resultVisibleAfter(source, observationId, successor) {
+    if (successor.sequence !== source.sequence)
+        return successor.sequence > source.sequence;
+    if (!isRecord(successor.payload))
+        return false;
+    const observations = observationsFromRecord(source) ?? [];
+    const sourceIndex = observations.findIndex((value) => value.id === observationId);
+    const successorId = successor.payload.observationId;
+    return (sourceIndex >= 0 && observations.findIndex((value) => value.id === successorId) > sourceIndex);
+}
 /** A checkpoint draft is valid only when its replacements match the source records and evidence. */
-function replacementMatchesRecords(replacement, records, recordsBySequence, workspace, platform) {
+function replacementMatchesRecords(replacement, records, recordsBySequence, workspace, platform, allReplacements, protection, previous) {
     let source = recordsBySequence.get(replacement.target.sequence);
     if (!source || !isRecord(source.payload))
         return false;
@@ -286,7 +327,6 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
         }
         else
             source = { ...source, payload: { ...source.payload, content: selected.value } };
-        recordsBySequence = new Map(recordsBySequence).set(source.sequence, source);
     }
     if (!isRecord(source.payload))
         return false;
@@ -302,6 +342,30 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
         return replacement.items.every((item) => {
             const original = originalItems.get(item.index);
             const evidence = appliedPatchEvidenceForPath(records, recordsBySequence, item.evidenceSequence, item.path, workspace, platform, sourceToolSequence, item.supersededByCallId);
+            if (original && !evidence && item.supersededByCallId) {
+                const later = successfulToolEvidence(records, recordsBySequence, item.evidenceSequence, 'read', item.supersededByCallId);
+                if (!later ||
+                    !resultVisibleAfter(source, replacement.target.observationId, later.result) ||
+                    !isRecord(later.result.payload) ||
+                    typeof later.result.payload.content !== 'string')
+                    return false;
+                const laterItems = parseReadContextOutput(later.result.payload.content)?.items ?? [];
+                const pathKey = contextGcLogicalPathKey(original.path, workspace, platform);
+                const observationId = typeof later.result.payload.observationId === 'string'
+                    ? later.result.payload.observationId
+                    : undefined;
+                const laterRecord = recordsBySequence.get(item.evidenceSequence);
+                if (laterRecord && observationsFromRecord(laterRecord) !== undefined && !observationId)
+                    return false;
+                const covered = laterItems.some((next) => pathKey !== undefined &&
+                    contextGcLogicalPathKey(next.path, workspace, platform) === pathKey &&
+                    contextGcReadRangeCovers(original, next) &&
+                    !allReplacements.some((prior) => prior.kind === 'READ_OUTPUT_ITEMS' &&
+                        prior.target.sequence === later.result.sequence &&
+                        prior.target.observationId === observationId &&
+                        prior.items.some((existing) => existing.index === next.index)));
+                return (covered && item.replacement === contextGcCoveredReadReplacement(original, later.callId));
+            }
             return (original?.pathTruncated === false &&
                 original?.path === item.path &&
                 evidence !== undefined &&
@@ -321,6 +385,19 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             result !== undefined &&
             isDeepStrictEqual(replacement.replacementArguments, contextGcApplyPatchInputReplacement(source.payload.arguments, result)));
     }
+    if (replacement.kind === 'TOOL_CALL_INPUT' && replacement.toolName === 'todo_write') {
+        const own = records.find((item) => completedTodoWrite(item)?.callId === replacement.callId);
+        const original = own && completedTodoWrite(own);
+        const successorRecord = recordsBySequence.get(replacement.evidenceSequence);
+        const successor = successorRecord && completedTodoWrite(successorRecord);
+        const args = source.payload.arguments;
+        return (original !== undefined &&
+            successor !== undefined &&
+            successor.revision > original.revision &&
+            isRecord(args) &&
+            Array.isArray(args.items) &&
+            isDeepStrictEqual(replacement.replacementArguments, todoInputReplacement(original.revision, args.items.length, successor.revision)));
+    }
     if (replacement.kind === 'TOOL_CALL_INPUT' && replacement.toolName === 'code_exec') {
         const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, replacement.toolName);
         const input = normalizeContextGcCodeModeInput(source.payload.arguments);
@@ -329,10 +406,38 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             evidence.call.sequence === replacement.target.sequence &&
             input !== undefined &&
             isDeepStrictEqual(replacement.replacementArguments, contextGcCodeModeInputReplacement(input, observationsFromRecord(evidence.result)
-                ? retainedCodeInputs(records, replacement.callId)
+                ? retainedCodeInputs(records, replacement.callId, (original, successor) => {
+                    const count = protection.after(Math.max(replacement.target.sequence, replacement.evidenceSequence, codeCellCompletionSequence(records, evidence.completed) ?? 0, original.sequence, successor.sequence));
+                    return count.rollouts >= 6 && count.thinking >= 3;
+                }, {
+                    activeProcessIds: new Set(),
+                    evidenceMature: (sequence) => {
+                        const count = protection.after(Math.max(replacement.target.sequence, replacement.evidenceSequence, codeCellCompletionSequence(records, evidence.completed) ?? 0, sequence));
+                        return count.rollouts >= 6 && count.thinking >= 3;
+                    },
+                    selected: (callId, toolName, summary) => {
+                        const argument = replacement.replacementArguments;
+                        const content = typeof argument === 'string'
+                            ? argument
+                            : isRecord(argument)
+                                ? argument.code
+                                : undefined;
+                        return (typeof content === 'string' &&
+                            content.includes(contextGcRetainedInputMarkup({ callId, toolName, input: summary })));
+                    }
+                })
                 : [])));
     }
     if (replacement.kind === 'CODE_MODE_OUTPUT') {
+        if (replacement.target.observationId) {
+            const observation = observationsFromRecord(source)?.find((value) => value.id === replacement.target.observationId && value.type === 'value');
+            return (observation?.type === 'value' &&
+                source.payload.callId === replacement.callId &&
+                replacement.evidenceSequence === source.sequence &&
+                ['code_exec', 'code_exec_wait'].includes(toolNameForCallId(records, replacement.callId, source.sequence) ?? '') &&
+                replacement.replacementContent ===
+                    contextGcCodeModeOutputReplacement(observation.value, observation.truncated === true, true));
+        }
         const evidence = ['code_exec', 'code_exec_wait']
             .map((name) => successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, name))
             .find((item) => item !== undefined);
@@ -344,13 +449,112 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             isRecord(evidence.completed.payload) &&
             typeof evidence.completed.payload.truncated === 'boolean' &&
             replacement.replacementContent ===
-                contextGcCodeModeOutputReplacement(source.payload.content, replacement.target.observationId
-                    ? observationsFromRecord(source)?.some((value) => value.id === replacement.target.observationId &&
-                        value.type === 'value' &&
-                        value.truncated === true) === true
-                    : evidence.completed.payload.truncated));
+                contextGcCodeModeOutputReplacement(source.payload.content, evidence.completed.payload.truncated, false));
     }
     if (replacement.kind === 'TOOL_OUTPUT') {
+        if (replacement.toolName === 'tool_search') {
+            const original = successfulToolEvidence(records, recordsBySequence, source.sequence, 'tool_search', replacement.callId);
+            if (!original ||
+                !isRecord(source.payload) ||
+                !Array.isArray(source.payload.toolSearchTools) ||
+                replacement.retainedToolNames === undefined ||
+                replacement.replacementContent !== source.payload.content)
+                return false;
+            const sourceNames = source.payload.toolSearchTools.flatMap((tool) => isRecord(tool) && typeof tool.name === 'string' ? [tool.name] : []);
+            const priorNames = previous?.kind === 'TOOL_OUTPUT' && previous.retainedToolNames !== undefined
+                ? previous.retainedToolNames
+                : sourceNames;
+            if (replacement.retainedToolNames.some((name) => !priorNames.includes(name)) ||
+                !isDeepStrictEqual(replacement.retainedToolNames, priorNames.filter((name) => replacement.retainedToolNames.includes(name))))
+                return false;
+            const removed = priorNames.filter((name) => !replacement.retainedToolNames.includes(name));
+            if (removed.length === 0)
+                return false;
+            const successors = records.filter((item) => item.sequence > source.sequence &&
+                item.sequence <= replacement.evidenceSequence &&
+                item.type === 'model.context' &&
+                isRecord(item.payload) &&
+                item.payload.role === 'tool' &&
+                typeof item.payload.callId === 'string' &&
+                Array.isArray(item.payload.toolSearchTools) &&
+                successfulToolEvidence(records, recordsBySequence, item.sequence, 'tool_search', item.payload.callId) !== undefined);
+            return (removed.every((name) => successors.some((item) => {
+                if (!isRecord(item.payload) || !Array.isArray(item.payload.toolSearchTools))
+                    return false;
+                const target = {
+                    sequence: item.sequence,
+                    recordId: item.recordId,
+                    role: 'tool',
+                    ...(typeof item.payload.callId === 'string' ? { callId: item.payload.callId } : {})
+                };
+                const applied = allReplacements.find((candidate) => contextGcTargetKey(candidate.target) === contextGcTargetKey(target));
+                return (item.payload.toolSearchTools.some((tool) => isRecord(tool) && tool.name === name) &&
+                    !(applied?.kind === 'TOOL_OUTPUT' &&
+                        applied.retainedToolNames !== undefined &&
+                        !applied.retainedToolNames.includes(name)));
+            })) && successors.some((item) => item.sequence === replacement.evidenceSequence));
+        }
+        if (replacement.toolName === 'todo_read') {
+            const original = successfulToolEvidence(records, recordsBySequence, source.sequence, 'todo_read', replacement.callId);
+            const successorRecord = recordsBySequence.get(replacement.evidenceSequence);
+            const successor = successorRecord && completedTodoWrite(successorRecord);
+            const snapshot = typeof source.payload.content === 'string'
+                ? visibleTodoSnapshot(source.payload.content)
+                : undefined;
+            return (original !== undefined &&
+                snapshot !== undefined &&
+                successor !== undefined &&
+                successor.revision > snapshot.revision &&
+                replacement.replacementContent ===
+                    todoSnapshotReplacement(snapshot.revision, snapshot.count, successor.revision));
+        }
+        if (replacement.toolName === 'skill') {
+            const original = successfulToolEvidence(records, recordsBySequence, source.sequence, 'skill', replacement.callId);
+            let successorCallId;
+            try {
+                successorCallId = JSON.parse(replacement.replacementContent).supersededByCallId;
+            }
+            catch {
+                return false;
+            }
+            if (typeof successorCallId !== 'string')
+                return false;
+            const successor = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'skill', successorCallId);
+            const successorRecord = recordsBySequence.get(replacement.evidenceSequence);
+            const successorObservationId = isRecord(successor?.result.payload)
+                ? successor.result.payload.observationId
+                : undefined;
+            if (!successorRecord ||
+                !isRecord(successorRecord.payload) ||
+                (observationsFromRecord(successorRecord) !== undefined &&
+                    typeof successorObservationId !== 'string'))
+                return false;
+            const successorKey = contextGcTargetKey({
+                sequence: successorRecord.sequence,
+                recordId: successorRecord.recordId,
+                role: 'tool',
+                ...(typeof successorRecord.payload.callId === 'string'
+                    ? { callId: successorRecord.payload.callId }
+                    : {}),
+                ...(typeof successorObservationId === 'string'
+                    ? { observationId: successorObservationId }
+                    : {})
+            });
+            if (!original ||
+                !successor ||
+                !resultVisibleAfter(source, replacement.target.observationId, successor.result) ||
+                !isRecord(original.call.payload) ||
+                !isRecord(successor.call.payload) ||
+                !isRecord(original.call.payload.arguments) ||
+                !isRecord(successor.call.payload.arguments) ||
+                typeof original.call.payload.arguments.name !== 'string' ||
+                original.call.payload.arguments.name !== successor.call.payload.arguments.name ||
+                typeof source.payload.content !== 'string' ||
+                allReplacements.some((item) => contextGcTargetKey(item.target) === successorKey))
+                return false;
+            return (replacement.replacementContent ===
+                contextGcSkillOutputReplacement(original.call.payload.arguments.name, source.payload.content, successor.callId));
+        }
         const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, replacement.toolName, replacement.callId);
         return (isGenericContextGcTool(replacement.toolName) &&
             evidence !== undefined &&
@@ -359,8 +563,6 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             isRecord(evidence.completed.payload) &&
             typeof evidence.completed.payload.truncated === 'boolean' &&
             typeof source.payload.content === 'string' &&
-            isRecord(evidence.result.payload) &&
-            evidence.result.payload.content === source.payload.content &&
             replacement.replacementContent ===
                 contextGcToolOutputReplacement(replacement.toolName, source.payload.content, evidence.completed.payload.truncated));
     }
@@ -447,7 +649,9 @@ function successfulToolEvidence(records, recordsBySequence, evidenceSequence, to
         !isRecord(call.payload) ||
         call.payload.name !== toolName ||
         (expectedCallId && expectedCallId !== callId)) {
-        for (const observation of observationsFromRecord(result) ?? []) {
+        const observations = observationsFromRecord(result) ?? [];
+        // Repeated observations of a known call use its last visible occurrence.
+        for (const observation of expectedCallId ? [...observations].reverse() : observations) {
             if (observation.type !== 'tool_result' ||
                 observation.source.toolName !== toolName ||
                 (expectedCallId && observation.source.callId !== expectedCallId))
@@ -766,7 +970,8 @@ function isContextGcReplacement(value) {
             (value.toolName === 'apply_patch' ||
                 value.toolName === 'exec' ||
                 value.toolName === 'exec_wait' ||
-                value.toolName === 'code_exec') &&
+                value.toolName === 'code_exec' ||
+                value.toolName === 'todo_write') &&
             value.target.toolName === value.toolName &&
             Array.isArray(value.providerAliasTargets) &&
             value.providerAliasTargets.every((target) => isContextGcTarget(target) &&
@@ -829,13 +1034,23 @@ function isContextGcReplacement(value) {
             'callId',
             'target',
             'replacementContent',
+            'retainedToolNames',
             'evidenceSequence'
         ]) &&
             value.target.role === 'tool' &&
             isNonemptyString(value.toolName) &&
-            isGenericContextGcTool(value.toolName) &&
+            (value.toolName === 'skill' ||
+                value.toolName === 'todo_read' ||
+                value.toolName === 'tool_search' ||
+                isGenericContextGcTool(value.toolName)) &&
             (value.target.toolName === undefined || value.target.toolName === value.toolName) &&
-            isNonemptyString(value.replacementContent) &&
+            (isNonemptyString(value.replacementContent) ||
+                (value.toolName === 'tool_search' && value.replacementContent === '')) &&
+            (value.retainedToolNames === undefined ||
+                (value.toolName === 'tool_search' &&
+                    Array.isArray(value.retainedToolNames) &&
+                    value.retainedToolNames.every(isNonemptyString) &&
+                    new Set(value.retainedToolNames).size === value.retainedToolNames.length)) &&
             isPositiveInteger(value.evidenceSequence));
     if (value.kind === 'CODE_MODE_OUTPUT')
         return (hasOnlyKeys(value, ['kind', 'callId', 'target', 'replacementContent', 'evidenceSequence']) &&
@@ -906,7 +1121,8 @@ function isContextGcEconomicsPolicy(value) {
 }
 function isContextGcMetrics(value) {
     if (!isRecord(value) ||
-        (value.stage !== 'STAGE_A' &&
+        (value.stage !== 'UNIFIED' &&
+            value.stage !== 'STAGE_A' &&
             value.stage !== 'STAGE_A_AND_EXEC' &&
             value.stage !== 'INLINE_MEDIA'))
         return false;

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

@@ -49,7 +49,7 @@ export type ContextGcReplacement = {
     readonly evidenceSequences: readonly number[];
 } | {
     readonly kind: 'TOOL_CALL_INPUT';
-    readonly toolName: 'apply_patch' | 'exec' | 'exec_wait' | 'code_exec';
+    readonly toolName: 'apply_patch' | 'exec' | 'exec_wait' | 'code_exec' | 'todo_write';
     readonly callId: string;
     readonly target: ContextGcTarget;
     readonly replacementArguments: unknown;
@@ -74,6 +74,7 @@ export type ContextGcReplacement = {
     readonly callId: string;
     readonly target: ContextGcTarget;
     readonly replacementContent: string;
+    readonly retainedToolNames?: readonly string[];
     readonly evidenceSequence: number;
 } | {
     readonly kind: 'SUBAGENT_OUTPUT';
@@ -98,7 +99,7 @@ export type ContextGcReplacement = {
     readonly evidenceSequence: number;
 };
 export interface ContextGcMetrics {
-    readonly stage: 'STAGE_A' | 'STAGE_A_AND_EXEC' | 'INLINE_MEDIA';
+    readonly stage: 'UNIFIED' | 'STAGE_A' | 'STAGE_A_AND_EXEC' | 'INLINE_MEDIA';
     readonly tokenEstimator?: 'UTF8_BYTES_V1';
     readonly beforeTokens: number;
     readonly afterTokens: number;

package/dist/session/context-gc-exec-lifecycle.d.ts

@@ -0,0 +1,11 @@
+import type { ContextGcExecResult } from './context-gc-replacements.js';
+/** The same process-lifetime selection is used for Direct output and retained cell inputs. */
+export interface ContextGcExecFact<T> {
+    readonly value: T;
+    readonly callId: string;
+    readonly toolName: string;
+    readonly sequence: number;
+    readonly input?: Record<string, unknown>;
+    readonly result?: ContextGcExecResult;
+}
+export declare function terminalExecLifecycles<T>(facts: readonly ContextGcExecFact<T>[], active: ReadonlySet<string>): ContextGcExecFact<T>[][];

package/dist/session/context-gc-exec-lifecycle.js

@@ -0,0 +1,41 @@
+export function terminalExecLifecycles(facts, active) {
+    const ordered = [...facts].sort((a, b) => a.sequence - b.sequence);
+    const lifecycles = [];
+    for (const start of ordered) {
+        if (!start.input || !start.result)
+            continue;
+        const isStart = start.toolName === 'exec' &&
+            (start.input.action === 'start' ||
+                (start.input.action == null && typeof start.input.command === 'string'));
+        const processId = typeof start.input.processId === 'string' ? start.input.processId : start.result.processId;
+        if (!isStart) {
+            if (start.toolName !== 'exec_wait' || !processId)
+                continue;
+            const previous = ordered.findLast((item) => item.sequence < start.sequence &&
+                (item.input?.processId === processId || item.result?.processId === processId));
+            if (previous &&
+                previous.result?.status !== 'completed' &&
+                previous.result?.status !== 'cancelled')
+                continue;
+        }
+        const lifecycle = [start];
+        let terminal = start.result.status !== 'running';
+        if (!terminal) {
+            if (!processId)
+                continue;
+            const related = ordered.filter((item) => item.sequence > start.sequence && item.input?.processId === processId);
+            for (const item of related) {
+                if (!item.result)
+                    break;
+                lifecycle.push(item);
+                if (item.result.status !== 'running') {
+                    terminal = true;
+                    break;
+                }
+            }
+        }
+        if (terminal && (!processId || !active.has(processId)))
+            lifecycles.push(lifecycle);
+    }
+    return lifecycles;
+}

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

@@ -1 +1,2 @@
+export declare function contextGcRetainedInputMarkup(input: unknown): string;
 export declare function contextGcMarkup(kind: string, fields: Record<string, unknown>): string;

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

@@ -1,4 +1,7 @@
 import { markupAttributes, markupText } from '../prompts/markup.js';
+export function contextGcRetainedInputMarkup(input) {
+    return markupText('retained_input', typeof input === 'string' ? input : JSON.stringify(input));
+}
 // Render message placeholders only; structured GC records keep their JSON shape.
 export function contextGcMarkup(kind, fields) {
     const attributes = { kind };
@@ -8,7 +11,7 @@ export function contextGcMarkup(kind, fields) {
             continue;
         if (key === 'retainedInputs' && Array.isArray(value)) {
             for (const input of value)
-                children.push(markupText('retained_input', typeof input === 'string' ? input : JSON.stringify(input)));
+                children.push(contextGcRetainedInputMarkup(input));
         }
         else if (key === 'contextGc')
             children.push(markupText('instruction', String(value)));

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

@@ -51,7 +51,11 @@ export declare function codePartialPatchCallEvidence(records: readonly SessionRe
     result: SessionRecord;
 } | undefined;
 export declare function callsFromRecord(record: SessionRecord): CodeToolCallRecord[] | undefined;
-export declare function retainedCodeInputs(records: readonly SessionRecord[], parentCallId: string): {
+export declare function retainedCodeInputs(records: readonly SessionRecord[], parentCallId: string, todoEvidenceMature?: (original: SessionRecord, successor: SessionRecord) => boolean, execOptions?: {
+    readonly activeProcessIds: ReadonlySet<string>;
+    readonly evidenceMature: (sequence: number) => boolean;
+    readonly selected?: (callId: string, toolName: string, summary: unknown) => boolean;
+}): {
     callId: unknown;
     toolName: unknown;
     input: unknown;