@myagentroam/agent 0.9.142 → 0.9.143

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

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
+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';
@@ -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/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/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);

package/dist/agent-core/tools/code-mode/cells.d.ts

@@ -1,6 +1,9 @@
 import { MarAgentError } from '../../error.js';
 import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js';
+import { type CodeObservation } from './observations.js';
 export interface CellOutput {
+    call(value: import('./observations.js').CodeToolCallRecord): void;
+    observe(value: CodeObservation): void;
     text(value: string, originalBytes?: number): void;
     image(value: NonNullable<ToolExecutionResult['images']>[number]): void;
     yield(): void;

package/dist/agent-core/tools/code-mode/cells.js

@@ -3,6 +3,7 @@ import { MarAgentError, describeMarAgentError } from '../../error.js';
 import { truncateModelText } from '../../runtime/token-budget.js';
 import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { BoundedTextOutput, renderCapturedText } from './text-output.js';
+import { boundObservations, selectObservationImages, newObservationId, visibleObservation } from './observations.js';
 /** Keeps a failed tool call observable without discarding earlier explicit output. */
 export class CodeCellExecutionError extends MarAgentError {
     result;
@@ -88,6 +89,9 @@ export class CodeCells {
             status: 'running',
             text: new BoundedTextOutput(limits.codeMaxOutputBytes),
             images: [],
+            observations: [],
+            calls: new Map(),
+            imageOffset: 0,
             yielded: false,
             truncated: false,
             listeners: new Set(),
@@ -104,6 +108,8 @@ export class CodeCells {
             .then(async () => {
             releaseSession = await context.codeMode?.retainSession?.();
             return run(source, { ...context, signal: controller.signal }, {
+                call: (value) => cell.calls.set(value.callId, value),
+                observe: (value) => cell.observations.push(value),
                 text: (text, originalBytes) => cell.text.append(text, originalBytes),
                 image: (image) => cell.images.push(image),
                 yield: () => {
@@ -199,6 +205,31 @@ export class CodeCells {
         if (!supportsImages && (cell.images.length || cell.terminal?.images?.length))
             throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'The current model cannot receive this cell image output.');
         if (cell.terminal) {
+            if (cell.terminal.observations) {
+                const bounded = boundObservations(cell.terminal.observations, input.maxOutputTokens);
+                const visible = selectObservationImages(bounded.observations, cell.terminal.images ?? []);
+                const original = cell.terminal.data;
+                const data = {
+                    ...original,
+                    output: truncateModelText(original.output ?? '', input.maxOutputTokens).content,
+                    observations: visible.observations,
+                    cached: true,
+                    truncated: cell.terminal.truncated === true || bounded.truncated
+                };
+                return {
+                    ...cell.terminal,
+                    observations: visible.observations,
+                    images: visible.images,
+                    content: JSON.stringify({
+                        ...data,
+                        output: undefined,
+                        calls: undefined,
+                        observations: visible.observations.map(visibleObservation)
+                    }),
+                    data,
+                    truncated: data.truncated
+                };
+            }
             const snapshot = cell.terminal.data;
             const bounded = truncateModelText(snapshot.output, input.maxOutputTokens);
             const data = {
@@ -219,7 +250,21 @@ export class CodeCells {
         const text = renderCapturedText(captured, images.length);
         cell.yielded = false;
         const bounded = truncateModelText(text, input.maxOutputTokens);
-        cell.truncated ||= captured.droppedBytes > 0 || bounded.truncated;
+        const pending = cell.observations.splice(0);
+        if (!pending.length && captured.text)
+            pending.push({
+                type: 'value',
+                id: newObservationId(),
+                format: 'text',
+                value: captured.text,
+                truncated: captured.droppedBytes > 0
+            });
+        const structured = boundObservations(pending, input.maxOutputTokens);
+        const visible = selectObservationImages(structured.observations, images, cell.imageOffset);
+        const remapped = visible.observations;
+        const visibleImages = visible.images;
+        cell.imageOffset += images.length;
+        cell.truncated ||= captured.droppedBytes > 0 || bounded.truncated || structured.truncated;
         const error = cell.error === undefined
             ? undefined
             : describeMarAgentError(cell.error, 'MAR_AGENT_CODE_FAILED');
@@ -227,6 +272,8 @@ export class CodeCells {
             cellId: cell.cellId,
             status: cell.status,
             output: bounded.content,
+            observations: remapped,
+            calls: [...cell.calls.values()],
             ...cell.result?.data,
             outputBytes: captured.originalBytes,
             outputDroppedBytes: captured.droppedBytes,
@@ -235,10 +282,17 @@ export class CodeCells {
             cached: false
         };
         const result = {
-            content: JSON.stringify(data),
+            content: JSON.stringify({
+                ...data,
+                output: undefined,
+                calls: undefined,
+                observations: remapped.map(visibleObservation)
+            }),
+            calls: [...cell.calls.values()],
+            observations: remapped,
             data,
-            truncated: cell.truncated,
-            ...(images.length ? { images } : {})
+            truncated: cell.truncated || structured.truncated,
+            ...(visibleImages.length ? { images: visibleImages } : {})
         };
         if (cell.status !== 'running')
             cell.terminal = result;
@@ -246,7 +300,7 @@ export class CodeCells {
         if (initial && cell.status !== 'running') {
             if (cell.error !== undefined)
                 throw new CodeCellExecutionError(cell.error, result);
-            return { ...result, content: bounded.content || 'Code Exec completed without emitted text.' };
+            return result;
         }
         return result;
     }