@myagentroam/agent 0.9.141 → 0.9.143

package/dist/agent-core/sdk/subagent-backend.d.ts

@@ -0,0 +1,3 @@
+import type { JsonlSessionStore } from '../session/jsonl-store.js';
+import type { SubagentSessionControllerBackend } from '../subagent/session-controller.js';
+export declare function createSubagentBackend(store: JsonlSessionStore, workspace: string): SubagentSessionControllerBackend;

package/dist/agent-core/sdk/subagent-backend.js

@@ -0,0 +1,46 @@
+import { MarAgentError } from '../error.js';
+export function createSubagentBackend(store, workspace) {
+    return {
+        createSession: async (input) => {
+            const session = await store.createSession({
+                workspace,
+                title: input.title,
+                source: input.source
+            });
+            return { id: session.id };
+        },
+        deleteSession: async (sessionId) => {
+            await store.delete(sessionId);
+        },
+        listChildren: async (parentSessionId) => {
+            const sessions = await store.listSubagentChildren(parentSessionId);
+            return Promise.all(sessions.map(async (session) => ({
+                id: session.id,
+                createdAt: session.createdAt,
+                lastActivityAt: session.lastActivityAt,
+                source: session.source,
+                records: await store.read(session.id)
+            })));
+        },
+        loadChild: async (parentSessionId, childSessionId) => {
+            let session;
+            try {
+                session = await store.getSession(childSessionId);
+            }
+            catch (error) {
+                if (error instanceof MarAgentError && error.code === 'MAR_AGENT_SESSION_NOT_FOUND')
+                    return undefined;
+                throw error;
+            }
+            if (session.source.type !== 'subagent' || session.source.parentSessionId !== parentSessionId)
+                return undefined;
+            return {
+                id: session.id,
+                createdAt: session.createdAt,
+                lastActivityAt: session.lastActivityAt,
+                source: session.source,
+                records: await store.read(session.id)
+            };
+        }
+    };
+}

package/dist/agent-core/sdk/types.d.ts

@@ -0,0 +1,56 @@
+import type { MarAgentHost } from '../host/contracts.js';
+import type { MarAgentModelConfiguration } from '../model/configuration.js';
+import type { ExecutionResult, RolloutBudgetOptions, RunInput } from '../runtime/contracts.js';
+import type { MarAgentEvent } from '../runtime/events.js';
+import type { MarAgentSessionPage, MarAgentSessionSummary } from '../session/catalog.js';
+import type { SessionListInput, SessionSource } from '../session/types.js';
+export interface CreateSessionInput {
+    workspace: string;
+    title?: string;
+}
+export type { HostExecutionExtensions, HostSessionResourceSnapshot, HostSkill, MarAgentHost } from '../host/contracts.js';
+export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from '../runtime/contracts.js';
+export type { MarAgentEvent, MarAgentEventBase } from '../runtime/events.js';
+export type { CodeCellEventData, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../tools/contracts.js';
+/** A live execution exposes streamed events separately from its terminal result. */
+export interface ExecutionHandle extends AsyncIterable<MarAgentEvent> {
+    readonly executionId: string;
+    result(): Promise<ExecutionResult>;
+    /** Signals abort; await result() to observe the terminal status and cleanup. */
+    cancel(): void;
+}
+/** A persisted Session permits one active main execution at a time. */
+export interface MarAgentSession {
+    readonly id: string;
+    run(input: RunInput): ExecutionHandle;
+    plan(input: RunInput): ExecutionHandle;
+    compact(input?: Partial<RunInput>): ExecutionHandle;
+    cancel(executionId: string): Promise<void>;
+}
+export interface MarAgent {
+    createSession(input: CreateSessionInput): Promise<MarAgentSession>;
+    openSession(sessionId: string): Promise<MarAgentSession>;
+    listSessions(input?: SessionListInput): Promise<MarAgentSessionPage>;
+    clearSession(sessionId: string): Promise<void>;
+    /** Rebinds future main executions only; running subagents keep their captured model providers. */
+    reconfigureModels(input: {
+        readonly models: readonly MarAgentModelConfiguration[];
+        readonly defaultModelId?: string;
+    }): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    /** Cancels active executions, then closes SDK-owned providers, the Host and the Session store. */
+    dispose(): Promise<void>;
+}
+export interface CreateMarAgentOptions {
+    mode: 'normal' | 'node';
+    host: MarAgentHost;
+    models: readonly MarAgentModelConfiguration[];
+    defaultModelId?: string;
+    systemInstruction?: string;
+    workspaceMapping?: {
+        readonly logicalPath: string;
+        readonly physicalPath: string;
+    };
+    rolloutBudget?: false | RolloutBudgetOptions;
+}
+export type { MarAgentSessionSummary, SessionListInput, SessionSource };

package/dist/{session → agent-core/session}/catalog.d.ts

@@ -1,5 +1,6 @@
+import type { MarAgentImageMetadata } from '../runtime/contracts.js';
+import type { MarAgentEvent } from '../runtime/events.js';
 import type { SessionListInput, SessionSource } from './types.js';
-import type { MarAgentEvent, MarAgentImageMetadata } from '../sdk/types.js';
 export interface MarAgentSessionSummary {
     id: string;
     title: string;

package/dist/{session → agent-core/session}/context-gc-checkpoint.d.ts

@@ -29,6 +29,7 @@ export type ContextGcBase = {
     readonly recordId: string;
 };
 export interface ContextGcTarget {
+    readonly observationId?: string;
     readonly sequence: number;
     readonly recordId: string;
     readonly role: 'tool_call' | 'tool' | 'provider';
@@ -37,6 +38,7 @@ export interface ContextGcTarget {
     readonly sourceHash: string;
 }
 export interface ContextGcReadItemReplacement {
+    readonly supersededByCallId?: string;
     readonly index: number;
     readonly path: string;
     readonly replacement: string;
@@ -58,6 +60,7 @@ export type ContextGcReplacement = {
     readonly evidenceSequence: number;
 } | {
     readonly kind: 'EXEC_OUTPUT';
+    readonly terminalCallId?: string;
     readonly callId: string;
     readonly target: ContextGcTarget;
     readonly replacementContent: string;

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

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto';
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-import { parseReadContextOutput } from '../tools/read-context.js';
+import { codeCallEvidence, callsFromRecord, codeObservationEvidence, observationsFromRecord, retainedCodeInputs } from './context-gc-observations.js';
+import { parseReadContextOutput } from '../tools/local/read-context.js';
 import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, 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;
@@ -57,7 +58,7 @@ export function contextGcLogicalPathKey(path, workspace, platform) {
     return resolved;
 }
 export function contextGcTargetKey(target) {
-    return `${target.sequence}:${target.recordId}:${target.role}:${target.callId ?? ''}:${target.toolName ?? ''}`;
+    return `${target.sequence}:${target.recordId}:${target.role}:${target.callId ?? ''}:${target.toolName ?? ''}${target.observationId ? `:${target.observationId}` : ''}`;
 }
 export function contextGcReplacementKey(replacement) {
     return contextGcTargetKey(replacement.target);
@@ -154,6 +155,8 @@ export function validateContextGcCheckpoint(records, record, workspace = session
     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;
@@ -225,13 +228,39 @@ function targetMatchesRecord(target, record) {
     const messageCallId = modelContextCallId(record.payload);
     const messageToolName = modelContextToolName(record.payload);
     return ((target.callId === undefined || target.callId === messageCallId) &&
+        (target.observationId === undefined ||
+            observationsFromRecord(record)?.some((value) => value.id === target.observationId) ===
+                true) &&
         (target.toolName === undefined || target.toolName === messageToolName));
 }
 /** A checkpoint draft is valid only when its replacements match the source records and evidence. */
 function replacementMatchesRecords(replacement, records, recordsBySequence, workspace, platform) {
-    const source = recordsBySequence.get(replacement.target.sequence);
+    let source = recordsBySequence.get(replacement.target.sequence);
     if (!source || !isRecord(source.payload))
         return false;
+    if (replacement.target.observationId) {
+        const selected = observationsFromRecord(source)?.find((value) => value.id === replacement.target.observationId);
+        if (!selected)
+            return false;
+        if (selected.type === 'tool_result') {
+            const evidence = codeObservationEvidence(records, source, selected);
+            if (!evidence)
+                return false;
+            source = {
+                ...source,
+                payload: {
+                    ...source.payload,
+                    callId: selected.source.callId,
+                    content: selected.result.content
+                }
+            };
+        }
+        else
+            source = { ...source, payload: { ...source.payload, content: selected.value } };
+        recordsBySequence = new Map(recordsBySequence).set(source.sequence, source);
+    }
+    if (!isRecord(source.payload))
+        return false;
     if (replacement.kind === 'READ_OUTPUT_ITEMS') {
         if (!workspace || toolNameForCallId(records, replacement.callId, source.sequence) !== 'read')
             return false;
@@ -243,7 +272,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
         const originalItems = new Map(parsed.items.map((item) => [item.index, item]));
         return replacement.items.every((item) => {
             const original = originalItems.get(item.index);
-            const evidence = successfulPatchEvidenceForPath(records, recordsBySequence, item.evidenceSequence, item.path, workspace, platform);
+            const evidence = successfulPatchEvidenceForPath(records, recordsBySequence, item.evidenceSequence, item.path, workspace, platform, item.supersededByCallId);
             return (original?.pathTruncated === false &&
                 original?.path === item.path &&
                 evidence !== undefined &&
@@ -274,7 +303,9 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             codeCellCompletionSequence(records, evidence.completed) !== undefined &&
             evidence.call.sequence === replacement.target.sequence &&
             input !== undefined &&
-            isDeepStrictEqual(replacement.replacementArguments, contextGcCodeModeInputReplacement(input)));
+            isDeepStrictEqual(replacement.replacementArguments, contextGcCodeModeInputReplacement(input, observationsFromRecord(evidence.result)
+                ? retainedCodeInputs(records, replacement.callId)
+                : [])));
     }
     if (replacement.kind === 'CODE_MODE_OUTPUT') {
         const evidence = ['code_mode', 'code_exec', 'code_exec_wait']
@@ -288,12 +319,16 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             isRecord(evidence.completed.payload) &&
             typeof evidence.completed.payload.truncated === 'boolean' &&
             replacement.replacementContent ===
-                contextGcCodeModeOutputReplacement(evidence.result.payload.content, evidence.completed.payload.truncated));
+                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));
     }
     if (replacement.kind === 'SUBAGENT_OUTPUT') {
         const retainedPriorFinal = replacement.retainedPriorFinal;
         const sourceEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, replacement.toolName);
-        const terminalEvidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, replacement.terminalToolName);
+        const terminalEvidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, replacement.terminalToolName, replacement.terminalCallId);
         if (!sourceEvidence ||
             sourceEvidence.callId !== replacement.callId ||
             !terminalEvidence ||
@@ -304,7 +339,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
         let retainedPriorFinalEvidence;
         let retainedPriorFinalSnapshot;
         if (retainedPriorFinal !== undefined) {
-            retainedPriorFinalEvidence = successfulToolEvidence(records, recordsBySequence, retainedPriorFinal.evidenceSequence, retainedPriorFinal.toolName);
+            retainedPriorFinalEvidence = successfulToolEvidence(records, recordsBySequence, retainedPriorFinal.evidenceSequence, retainedPriorFinal.toolName, retainedPriorFinal.callId);
             if (!retainedPriorFinalEvidence ||
                 retainedPriorFinalEvidence.callId !== retainedPriorFinal.callId ||
                 !isRecord(retainedPriorFinalEvidence.result.payload))
@@ -319,7 +354,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
                 (retainedPriorFinal !== undefined) &&
             (retainedPriorFinalEvidence === undefined ||
                 retainedPriorFinalEvidence.result.sequence < sourceEvidence.result.sequence) &&
-            sourceEvidence.result.sequence < terminalEvidence.result.sequence &&
+            sourceEvidence.completed.sequence < terminalEvidence.completed.sequence &&
             (contextGcSubagentSnapshotIsSuperseded(sourceSnapshot, terminalSnapshot, retainedPriorFinalSnapshot) ||
                 contextGcSubagentSnapshotIsPreciselyCovered(sourceSnapshot, terminalSnapshot)) &&
             replacement.replacementContent ===
@@ -351,8 +386,8 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
         return false;
     if (replacement.kind === 'TOOL_CALL_INPUT')
         return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, execInputReplacementFormatVersion(replacement.replacementArguments), replacement.toolName));
-    const targetEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec') ??
-        successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec_wait');
+    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 ===
@@ -401,7 +436,7 @@ function toolNameForCallId(records, callId, beforeSequence) {
         ? call.payload.name
         : undefined;
 }
-function successfulToolEvidence(records, recordsBySequence, evidenceSequence, toolName) {
+function successfulToolEvidence(records, recordsBySequence, evidenceSequence, toolName, expectedCallId) {
     const result = recordsBySequence.get(evidenceSequence);
     if (result?.type !== 'model.context' ||
         !isRecord(result.payload) ||
@@ -410,8 +445,28 @@ function successfulToolEvidence(records, recordsBySequence, evidenceSequence, to
         return undefined;
     const callId = result.payload.callId;
     const call = modelToolCallForCallId(records, callId, result.sequence);
-    if (!call || !isRecord(call.payload) || call.payload.name !== toolName)
+    if (!call ||
+        !isRecord(call.payload) ||
+        call.payload.name !== toolName ||
+        (expectedCallId && expectedCallId !== callId)) {
+        for (const observation of observationsFromRecord(result) ?? []) {
+            if (observation.type !== 'tool_result' ||
+                observation.source.toolName !== toolName ||
+                (expectedCallId && observation.source.callId !== expectedCallId))
+                continue;
+            const evidence = codeObservationEvidence(records, result, observation);
+            if (evidence)
+                return evidence;
+        }
+        for (const entry of callsFromRecord(result) ?? []) {
+            if (entry.toolName !== toolName || (expectedCallId && entry.callId !== expectedCallId))
+                continue;
+            const evidence = codeCallEvidence(records, result, entry);
+            if (evidence)
+                return evidence;
+        }
         return undefined;
+    }
     const completed = records.findLast((record) => record.sequence > call.sequence &&
         record.sequence < result.sequence &&
         record.type === 'tool.completed' &&
@@ -441,11 +496,29 @@ function hasFailedToolEvidence(records, call, result, toolName) {
         record.payload.toolName === toolName);
 }
 function modelToolCallForCallId(records, callId, beforeSequence) {
-    return records.findLast((record) => record.sequence < beforeSequence &&
+    const direct = records.findLast((record) => record.sequence < beforeSequence &&
         record.type === 'model.context' &&
         isRecord(record.payload) &&
         record.payload.role === 'tool_call' &&
         record.payload.callId === callId);
+    if (direct)
+        return direct;
+    const started = records.findLast((record) => record.sequence < beforeSequence &&
+        record.type === 'tool.started' &&
+        isRecord(record.payload) &&
+        record.payload.callId === callId &&
+        typeof record.payload.parentCallId === 'string');
+    return started && isRecord(started.payload)
+        ? {
+            ...started,
+            payload: {
+                role: 'tool_call',
+                name: started.payload.toolName,
+                callId,
+                arguments: started.payload.input
+            }
+        }
+        : undefined;
 }
 function modelToolResultForCall(records, call, beforeSequence) {
     if (!isRecord(call.payload) || typeof call.payload.callId !== 'string')
@@ -458,8 +531,8 @@ function modelToolResultForCall(records, call, beforeSequence) {
         record.payload.role === 'tool' &&
         record.payload.callId === callId);
 }
-function successfulPatchEvidenceForPath(records, recordsBySequence, evidenceSequence, path, workspace, platform) {
-    const evidence = successfulToolEvidence(records, recordsBySequence, evidenceSequence, 'apply_patch');
+function successfulPatchEvidenceForPath(records, recordsBySequence, evidenceSequence, path, workspace, platform, expectedCallId) {
+    const evidence = successfulToolEvidence(records, recordsBySequence, evidenceSequence, 'apply_patch', expectedCallId);
     if (!evidence || !isRecord(evidence.completed.payload))
         return undefined;
     const result = contextGcPatchResultFromCompletedPayload(evidence.completed.payload);
@@ -475,8 +548,9 @@ function successfulPatchEvidenceForPath(records, recordsBySequence, evidenceSequ
         : undefined;
 }
 function isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence) {
-    const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec') ??
-        successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec_wait');
+    const expectedTerminal = replacement.kind === 'EXEC_OUTPUT' ? replacement.terminalCallId : undefined;
+    const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec', expectedTerminal) ??
+        successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec_wait', expectedTerminal);
     if (!evidence || !isRecord(evidence.call.payload) || !isRecord(evidence.result.payload))
         return false;
     const finalResult = normalizeContextGcExecResult(evidence.result.payload.content, evidence.completed.payload);
@@ -497,7 +571,7 @@ function isSuccessfulExecLifecycleEvidence(replacement, source, records, records
         : modelToolResultForCall(records, targetCall, evidence.result.sequence);
     if (!targetResult)
         return false;
-    const targetEvidence = successfulToolEvidence(records, recordsBySequence, targetResult.sequence, targetCall.payload.name);
+    const targetEvidence = successfulToolEvidence(records, recordsBySequence, targetResult.sequence, targetCall.payload.name, replacement.callId);
     if (!targetEvidence || targetEvidence.call.sequence !== targetCall.sequence)
         return false;
     if (targetEvidence.callId === evidence.callId)
@@ -597,7 +671,7 @@ function isContextGcReplacement(value) {
     if (!isRecord(value) ||
         !isContextGcTarget(value.target) ||
         !isNonemptyString(value.callId) ||
-        value.target.callId !== value.callId)
+        (value.target.callId !== value.callId && value.target.observationId === undefined))
         return false;
     if (value.kind === 'READ_OUTPUT_ITEMS') {
         const items = value.items;
@@ -607,7 +681,14 @@ function isContextGcReplacement(value) {
             Array.isArray(items) &&
             items.length > 0 &&
             items.every((item) => isRecord(item) &&
-                hasOnlyKeys(item, ['index', 'path', 'replacement', 'evidenceSequence']) &&
+                hasOnlyKeys(item, [
+                    'index',
+                    'path',
+                    'replacement',
+                    'evidenceSequence',
+                    'supersededByCallId'
+                ]) &&
+                (item.supersededByCallId === undefined || isNonemptyString(item.supersededByCallId)) &&
                 isNonnegativeInteger(item.index) &&
                 isNonemptyString(item.path) &&
                 isNonemptyString(item.replacement) &&
@@ -697,14 +778,32 @@ function isContextGcReplacement(value) {
             isNonemptyString(value.replacementContent) &&
             isPositiveInteger(value.evidenceSequence));
     return (value.kind === 'EXEC_OUTPUT' &&
-        hasOnlyKeys(value, ['kind', 'callId', 'target', 'replacementContent', 'evidenceSequence']) &&
+        hasOnlyKeys(value, [
+            'kind',
+            'callId',
+            'target',
+            'replacementContent',
+            'evidenceSequence',
+            'terminalCallId'
+        ]) &&
+        (value.terminalCallId === undefined || isNonemptyString(value.terminalCallId)) &&
         value.target.role === 'tool' &&
         isNonemptyString(value.replacementContent) &&
         isPositiveInteger(value.evidenceSequence));
 }
 function isContextGcTarget(value) {
     return (isRecord(value) &&
-        hasOnlyKeys(value, ['sequence', 'recordId', 'role', 'callId', 'toolName', 'sourceHash']) &&
+        hasOnlyKeys(value, [
+            'sequence',
+            'recordId',
+            'role',
+            'callId',
+            'toolName',
+            'sourceHash',
+            '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') &&

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

@@ -0,0 +1,38 @@
+import type { SessionRecord } from './jsonl-store.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, {
+    type: 'tool_result';
+}>): {
+    callId: string;
+    call: SessionRecord;
+    completed: SessionRecord;
+    result: SessionRecord;
+} | undefined;
+export declare function observationsFromRecord(record: SessionRecord): CodeObservation[] | undefined;
+export declare function codeCallEvidence(records: readonly SessionRecord[], result: SessionRecord, entry: CodeToolCallRecord): {
+    result: {
+        payload: {
+            role: string;
+            callId: string;
+            content: string;
+        };
+        schemaVersion: 1;
+        recordId: string;
+        sequence: number;
+        timestamp: string;
+        sessionId: string;
+        executionId?: string;
+        turnId?: string;
+        type: string;
+    };
+    callId: string;
+    call: SessionRecord;
+    completed: SessionRecord;
+} | undefined;
+export declare function callsFromRecord(record: SessionRecord): CodeToolCallRecord[] | undefined;
+export declare function retainedCodeInputs(records: readonly SessionRecord[], parentCallId: string): {
+    callId: unknown;
+    toolName: unknown;
+    input: unknown;
+}[];

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

@@ -0,0 +1,150 @@
+import { isDeepStrictEqual } from 'node:util';
+import { codeCellCompletionSequence, contextGcPatchResultFromCompletedPayload } from './context-gc-replacements.js';
+import { parseCodeCalls, parseObservations } from '../tools/code-mode/observations.js';
+/** Resolve private observation identity to real dispatch facts, not Provider tool calls. */
+export function codeObservationEvidence(records, result, observation) {
+    if (observation.outcome !== 'completed')
+        return undefined;
+    const started = records.findLast((record) => record.sequence < result.sequence &&
+        record.type === 'tool.started' &&
+        isRecord(record.payload) &&
+        record.payload.callId === observation.source.callId &&
+        record.payload.toolName === observation.source.toolName &&
+        typeof record.payload.parentCallId === 'string' &&
+        isDeepStrictEqual(record.payload.input, observation.source.input));
+    if (!started || !isRecord(started.payload))
+        return undefined;
+    const parentId = started.payload.parentCallId;
+    const parent = records.find((record) => record.type === 'model.context' &&
+        record.sequence < started.sequence &&
+        isRecord(record.payload) &&
+        record.payload.role === 'tool_call' &&
+        record.payload.callId === parentId &&
+        (record.payload.name === 'code_exec' || record.payload.name === 'code_mode'));
+    if (!parent)
+        return undefined;
+    const original = records.find((record) => record.recordId === result.recordId) ?? result;
+    if (!isRecord(original.payload))
+        return undefined;
+    const outerId = original.payload.callId;
+    const outer = records.findLast((record) => record.sequence < result.sequence &&
+        record.type === 'tool.completed' &&
+        isRecord(record.payload) &&
+        record.payload.callId === outerId &&
+        (record.payload.toolName === 'code_exec' ||
+            record.payload.toolName === 'code_mode' ||
+            record.payload.toolName === 'code_exec_wait'));
+    if (!outer ||
+        codeCellCompletionSequence(records, outer) === undefined ||
+        records.some((record) => record.sequence < result.sequence &&
+            record.type === 'tool.failed' &&
+            isRecord(record.payload) &&
+            record.payload.callId === outerId))
+        return undefined;
+    if (original.payload.callId !== parentId) {
+        const initial = records.find((record) => record.sequence < outer.sequence &&
+            record.type === 'tool.completed' &&
+            isRecord(record.payload) &&
+            record.payload.callId === parentId);
+        if (!initial ||
+            !isRecord(outer.payload) ||
+            outer.payload.toolName !== 'code_exec_wait' ||
+            !isRecord(initial.payload) ||
+            !isRecord(outer.payload.data) ||
+            !isRecord(initial.payload.data) ||
+            typeof outer.payload.data.cellId !== 'string' ||
+            outer.payload.data.cellId !== initial.payload.data.cellId)
+            return undefined;
+    }
+    const completed = records.findLast((record) => record.sequence > started.sequence &&
+        record.sequence < result.sequence &&
+        record.type === 'tool.completed' &&
+        isRecord(record.payload) &&
+        record.payload.callId === observation.source.callId &&
+        record.payload.toolName === observation.source.toolName &&
+        record.payload.parentCallId === parentId);
+    if (!completed ||
+        records.some((record) => record.sequence > started.sequence &&
+            record.sequence < result.sequence &&
+            record.type === 'tool.failed' &&
+            isRecord(record.payload) &&
+            record.payload.callId === observation.source.callId))
+        return undefined;
+    const call = {
+        ...started,
+        payload: {
+            role: 'tool_call',
+            name: observation.source.toolName,
+            callId: observation.source.callId,
+            arguments: observation.source.input
+        }
+    };
+    const selected = {
+        ...result,
+        payload: {
+            role: 'tool',
+            callId: observation.source.callId,
+            content: observation.result.content,
+            observationId: observation.id
+        }
+    };
+    return { callId: observation.source.callId, call, completed, result: selected };
+}
+export function observationsFromRecord(record) {
+    return isRecord(record.payload) ? parseObservations(record.payload.observations) : undefined;
+}
+export function codeCallEvidence(records, result, entry) {
+    if (entry.status !== 'completed')
+        return undefined;
+    const evidence = codeObservationEvidence(records, result, {
+        type: 'tool_result',
+        id: `call:${entry.callId}`,
+        source: { callId: entry.callId, toolName: entry.toolName, input: entry.input },
+        outcome: 'completed',
+        result: { content: '' }
+    });
+    if (!evidence || !isRecord(evidence.completed.payload))
+        return undefined;
+    return {
+        ...evidence,
+        result: {
+            ...evidence.result,
+            payload: {
+                role: 'tool',
+                callId: entry.callId,
+                content: JSON.stringify(evidence.completed.payload.data ?? {})
+            }
+        }
+    };
+}
+export function callsFromRecord(record) {
+    return isRecord(record.payload) ? parseCodeCalls(record.payload.calls) : undefined;
+}
+export function retainedCodeInputs(records, parentCallId) {
+    return records.flatMap((record) => {
+        if (!isRecord(record.payload) ||
+            record.type !== 'tool.started' ||
+            record.payload.parentCallId !== parentCallId)
+            return [];
+        const call = record.payload;
+        const completedPatch = call.toolName === 'apply_patch' &&
+            records.some((next) => next.sequence > record.sequence &&
+                next.type === 'tool.completed' &&
+                isRecord(next.payload) &&
+                next.payload.callId === call.callId &&
+                next.payload.toolName === 'apply_patch' &&
+                next.payload.parentCallId === parentCallId &&
+                contextGcPatchResultFromCompletedPayload(next.payload) !== undefined) &&
+            !records.some((next) => next.sequence > record.sequence &&
+                next.type === 'tool.failed' &&
+                isRecord(next.payload) &&
+                next.payload.callId === call.callId);
+        // Successful patches have durable file evidence; other inputs retain their direct-mode semantics.
+        return completedPatch
+            ? []
+            : [{ callId: call.callId, toolName: call.toolName, input: call.input }];
+    });
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -4,7 +4,7 @@ export interface ContextGcCodeModeInput {
     readonly inputMode: 'freeform' | 'json';
 }
 export declare function normalizeContextGcCodeModeInput(arguments_: unknown): ContextGcCodeModeInput | undefined;
-export declare function contextGcCodeModeInputReplacement(input: ContextGcCodeModeInput): unknown;
+export declare function contextGcCodeModeInputReplacement(input: ContextGcCodeModeInput, retainedInputs?: readonly unknown[]): unknown;
 export declare function contextGcCodeModeOutputReplacement(originalContent: string, truncated: boolean): string;
 export interface ContextGcPatchFile {
     readonly path: string;

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

@@ -14,9 +14,13 @@ export function normalizeContextGcCodeModeInput(arguments_) {
         return { code: arguments_.code, inputMode: 'json' };
     return undefined;
 }
-export function contextGcCodeModeInputReplacement(input) {
+export function contextGcCodeModeInputReplacement(input, retainedInputs = []) {
     const replacement = `<context_gc kind="completed_code_mode_input" originalBytes="${Buffer.byteLength(input.code)}" lines="${lineCount(input.code)}" inputMode="${input.inputMode}">Completed Code Mode source was reclaimed after six successful rollouts. The paired output, images, completion evidence, and nested tool side effects remain in history.</context_gc>`;
-    return input.inputMode === 'freeform' ? replacement : { code: replacement };
+    const content = replacement +
+        (retainedInputs.length
+            ? `\nRetained tool instructions: ${JSON.stringify(retainedInputs)}`
+            : '');
+    return input.inputMode === 'freeform' ? content : { code: content };
 }
 export function contextGcCodeModeOutputReplacement(originalContent, truncated) {
     const preview = unicodeHeadTail(originalContent, CODE_MODE_OUTPUT_PREVIEW_CHARACTERS);