@myagentroam/agent 0.11.52 → 0.11.54

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

@@ -1,5 +1,6 @@
-import { isDeepStrictEqual } from 'node:util';
-import { codeCellCompletionSequence, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload } from './context-gc-replacements.js';
+import { completedTodoWrite, todoInputReplacement } from './context-gc-todo.js';
+import { terminalExecLifecycles } from './context-gc-exec-lifecycle.js';
+import { contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcExecInputReplacement, normalizeContextGcExecResult } from './context-gc-replacements.js';
 import { parseCodeCalls, parseObservations } from './code-observation-projection.js';
 /** Resolve private observation identity to real dispatch facts, not Provider tool calls. */
 export function codeObservationEvidence(records, result, observation) {
@@ -29,8 +30,7 @@ function codeToolEvidence(records, result, source, outcome) {
         isRecord(record.payload) &&
         record.payload.callId === source.callId &&
         record.payload.toolName === source.toolName &&
-        typeof record.payload.parentCallId === 'string' &&
-        isDeepStrictEqual(record.payload.input, source.input));
+        typeof record.payload.parentCallId === 'string');
     if (!started || !isRecord(started.payload))
         return undefined;
     const parentId = started.payload.parentCallId;
@@ -47,20 +47,11 @@ function codeToolEvidence(records, result, source, outcome) {
         return undefined;
     const outerId = original.payload.callId;
     const outer = records.findLast((record) => record.sequence < result.sequence &&
-        (record.type === 'tool.completed' ||
-            (outcome === 'failed' && record.type === 'tool.failed')) &&
+        (record.type === 'tool.completed' || record.type === 'tool.failed') &&
         isRecord(record.payload) &&
         record.payload.callId === outerId &&
         (record.payload.toolName === 'code_exec' || record.payload.toolName === 'code_exec_wait'));
-    if (!outer ||
-        (outcome === 'completed'
-            ? codeCellCompletionSequence(records, outer)
-            : partialPatchCellTerminalSequence(records, outer)) === undefined ||
-        (outcome === 'completed' &&
-            records.some((record) => record.sequence < result.sequence &&
-                record.type === 'tool.failed' &&
-                isRecord(record.payload) &&
-                record.payload.callId === outerId)))
+    if (!outer)
         return undefined;
     if (original.payload.callId !== parentId) {
         const initial = records.find((record) => record.sequence < outer.sequence &&
@@ -102,22 +93,6 @@ function codeToolEvidence(records, result, source, outcome) {
     };
     return { callId: source.callId, call, terminal: completed, result };
 }
-function partialPatchCellTerminalSequence(records, result) {
-    if (!isRecord(result.payload) || !isRecord(result.payload.data))
-        return undefined;
-    const data = result.payload.data;
-    if (typeof data.cellId !== 'string')
-        return undefined;
-    const terminal = (status) => status === 'completed' || status === 'failed' || status === 'cancelled';
-    if (terminal(data.status))
-        return result.sequence;
-    if (data.status !== 'running')
-        return undefined;
-    return records.findLast((record) => record.type === 'code.cell.completed' &&
-        isRecord(record.payload) &&
-        record.payload.cellId === data.cellId &&
-        terminal(record.payload.status))?.sequence;
-}
 export function observationsFromRecord(record) {
     return isRecord(record.payload) ? parseObservations(record.payload.observations) : undefined;
 }
@@ -157,7 +132,81 @@ export function codePartialPatchCallEvidence(records, result, entry) {
 export function callsFromRecord(record) {
     return isRecord(record.payload) ? parseCodeCalls(record.payload.calls) : undefined;
 }
-export function retainedCodeInputs(records, parentCallId) {
+export function retainedCodeInputs(records, parentCallId, todoEvidenceMature, execOptions) {
+    const initial = records.findLast((record) => record.type === 'tool.completed' &&
+        isRecord(record.payload) &&
+        record.payload.callId === parentCallId &&
+        record.payload.toolName === 'code_exec');
+    const initialData = initial && isRecord(initial.payload) && isRecord(initial.payload.data)
+        ? initial.payload.data
+        : undefined;
+    const cellId = initialData?.cellId;
+    const inputs = new Map();
+    const nestedExecCallIds = new Set();
+    const nestedCallIds = new Set();
+    for (const record of records) {
+        if (record.type !== 'tool.started' ||
+            !isRecord(record.payload) ||
+            record.payload.parentCallId !== parentCallId ||
+            typeof record.payload.callId !== 'string')
+            continue;
+        nestedCallIds.add(record.payload.callId);
+        if (record.payload.toolName === 'exec' || record.payload.toolName === 'exec_wait')
+            nestedExecCallIds.add(record.payload.callId);
+    }
+    const waits = new Map();
+    for (const snapshot of records) {
+        if (snapshot.type === 'tool.completed' &&
+            isRecord(snapshot.payload) &&
+            snapshot.payload.toolName === 'code_exec_wait' &&
+            typeof snapshot.payload.callId === 'string')
+            waits.set(snapshot.payload.callId, snapshot);
+        if (snapshot.type !== 'model.context' ||
+            !isRecord(snapshot.payload) ||
+            snapshot.payload.role !== 'tool' ||
+            !Array.isArray(snapshot.payload.calls))
+            continue;
+        const calls = (callsFromRecord(snapshot) ?? []).filter((call) => nestedCallIds.has(call.callId));
+        if (calls.length === 0)
+            continue;
+        const outerId = snapshot.payload.callId;
+        if (outerId !== parentCallId) {
+            const outer = typeof outerId === 'string' ? waits.get(outerId) : undefined;
+            if (!outer ||
+                outer.sequence >= snapshot.sequence ||
+                !isRecord(outer.payload) ||
+                !isRecord(outer.payload.data) ||
+                typeof cellId !== 'string' ||
+                outer.payload.data.cellId !== cellId)
+                continue;
+        }
+        for (const call of calls)
+            inputs.set(call.callId, call.input);
+    }
+    const terminalExecs = new Map();
+    if (execOptions && nestedExecCallIds.size > 0) {
+        const processIds = new Set();
+        for (const callId of nestedExecCallIds) {
+            const input = inputs.get(callId);
+            if (isRecord(input) && typeof input.processId === 'string')
+                processIds.add(input.processId);
+        }
+        for (const record of records) {
+            if (!isRecord(record.payload) || typeof record.payload.callId !== 'string')
+                continue;
+            if (!nestedExecCallIds.has(record.payload.callId))
+                continue;
+            const data = record.type === 'tool.started' ? record.payload.input : record.payload.data;
+            if (isRecord(data) && typeof data.processId === 'string')
+                processIds.add(data.processId);
+        }
+        for (const lifecycle of terminalExecLifecycles(execFactsFromRecords(records, nestedExecCallIds, processIds), execOptions.activeProcessIds)) {
+            const boundary = lifecycle.at(-1).value.resultSequence;
+            if (boundary !== undefined && execOptions.evidenceMature(boundary))
+                for (const fact of lifecycle)
+                    terminalExecs.set(fact.callId, boundary);
+        }
+    }
     return records.flatMap((record) => {
         if (!isRecord(record.payload) ||
             record.type !== 'tool.started' ||
@@ -176,12 +225,116 @@ export function retainedCodeInputs(records, parentCallId) {
                 next.type === 'tool.failed' &&
                 isRecord(next.payload) &&
                 next.payload.callId === call.callId);
+        const actualInput = inputs.has(String(call.callId))
+            ? inputs.get(String(call.callId))
+            : call.input;
+        if ((call.toolName === 'exec' || call.toolName === 'exec_wait') &&
+            typeof call.callId === 'string' &&
+            terminalExecs.has(call.callId)) {
+            const summary = contextGcExecInputReplacement(actualInput, call.toolName);
+            if (!execOptions?.selected || execOptions.selected(call.callId, call.toolName, summary))
+                return [{ callId: call.callId, toolName: call.toolName, input: summary }];
+        }
+        if (call.toolName === 'todo_write' &&
+            todoEvidenceMature &&
+            isRecord(actualInput) &&
+            Array.isArray(actualInput.items)) {
+            const originalRecord = records.find((item) => completedTodoWrite(item)?.callId === call.callId);
+            const original = originalRecord && completedTodoWrite(originalRecord);
+            const successor = original &&
+                records
+                    .flatMap((item) => {
+                    const fact = completedTodoWrite(item);
+                    return fact &&
+                        fact.revision > original.revision &&
+                        todoEvidenceMature(originalRecord, item)
+                        ? [{ record: item, ...fact }]
+                        : [];
+                })
+                    .sort((a, b) => b.revision - a.revision)[0];
+            if (original && successor)
+                return [
+                    {
+                        callId: call.callId,
+                        toolName: call.toolName,
+                        input: todoInputReplacement(original.revision, actualInput.items.length, successor.revision)
+                    }
+                ];
+        }
         // Successful patches have durable file evidence; other inputs retain their direct-mode semantics.
         return completedPatch
             ? []
-            : [{ callId: call.callId, toolName: call.toolName, input: call.input }];
+            : [{ callId: call.callId, toolName: call.toolName, input: actualInput }];
     });
 }
+function execFactsFromRecords(records, relevantCallIds, relevantProcessIds) {
+    const facts = new Map();
+    const completedByCallId = new Map();
+    const startedByCallId = new Map();
+    for (const record of records) {
+        if (isRecord(record.payload) &&
+            typeof record.payload.callId === 'string' &&
+            typeof record.payload.toolName === 'string') {
+            const key = `${record.payload.toolName}:${record.payload.callId}`;
+            if (record.type === 'tool.completed')
+                completedByCallId.set(key, record);
+            if (record.type === 'tool.started')
+                startedByCallId.set(key, record);
+        }
+        if (record.type !== 'model.context' || !isRecord(record.payload))
+            continue;
+        const payload = record.payload;
+        if (payload.role === 'tool_call' &&
+            (payload.name === 'exec' || payload.name === 'exec_wait') &&
+            typeof payload.callId === 'string') {
+            facts.set(payload.callId, {
+                value: {},
+                callId: payload.callId,
+                toolName: payload.name,
+                sequence: record.sequence,
+                ...(isRecord(payload.arguments) ? { input: payload.arguments } : {})
+            });
+        }
+        if (payload.role !== 'tool')
+            continue;
+        if (typeof payload.callId === 'string') {
+            const fact = facts.get(payload.callId);
+            const completed = fact && completedByCallId.get(`${fact.toolName}:${fact.callId}`);
+            const result = completed && normalizeContextGcExecResult(payload.content, completed.payload);
+            if (fact && result)
+                facts.set(fact.callId, { ...fact, value: { resultSequence: record.sequence }, result });
+        }
+        for (const call of callsFromRecord(record) ?? []) {
+            if (call.toolName !== 'exec' && call.toolName !== 'exec_wait')
+                continue;
+            const started = startedByCallId.get(`${call.toolName}:${call.callId}`);
+            const completed = completedByCallId.get(`${call.toolName}:${call.callId}`);
+            const data = completed && isRecord(completed.payload) ? completed.payload.data : undefined;
+            const inputProcess = isRecord(call.input) ? call.input.processId : undefined;
+            const resultProcess = isRecord(data) ? data.processId : undefined;
+            if (!relevantCallIds.has(call.callId) &&
+                !(typeof inputProcess === 'string' && relevantProcessIds.has(inputProcess)) &&
+                !(typeof resultProcess === 'string' && relevantProcessIds.has(resultProcess)))
+                continue;
+            if (!started || !isRecord(started.payload) || started.payload.toolName !== call.toolName)
+                continue;
+            const evidence = codeCallEvidence(records, record, call);
+            const content = evidence && isRecord(evidence.result.payload) ? evidence.result.payload.content : undefined;
+            const result = evidence && normalizeContextGcExecResult(content, evidence.completed.payload);
+            facts.set(call.callId, {
+                value: result ? { resultSequence: record.sequence } : {},
+                callId: call.callId,
+                toolName: call.toolName,
+                sequence: started.sequence,
+                ...(isRecord(call.input) ? { input: call.input } : {}),
+                ...(result ? { result } : {})
+            });
+        }
+    }
+    return [...facts.values()].filter((fact) => relevantCallIds.has(fact.callId) ||
+        (typeof fact.input?.processId === 'string' && relevantProcessIds.has(fact.input.processId)) ||
+        (typeof fact.result?.processId === 'string' && relevantProcessIds.has(fact.result.processId)));
+}
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }

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

@@ -0,0 +1,8 @@
+import type { SessionRecord } from './record-contract.js';
+/** One immutable boundary index, shared by all candidate anchors in this evaluation. */
+export declare function buildContextGcProtection(records: readonly SessionRecord[], modelId: string, contextWindowTokens: number): {
+    after(anchor: number): {
+        rollouts: number;
+        thinking: number;
+    };
+};

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

@@ -0,0 +1,83 @@
+import { completedNativeThinkingIdentity } from '../model/native-context.js';
+/** One immutable boundary index, shared by all candidate anchors in this evaluation. */
+export function buildContextGcProtection(records, modelId, contextWindowTokens) {
+    const configurations = new Map();
+    const attempts = new Map();
+    const successful = [];
+    const thinking = [];
+    for (const record of records) {
+        if (!record.executionId ||
+            !['execution.header', 'model.attempt', 'model.context'].includes(record.type) ||
+            !isRecord(record.payload))
+            continue;
+        const key = record.executionId;
+        const payload = record.payload;
+        if (record.type === 'execution.header') {
+            configurations.set(key, {
+                modelId: typeof payload.modelId === 'string' ? payload.modelId : modelId,
+                window: typeof payload.contextWindowTokens === 'number'
+                    ? payload.contextWindowTokens
+                    : contextWindowTokens
+            });
+        }
+        else if (record.type === 'model.attempt') {
+            if (payload.purpose !== 'EXECUTION')
+                continue;
+            if (payload.state === 'STARTED') {
+                const configuration = configurations.get(key);
+                attempts.set(key, {
+                    start: record.sequence,
+                    matching: payload.purpose === 'EXECUTION' &&
+                        (configuration?.modelId ?? modelId) === modelId &&
+                        (configuration?.window ?? contextWindowTokens) === contextWindowTokens,
+                    native: new Set()
+                });
+            }
+            else if (payload.state === 'SUCCEEDED' || payload.state === 'FAILED') {
+                const attempt = attempts.get(key);
+                if (attempt?.matching) {
+                    if (payload.state === 'SUCCEEDED')
+                        successful.push(attempt.start);
+                    for (const _identity of attempt.native)
+                        thinking.push(attempt.start);
+                }
+                attempts.delete(key);
+            }
+        }
+        else if (record.type === 'model.context') {
+            const attempt = attempts.get(key);
+            if (!attempt?.matching ||
+                (typeof payload.providerModelId === 'string' && payload.providerModelId !== modelId))
+                continue;
+            const identity = completedNativeThinkingIdentity(payload, record.recordId);
+            if (identity !== undefined)
+                attempt.native.add(identity);
+        }
+    }
+    for (const attempt of attempts.values())
+        if (attempt.matching)
+            for (const _identity of attempt.native)
+                thinking.push(attempt.start);
+    successful.sort((a, b) => a - b);
+    thinking.sort((a, b) => a - b);
+    return {
+        after(anchor) {
+            return { rollouts: afterCount(successful, anchor), thinking: afterCount(thinking, anchor) };
+        }
+    };
+}
+function afterCount(values, anchor) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (values[middle] <= anchor)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return values.length - low;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -1,3 +1,5 @@
+import type { ParsedReadContextItem } from '../prompts/read-context.js';
+export declare function hasGenericContextGcPreview(originalContent: string): boolean;
 import type { ContextGcWebToolName } from './context-gc-contract.js';
 export type { ContextGcWebToolName } from './context-gc-contract.js';
 export interface ContextGcCodeModeInput {
@@ -6,7 +8,7 @@ export interface ContextGcCodeModeInput {
 }
 export declare function normalizeContextGcCodeModeInput(arguments_: unknown): ContextGcCodeModeInput | undefined;
 export declare function contextGcCodeModeInputReplacement(input: ContextGcCodeModeInput, retainedInputs?: readonly unknown[]): unknown;
-export declare function contextGcCodeModeOutputReplacement(originalContent: string, truncated: boolean): string;
+export declare function contextGcCodeModeOutputReplacement(originalContent: string, truncated: boolean, value?: boolean): string;
 export interface ContextGcPatchFile {
     readonly path: string;
     readonly targetPath?: string;
@@ -54,10 +56,13 @@ export declare function contextGcStaleReadReplacement(input: {
     readonly content: string;
     readonly operation: Exclude<ContextGcPatchFile['operation'], 'added'>;
 }): string;
+export declare function contextGcReadRangeCovers(original: ParsedReadContextItem, later: ParsedReadContextItem): boolean;
+export declare function contextGcCoveredReadReplacement(original: ParsedReadContextItem, successorCallId: string): string;
 export declare function contextGcWebOutputReplacement(toolName: ContextGcWebToolName, originalContent: string, truncated: boolean): string;
 /** Tools with their own evidence and lifecycle policies are never handled as generic output. */
 export declare function isGenericContextGcTool(toolName: string): boolean;
 export declare function contextGcToolOutputReplacement(toolName: string, originalContent: string, truncated: boolean): string;
+export declare function contextGcSkillOutputReplacement(name: string, originalContent: string, successorCallId: string): 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;

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

@@ -5,6 +5,10 @@ const EXEC_INPUT_COMPLETE_CHARACTERS = 512;
 const EXEC_INPUT_PREVIEW_CHARACTERS = 256;
 const EXEC_OUTPUT_PREVIEW_CHARACTERS = 512;
 const CODE_MODE_OUTPUT_PREVIEW_CHARACTERS = 512;
+const GENERIC_OUTPUT_PREVIEW_CHARACTERS = 768;
+export function hasGenericContextGcPreview(originalContent) {
+    return [...originalContent].length > GENERIC_OUTPUT_PREVIEW_CHARACTERS * 2;
+}
 export function normalizeContextGcCodeModeInput(arguments_) {
     if (typeof arguments_ === 'string' && arguments_.length > 0)
         return { code: arguments_, inputMode: 'freeform' };
@@ -25,8 +29,8 @@ export function contextGcCodeModeInputReplacement(input, retainedInputs = []) {
     });
     return input.inputMode === 'freeform' ? content : { code: content };
 }
-export function contextGcCodeModeOutputReplacement(originalContent, truncated) {
-    const preview = unicodeHeadTail(originalContent, CODE_MODE_OUTPUT_PREVIEW_CHARACTERS);
+export function contextGcCodeModeOutputReplacement(originalContent, truncated, value = false) {
+    const preview = unicodeHeadTail(originalContent, value ? GENERIC_OUTPUT_PREVIEW_CHARACTERS : CODE_MODE_OUTPUT_PREVIEW_CHARACTERS);
     return JSON.stringify({
         originalBytes: Buffer.byteLength(originalContent),
         lines: lineCount(originalContent),
@@ -70,6 +74,34 @@ export function contextGcStaleReadReplacement(input) {
         contextGc: 'This read predates a successful apply_patch. Re-read the path before relying on its contents.'
     });
 }
+export function contextGcReadRangeCovers(original, later) {
+    const oldStart = original.metadata.startLine;
+    const oldEnd = original.metadata.endLine;
+    const newStart = later.metadata.startLine;
+    const newEnd = later.metadata.endLine;
+    return (!original.pathTruncated &&
+        !later.pathTruncated &&
+        later.metadata.previewComplete === true &&
+        later.metadata.oversizedLine === undefined &&
+        !later.content.startsWith('<mar_context_gc ') &&
+        typeof oldStart === 'number' &&
+        typeof oldEnd === 'number' &&
+        typeof newStart === 'number' &&
+        typeof newEnd === 'number' &&
+        newStart <= oldStart &&
+        newEnd >= oldEnd);
+}
+export function contextGcCoveredReadReplacement(original, successorCallId) {
+    return contextGcMarkup('stale_read', {
+        path: original.path,
+        formatVersion: 2,
+        originalBytes: Buffer.byteLength(original.content),
+        startLine: original.metadata.startLine,
+        endLine: original.metadata.endLine,
+        supersededByCallId: successorCallId,
+        contextGc: 'This visible range was covered by a later read.'
+    });
+}
 export function contextGcWebOutputReplacement(toolName, originalContent, truncated) {
     const preview = unicodeHeadTail(originalContent, EXEC_OUTPUT_PREVIEW_CHARACTERS);
     return JSON.stringify({
@@ -93,11 +125,16 @@ export function isGenericContextGcTool(toolName) {
             'code_exec',
             'code_exec_wait',
             'web_search',
-            'web_fetch'
+            'web_fetch',
+            'skill',
+            'question',
+            'todo_read',
+            'todo_write',
+            'tool_search'
         ].includes(toolName));
 }
 export function contextGcToolOutputReplacement(toolName, originalContent, truncated) {
-    const preview = unicodeHeadTail(originalContent, EXEC_OUTPUT_PREVIEW_CHARACTERS);
+    const preview = unicodeHeadTail(originalContent, GENERIC_OUTPUT_PREVIEW_CHARACTERS);
     return JSON.stringify({
         toolName,
         originalBytes: Buffer.byteLength(originalContent),
@@ -108,6 +145,17 @@ export function contextGcToolOutputReplacement(toolName, originalContent, trunca
         contextGc: 'Detailed tool output was reclaimed after six successful rollouts. An incomplete preview is not the complete result; the tool was not replayed.'
     });
 }
+export function contextGcSkillOutputReplacement(name, originalContent, successorCallId) {
+    const firstLine = originalContent.split('\n', 1)[0] ?? '';
+    return JSON.stringify({
+        name,
+        ...(firstLine.startsWith('<mar_skill ') && firstLine.length <= 1024
+            ? { source: firstLine }
+            : {}),
+        supersededByCallId: successorCallId,
+        contextGc: 'This guidance was replaced by a later visible load of the same Skill.'
+    });
+}
 export function contextGcExecInputReplacement(arguments_, toolName = 'exec') {
     if (!isRecord(arguments_))
         return contextGcMarkup('terminal_exec_input', {
@@ -154,7 +202,7 @@ export function contextGcExecOutputReplacement(result) {
             modelContextBytes: Buffer.byteLength(result.modelContextContent),
             modelContextPreview: unicodeHeadTail(result.modelContextContent, RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS),
             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.'
+            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.'
         });
     const stdout = result.stdout;
     const stderr = result.stderr;
@@ -182,7 +230,7 @@ export function contextGcExecOutputReplacement(result) {
             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.'
+        contextGc: 'Detailed terminal input/output was reclaimed after the process reached a stable terminal state. An incomplete preview is not the complete result.'
     });
 }
 export function normalizeContextGcExecResult(modelContent, completedPayload) {

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

@@ -0,0 +1,13 @@
+import type { SessionRecord } from './record-contract.js';
+export declare function todoRevision(value: unknown): number | undefined;
+/** A successful write is a domain fact even if its output was not observed. */
+export declare function completedTodoWrite(record: SessionRecord): {
+    callId: string;
+    revision: number;
+} | undefined;
+export declare function visibleTodoSnapshot(content: string): {
+    revision: number;
+    count: number;
+} | undefined;
+export declare function todoInputReplacement(revision: number, count: number, successorRevision: number): unknown;
+export declare function todoSnapshotReplacement(revision: number, count: number, successorRevision: number): string;

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

@@ -0,0 +1,47 @@
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function todoRevision(value) {
+    return object(value) && Number.isSafeInteger(value.revision) && value.revision >= 0
+        ? value.revision
+        : undefined;
+}
+/** A successful write is a domain fact even if its output was not observed. */
+export function completedTodoWrite(record) {
+    if (record.type !== 'tool.completed' ||
+        !object(record.payload) ||
+        record.payload.type !== 'tool.completed' ||
+        record.payload.toolName !== 'todo_write' ||
+        typeof record.payload.callId !== 'string')
+        return undefined;
+    const revision = todoRevision(record.payload.data);
+    return revision === undefined ? undefined : { callId: record.payload.callId, revision };
+}
+export function visibleTodoSnapshot(content) {
+    try {
+        const value = JSON.parse(content);
+        const revision = todoRevision(value);
+        return revision !== undefined && object(value) && Array.isArray(value.items)
+            ? { revision, count: value.items.length }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function todoInputReplacement(revision, count, successorRevision) {
+    return {
+        contextGc: 'Todo input was superseded by a successful later revision.',
+        revision,
+        count,
+        supersededByRevision: successorRevision
+    };
+}
+export function todoSnapshotReplacement(revision, count, successorRevision) {
+    return JSON.stringify({
+        contextGc: 'Todo snapshot was superseded by a successful later revision.',
+        revision,
+        count,
+        supersededByRevision: successorRevision
+    });
+}

package/dist/session/tool-callers.d.ts

@@ -0,0 +1,7 @@
+import type { ClientToolDefinition } from '../tools/contracts.js';
+import type { ToolCaller } from '../tools/contracts.js';
+/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
+export declare function toolCallers(tool: ClientToolDefinition): readonly ToolCaller[];
+export declare function allowsToolCaller(tool: ClientToolDefinition, caller: ToolCaller): boolean;
+/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
+export declare function allowsDirectTool(tool: ClientToolDefinition, codeModeEnabled: boolean): boolean;

package/dist/session/tool-callers.js

@@ -0,0 +1,28 @@
+import { AgentError } from '../error.js';
+/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
+export function toolCallers(tool) {
+    if (tool.codeModeExposure !== undefined && tool.codeModeExposure !== 'both')
+        throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Mode exposure is invalid.');
+    const value = tool.allowedCallers;
+    if (value === undefined)
+        return tool.name.startsWith('mcp__') ? ['direct', 'programmatic'] : ['direct'];
+    if (!Array.isArray(value) ||
+        value.length === 0 ||
+        value.some((caller) => caller !== 'direct' && caller !== 'programmatic'))
+        throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Tool caller policy is invalid.');
+    return ['direct', 'programmatic'].filter((caller) => value.includes(caller));
+}
+export function allowsToolCaller(tool, caller) {
+    // Control tools cannot be widened by a Host override or historical definition.
+    if (caller === 'programmatic' &&
+        ['code_exec', 'code_exec_wait', 'tool_search', 'question', 'skill', 'sleep'].includes(tool.name))
+        return false;
+    return toolCallers(tool).includes(caller);
+}
+/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
+export function allowsDirectTool(tool, codeModeEnabled) {
+    return (allowsToolCaller(tool, 'direct') &&
+        (!codeModeEnabled ||
+            tool.codeModeExposure === 'both' ||
+            !allowsToolCaller(tool, 'programmatic')));
+}

package/dist/tools/callers.d.ts

@@ -1,7 +1 @@
-import type { ClientToolDefinition } from './contracts.js';
-import type { ToolCaller } from './contracts.js';
-/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
-export declare function toolCallers(tool: ClientToolDefinition): readonly ToolCaller[];
-export declare function allowsToolCaller(tool: ClientToolDefinition, caller: ToolCaller): boolean;
-/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
-export declare function allowsDirectTool(tool: ClientToolDefinition, codeModeEnabled: boolean): boolean;
+export { toolCallers, allowsToolCaller, allowsDirectTool } from '../session/tool-callers.js';

package/dist/tools/callers.js

@@ -1,28 +1 @@
-import { AgentError } from '../error.js';
-/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
-export function toolCallers(tool) {
-    if (tool.codeModeExposure !== undefined && tool.codeModeExposure !== 'both')
-        throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Mode exposure is invalid.');
-    const value = tool.allowedCallers;
-    if (value === undefined)
-        return tool.name.startsWith('mcp__') ? ['direct', 'programmatic'] : ['direct'];
-    if (!Array.isArray(value) ||
-        value.length === 0 ||
-        value.some((caller) => caller !== 'direct' && caller !== 'programmatic'))
-        throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Tool caller policy is invalid.');
-    return ['direct', 'programmatic'].filter((caller) => value.includes(caller));
-}
-export function allowsToolCaller(tool, caller) {
-    // Control tools cannot be widened by a Host override or historical definition.
-    if (caller === 'programmatic' &&
-        ['code_exec', 'code_exec_wait', 'tool_search', 'question', 'skill', 'sleep'].includes(tool.name))
-        return false;
-    return toolCallers(tool).includes(caller);
-}
-/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
-export function allowsDirectTool(tool, codeModeEnabled) {
-    return (allowsToolCaller(tool, 'direct') &&
-        (!codeModeEnabled ||
-            tool.codeModeExposure === 'both' ||
-            !allowsToolCaller(tool, 'programmatic')));
-}
+export { toolCallers, allowsToolCaller, allowsDirectTool } from '../session/tool-callers.js';

package/dist/tools/code-mode/index.d.ts

@@ -1,6 +1,6 @@
 import type { ClientToolDefinition } from '../contracts.js';
-import type { SessionModelMessage as ModelMessage } from '../../session/model-request.js';
 import type { LocalProcessExecutor } from '../../process/contracts.js';
+export { projectCodeModeSearchResult } from '../../session/code-mode-search-projection.js';
 import { type CellOutput } from './cells.js';
 import type { CodeModeEngineFactory } from './engine.js';
 import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js';
@@ -9,8 +9,6 @@ export declare const codeModeToolDefinition: ClientToolDefinition;
 export declare const codeExecWaitToolDefinition: ClientToolDefinition;
 /** Deferred definitions travel in search results, not in the stable Code Mode description. */
 export declare function projectCodeModeTools(tools: readonly ClientToolDefinition[], residentTools?: readonly ClientToolDefinition[]): ClientToolDefinition[];
-/** Preserve native search definitions while providing the same discovery evidence to other protocols. */
-export declare function projectCodeModeSearchResult(message: ModelMessage, codeModeEnabled: boolean): ModelMessage;
 export declare class CodeModeTool {
     #private;
     private readonly paths;