@myagentroam/agent 0.10.1 → 0.10.2

package/dist/agent-core/runtime/context/gc.js

@@ -1,6 +1,6 @@
-import { codeCallEvidence, codeObservationEvidence, retainedCodeInputs } from '../../session/context-gc-observations.js';
+import { codeCallEvidence, codePartialPatchCallEvidence, codeObservationEvidence, retainedCodeInputs } from '../../session/context-gc-observations.js';
 import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcRecordSourceHash, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
-import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
+import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
 import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../../session/context-gc-subagent.js';
 import { parseReadContextOutput } from '../../tools/local/read-context.js';
 import { CONTEXT_GC_TOKEN_ESTIMATOR, contextGcCacheImpact, contextGcMessageTokens, contextGcPrefixTokens, contextGcReclaimedTokens } from './gc-tokens.js';
@@ -533,23 +533,26 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
     const claimedReadItems = new Set([...existingReadReplacements.values()].flatMap((replacement) => replacement.items.map((item) => `${replacement.target.recordId}:${replacement.target.observationId ?? ''}:${item.index}`)));
     const patches = [...groups.values()]
         .flatMap((patch) => {
-        if (patch.toolName !== 'apply_patch' ||
-            !patch.call ||
-            !patch.result ||
-            patch.failed ||
-            !patch.completed)
+        if (patch.toolName !== 'apply_patch' || !patch.call || !patch.result)
             return [];
-        const result = contextGcPatchResultFromCompletedPayload(patch.completed.payload);
-        return result ? [{ patch, result, evidenceSequence: patch.result.record.sequence }] : [];
+        const terminal = patch.failed ?? patch.completed;
+        if (!terminal)
+            return [];
+        const result = patch.failed
+            ? contextGcPatchResultFromFailedPayload(terminal.payload)
+            : contextGcPatchResultFromCompletedPayload(terminal.payload);
+        return result
+            ? [{ patch, result, terminal, evidenceSequence: patch.result.record.sequence }]
+            : [];
     })
         .sort((left, right) => left.evidenceSequence - right.evidenceSequence);
-    for (const { patch, result, evidenceSequence } of patches) {
+    for (const { patch, result, terminal, evidenceSequence } of patches) {
         const patchCall = patch.call;
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
         const candidateReadItems = new Set();
         const patchTarget = targetFor(patchCall.record, patchCall.message);
-        if (patchTarget && !existingTargets.has(contextGcTargetKey(patchTarget)))
+        if (!patch.failed && patchTarget && !existingTargets.has(contextGcTargetKey(patchTarget)))
             replacements.push({
                 kind: 'TOOL_CALL_INPUT',
                 toolName: 'apply_patch',
@@ -562,7 +565,7 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
                 evidenceSequence
             });
         for (const read of reads) {
-            if ((read.completed?.sequence ?? read.result.record.sequence) >= patch.completed.sequence)
+            if ((read.completed?.sequence ?? read.result.record.sequence) >= terminal.sequence)
                 continue;
             const parsed = parseReadContextOutput(read.result.message.content);
             if (!parsed)
@@ -953,11 +956,6 @@ function buildToolGroups(records, messages, sources) {
     for (const [index, message] of messages.entries()) {
         if (!message.observations || message.role !== 'tool')
             continue;
-        const outer = message.callId ? groups.get(message.callId) : undefined;
-        if (!outer?.completed ||
-            outer.failed ||
-            codeCellCompletionSequence(records, outer.completed) === undefined)
-            continue;
         const record = sources[index];
         for (const entry of message.calls ?? []) {
             if (![
@@ -969,9 +967,11 @@ function buildToolGroups(records, messages, sources) {
                 'agent_message',
                 'agent_cancel'
             ].includes(entry.toolName) ||
-                message.observations.some((value) => value.type === 'tool_result' && value.source.callId === entry.callId))
+                (entry.status === 'completed' &&
+                    message.observations.some((value) => value.type === 'tool_result' && value.source.callId === entry.callId)))
                 continue;
-            const evidence = codeCallEvidence(records, record, entry);
+            const evidence = codeCallEvidence(records, record, entry) ??
+                codePartialPatchCallEvidence(records, record, entry);
             if (!evidence)
                 continue;
             groups.set(`execution:${evidence.callId}`, {
@@ -979,7 +979,9 @@ function buildToolGroups(records, messages, sources) {
                 callId: evidence.callId,
                 toolName: entry.toolName,
                 aliases: [],
-                completed: evidence.completed,
+                ...('completed' in evidence
+                    ? { completed: evidence.completed }
+                    : { failed: evidence.failed }),
                 call: {
                     record: evidence.call,
                     message: {

package/dist/agent-core/runtime/events.d.ts

@@ -84,7 +84,7 @@ export type MarAgentEvent = MarAgentEventBase & ({
     data?: CodeCellEventData | import('../tools/contracts.js').ExecResult | Omit<import('../tools/contracts.js').ExecResult, 'stdout' | 'stderr'> | import('../tools/contracts.js').ApplyPatchResult | import('../tools/contracts.js').ReadEventData | import('../tools/contracts.js').ViewImageResult | import('../subagent/contracts.js').SubagentTaskSnapshot;
 } | {
     type: 'tool.failed';
-    data?: import('../tools/contracts.js').CodeCellEventData;
+    data?: CodeCellEventData | import('../tools/contracts.js').ApplyPatchPartialResult;
     toolName: string;
     callId: string;
     parentCallId?: string;

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

@@ -1,9 +1,9 @@
 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 { codeCallEvidence, codePartialPatchCallEvidence, 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 { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, 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;
 export const CONTEXT_GC_MAX_TARGETS = 4_096;
@@ -239,6 +239,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
     let source = recordsBySequence.get(replacement.target.sequence);
     if (!source || !isRecord(source.payload))
         return false;
+    let sourceToolSequence = source.sequence;
     if (replacement.target.observationId) {
         const selected = observationsFromRecord(source)?.find((value) => value.id === replacement.target.observationId);
         if (!selected)
@@ -247,6 +248,7 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
             const evidence = codeObservationEvidence(records, source, selected);
             if (!evidence)
                 return false;
+            sourceToolSequence = evidence.completed.sequence;
             source = {
                 ...source,
                 payload: {
@@ -273,7 +275,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, item.supersededByCallId);
+            const evidence = appliedPatchEvidenceForPath(records, recordsBySequence, item.evidenceSequence, item.path, workspace, platform, sourceToolSequence, item.supersededByCallId);
             return (original?.pathTruncated === false &&
                 original?.path === item.path &&
                 evidence !== undefined &&
@@ -531,12 +533,47 @@ function modelToolResultForCall(records, call, beforeSequence) {
         record.payload.role === 'tool' &&
         record.payload.callId === callId);
 }
-function successfulPatchEvidenceForPath(records, recordsBySequence, evidenceSequence, path, workspace, platform, expectedCallId) {
-    const evidence = successfulToolEvidence(records, recordsBySequence, evidenceSequence, 'apply_patch', expectedCallId);
-    if (!evidence || !isRecord(evidence.completed.payload))
+function partialPatchEvidence(records, recordsBySequence, evidenceSequence, expectedCallId) {
+    const result = recordsBySequence.get(evidenceSequence);
+    if (result?.type !== 'model.context' ||
+        !isRecord(result.payload) ||
+        result.payload.role !== 'tool' ||
+        typeof result.payload.callId !== 'string')
         return undefined;
-    const result = contextGcPatchResultFromCompletedPayload(evidence.completed.payload);
-    if (!result)
+    const callId = result.payload.callId;
+    const call = modelToolCallForCallId(records, callId, result.sequence);
+    if (!call ||
+        !isRecord(call.payload) ||
+        call.payload.name !== 'apply_patch' ||
+        (expectedCallId && callId !== expectedCallId)) {
+        for (const entry of callsFromRecord(result) ?? []) {
+            if (expectedCallId && entry.callId !== expectedCallId)
+                continue;
+            const evidence = codePartialPatchCallEvidence(records, result, entry);
+            if (evidence)
+                return evidence;
+        }
+        return undefined;
+    }
+    const failed = records.findLast((record) => record.sequence > call.sequence &&
+        record.sequence < result.sequence &&
+        record.type === 'tool.failed' &&
+        isRecord(record.payload) &&
+        record.payload.callId === callId &&
+        contextGcPatchResultFromFailedPayload(record.payload) !== undefined);
+    return failed ? { callId, call, failed, result } : undefined;
+}
+function appliedPatchEvidenceForPath(records, recordsBySequence, evidenceSequence, path, workspace, platform, readSequence, expectedCallId) {
+    const evidence = successfulToolEvidence(records, recordsBySequence, evidenceSequence, 'apply_patch', expectedCallId);
+    const partial = evidence
+        ? undefined
+        : partialPatchEvidence(records, recordsBySequence, evidenceSequence, expectedCallId);
+    const callId = evidence?.callId ?? partial?.callId;
+    const terminalSequence = evidence?.completed.sequence ?? partial?.failed.sequence;
+    const result = evidence
+        ? contextGcPatchResultFromCompletedPayload(evidence.completed.payload)
+        : contextGcPatchResultFromFailedPayload(partial?.failed.payload);
+    if (!result || !callId || terminalSequence === undefined || readSequence >= terminalSequence)
         return undefined;
     const expected = contextGcLogicalPathKey(path, workspace, platform);
     if (!expected)
@@ -544,7 +581,7 @@ function successfulPatchEvidenceForPath(records, recordsBySequence, evidenceSequ
     const file = result.files.find((file) => file.operation !== 'added' &&
         contextGcLogicalPathKey(file.path, workspace, platform) === expected);
     return file && file.operation !== 'added'
-        ? { callId: evidence.callId, file: { operation: file.operation } }
+        ? { callId, file: { operation: file.operation } }
         : undefined;
 }
 function isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence) {

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

@@ -7,7 +7,22 @@ export declare function codeObservationEvidence(records: readonly SessionRecord[
     callId: string;
     call: SessionRecord;
     completed: SessionRecord;
-    result: SessionRecord;
+    result: {
+        payload: {
+            role: string;
+            callId: string;
+            content: string;
+            observationId: string;
+        };
+        schemaVersion: 1;
+        recordId: string;
+        sequence: number;
+        timestamp: string;
+        sessionId: string;
+        executionId?: string;
+        turnId?: string;
+        type: string;
+    };
 } | undefined;
 export declare function observationsFromRecord(record: SessionRecord): CodeObservation[] | undefined;
 export declare function codeCallEvidence(records: readonly SessionRecord[], result: SessionRecord, entry: CodeToolCallRecord): {
@@ -30,6 +45,13 @@ export declare function codeCallEvidence(records: readonly SessionRecord[], resu
     call: SessionRecord;
     completed: SessionRecord;
 } | undefined;
+/** Failed patch calls can prove applied file units, never successful input reclamation. */
+export declare function codePartialPatchCallEvidence(records: readonly SessionRecord[], result: SessionRecord, entry: CodeToolCallRecord): {
+    callId: string;
+    call: SessionRecord;
+    failed: SessionRecord;
+    result: SessionRecord;
+} | undefined;
 export declare function callsFromRecord(record: SessionRecord): CodeToolCallRecord[] | undefined;
 export declare function retainedCodeInputs(records: readonly SessionRecord[], parentCallId: string): {
     callId: unknown;

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

@@ -1,17 +1,36 @@
 import { isDeepStrictEqual } from 'node:util';
-import { codeCellCompletionSequence, contextGcPatchResultFromCompletedPayload } from './context-gc-replacements.js';
+import { codeCellCompletionSequence, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload } 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 evidence = codeToolEvidence(records, result, observation.source, 'completed');
+    if (!evidence)
+        return undefined;
+    return {
+        callId: evidence.callId,
+        call: evidence.call,
+        completed: evidence.terminal,
+        result: {
+            ...result,
+            payload: {
+                role: 'tool',
+                callId: evidence.callId,
+                content: observation.result.content,
+                observationId: observation.id
+            }
+        }
+    };
+}
+function codeToolEvidence(records, result, source, outcome) {
     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 &&
+        record.payload.callId === source.callId &&
+        record.payload.toolName === source.toolName &&
         typeof record.payload.parentCallId === 'string' &&
-        isDeepStrictEqual(record.payload.input, observation.source.input));
+        isDeepStrictEqual(record.payload.input, source.input));
     if (!started || !isRecord(started.payload))
         return undefined;
     const parentId = started.payload.parentCallId;
@@ -28,16 +47,20 @@ export function codeObservationEvidence(records, result, observation) {
         return undefined;
     const outerId = original.payload.callId;
     const outer = records.findLast((record) => record.sequence < result.sequence &&
-        record.type === 'tool.completed' &&
+        (record.type === 'tool.completed' ||
+            (outcome === 'failed' && record.type === 'tool.failed')) &&
         isRecord(record.payload) &&
         record.payload.callId === outerId &&
         (record.payload.toolName === 'code_exec' || 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))
+        (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)))
         return undefined;
     if (original.payload.callId !== parentId) {
         const initial = records.find((record) => record.sequence < outer.sequence &&
@@ -56,37 +79,44 @@ export function codeObservationEvidence(records, result, observation) {
     }
     const completed = records.findLast((record) => record.sequence > started.sequence &&
         record.sequence < result.sequence &&
-        record.type === 'tool.completed' &&
+        record.type === `tool.${outcome}` &&
         isRecord(record.payload) &&
-        record.payload.callId === observation.source.callId &&
-        record.payload.toolName === observation.source.toolName &&
+        record.payload.callId === source.callId &&
+        record.payload.toolName === source.toolName &&
         record.payload.parentCallId === parentId);
     if (!completed ||
         records.some((record) => record.sequence > started.sequence &&
             record.sequence < result.sequence &&
-            record.type === 'tool.failed' &&
+            record.type === (outcome === 'completed' ? 'tool.failed' : 'tool.completed') &&
             isRecord(record.payload) &&
-            record.payload.callId === observation.source.callId))
+            record.payload.callId === source.callId))
         return undefined;
     const call = {
         ...started,
         payload: {
             role: 'tool_call',
-            name: observation.source.toolName,
-            callId: observation.source.callId,
-            arguments: observation.source.input
+            name: source.toolName,
+            callId: source.callId,
+            arguments: 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 };
+    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;
@@ -115,6 +145,15 @@ export function codeCallEvidence(records, result, entry) {
         }
     };
 }
+/** Failed patch calls can prove applied file units, never successful input reclamation. */
+export function codePartialPatchCallEvidence(records, result, entry) {
+    if (entry.status !== 'failed' || entry.toolName !== 'apply_patch')
+        return undefined;
+    const evidence = codeToolEvidence(records, result, { callId: entry.callId, toolName: entry.toolName, input: entry.input }, 'failed');
+    if (!evidence || !contextGcPatchResultFromFailedPayload(evidence.terminal.payload))
+        return undefined;
+    return { callId: evidence.callId, call: evidence.call, failed: evidence.terminal, result };
+}
 export function callsFromRecord(record) {
     return isRecord(record.payload) ? parseCodeCalls(record.payload.calls) : undefined;
 }

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

@@ -46,6 +46,7 @@ export type ContextGcExecResult = {
     readonly modelContextContent: string;
 };
 export declare function contextGcPatchResultFromCompletedPayload(payload: unknown): ContextGcPatchResult | undefined;
+export declare function contextGcPatchResultFromFailedPayload(payload: unknown): ContextGcPatchResult | undefined;
 export declare function contextGcApplyPatchInputReplacement(arguments_: unknown, result: ContextGcPatchResult, evidenceSequence: number, formatVersion?: 1 | 2): string;
 export declare function contextGcStaleReadReplacement(input: {
     readonly path: string;

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

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { parseApplyPatchResult, parseApplyPatchPartialResult } from '../tools/shared/patch-result.js';
 const RAW_MODEL_CONTEXT_PREVIEW_CHARACTERS = 256;
 const EXEC_INPUT_COMPLETE_CHARACTERS = 512;
 const EXEC_INPUT_PREVIEW_CHARACTERS = 256;
@@ -36,45 +37,16 @@ export function contextGcCodeModeOutputReplacement(originalContent, truncated) {
 export function contextGcPatchResultFromCompletedPayload(payload) {
     if (!isRecord(payload) || payload.type !== 'tool.completed')
         return undefined;
-    const data = payload.data;
-    if (!isRecord(data) || !Array.isArray(data.files) || !isRecord(data.totals))
-        return undefined;
-    const files = data.files.flatMap((file) => isRecord(file) &&
-        isNonemptyString(file.path) &&
-        (file.operation === 'added' ||
-            file.operation === 'modified' ||
-            file.operation === 'deleted' ||
-            file.operation === 'moved') &&
-        (file.targetPath === undefined || isNonemptyString(file.targetPath)) &&
-        isNonnegativeInteger(file.addedLines) &&
-        isNonnegativeInteger(file.deletedLines)
-        ? [
-            {
-                path: file.path,
-                ...(typeof file.targetPath === 'string' ? { targetPath: file.targetPath } : {}),
-                operation: file.operation,
-                addedLines: file.addedLines,
-                deletedLines: file.deletedLines
-            }
-        ]
-        : []);
-    if (files.length !== data.files.length ||
-        files.length === 0 ||
-        !isNonnegativeInteger(data.totals.files) ||
-        !isNonnegativeInteger(data.totals.addedLines) ||
-        !isNonnegativeInteger(data.totals.deletedLines) ||
-        data.totals.files !== files.length ||
-        data.totals.addedLines !== files.reduce((total, file) => total + file.addedLines, 0) ||
-        data.totals.deletedLines !== files.reduce((total, file) => total + file.deletedLines, 0))
+    const result = parseApplyPatchResult(payload.data);
+    return result?.files.length ? result : undefined;
+}
+export function contextGcPatchResultFromFailedPayload(payload) {
+    if (!isRecord(payload) ||
+        payload.type !== 'tool.failed' ||
+        payload.toolName !== 'apply_patch' ||
+        payload.code !== 'MAR_AGENT_PATCH_PARTIAL')
         return undefined;
-    return {
-        files,
-        totals: {
-            files: data.totals.files,
-            addedLines: data.totals.addedLines,
-            deletedLines: data.totals.deletedLines
-        }
-    };
+    return parseApplyPatchPartialResult(payload.data);
 }
 export function contextGcApplyPatchInputReplacement(arguments_, result, evidenceSequence, formatVersion = 2) {
     const original = typeof arguments_ === 'string' ? arguments_ : stableJson(arguments_);

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

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../../error.js';
 import { AGENT_EXECUTION_POLICY } from '../../runtime/execution-policy.js';
 import { allowsToolCaller } from '../callers.js';
-import { boundedModelToolOutput, structuredToolEventData } from '../output-projection.js';
+import { boundedModelToolOutput, structuredToolEventData, structuredToolFailureData } from '../output-projection.js';
 import { executeRegisteredTool } from '../runtime.js';
 /** Capture only the cell's immutable dispatch identity, never the model loop or its AbortSignal. */
 export function createCodeToolDispatch(input) {
@@ -56,11 +56,13 @@ export function createCodeToolDispatch(input) {
                     throw error;
                 }
                 const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
+                const data = structuredToolFailureData(call.name, error);
                 await input.emit({
                     type: 'tool.failed',
                     ...identity,
                     code: diagnostic.code,
-                    message: diagnostic.message
+                    message: diagnostic.message,
+                    ...(data === undefined ? {} : { data })
                 });
                 throw error;
             }

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

@@ -15,6 +15,7 @@ import { BoundedTextOutput, renderCapturedText } from './text-output.js';
 import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { createToolCallScheduler } from '../scheduler.js';
 import { detectImageMime } from '../local/view-image.js';
+import { structuredToolFailureData } from '../output-projection.js';
 export const codeModeToolDefinition = {
     name: 'code_exec',
     description: `Run JavaScript to orchestrate or compose tool calls.
@@ -511,6 +512,7 @@ export class CodeModeTool {
                         if (context.signal.aborted)
                             return;
                         const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
+                        const data = structuredToolFailureData(source.toolName, error);
                         recordCall({
                             ...source,
                             status: 'failed',
@@ -520,7 +522,12 @@ export class CodeModeTool {
                             source,
                             outcome: 'failed',
                             result: {
-                                content: JSON.stringify({ error: diagnostic.code, message: diagnostic.message })
+                                content: JSON.stringify({
+                                    error: diagnostic.code,
+                                    message: diagnostic.message,
+                                    ...(data === undefined ? {} : { data })
+                                }),
+                                ...(data === undefined ? {} : { data })
                             }
                         });
                         await write({

package/dist/agent-core/tools/contracts.d.ts

@@ -132,6 +132,10 @@ export interface ApplyPatchResult {
         deletedLines: number;
     };
 }
+export interface ApplyPatchPartialResult extends ApplyPatchResult {
+    failedFile: string;
+    pendingFiles: string[];
+}
 export interface ReadEventData {
     mode: 'batch';
     results: Array<{

package/dist/agent-core/tools/execution.js

@@ -3,7 +3,7 @@ import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { allowsToolCaller } from './callers.js';
 import { CodeCellExecutionError } from './code-mode/cells.js';
 import { createCodeToolDispatch } from './code-mode/dispatch.js';
-import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData } from './output-projection.js';
+import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
 import { executeRegisteredTool } from './runtime.js';
 import { scheduleToolCallBatch } from './scheduler.js';
 /** Shared raw context construction for physical tools and native calls in a real model round. */
@@ -114,6 +114,11 @@ export async function executeRoundTools(calls, scope) {
         catch (error) {
             const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
             const partial = error instanceof CodeCellExecutionError ? error.result : undefined;
+            const failureData = structuredToolFailureData(call.name, error);
+            const eventData = failureData ??
+                (partial?.data === undefined
+                    ? undefined
+                    : structuredToolEventData(call.name, partial.data));
             await scope.emit({
                 type: 'tool.failed',
                 toolName: call.name,
@@ -121,20 +126,17 @@ export async function executeRoundTools(calls, scope) {
                 ...(parentCallId === undefined ? {} : { parentCallId }),
                 code: diagnostic.code,
                 message: diagnostic.message,
-                ...(partial?.data === undefined
-                    ? {}
-                    : {
-                        data: structuredToolEventData(call.name, partial.data)
-                    })
+                ...(eventData === undefined ? {} : { data: eventData })
             });
             return {
                 call,
                 content: partial === undefined
-                    ? JSON.stringify({
+                    ? boundedModelToolOutput(call.name, JSON.stringify({
                         error: diagnostic.code,
                         message: diagnostic.message,
+                        ...(failureData === undefined ? {} : { data: failureData }),
                         ...(error instanceof MarAgentError && error.retryable ? { retryable: true } : {})
-                    })
+                    }), failureData).content
                     : boundedModelToolOutput(call.name, partial.content, partial.data).content,
                 ...(partial?.images?.length ? { images: partial.images } : {}),
                 failed: true,

package/dist/agent-core/tools/local/apply-patch.js

@@ -526,7 +526,17 @@ function partialPatchError(cause, appliedResults, pendingChanges) {
     return new MarAgentError('MAR_AGENT_PATCH_PARTIAL', `Patch partially applied. Applied: ${summarizePaths(appliedFiles)}. Failed: ${failedFile}. Pending: ${summarizePaths(pendingFiles)}. Retry only failed and pending paths.`, {
         cause,
         retryable: true,
-        details: { appliedFiles, failedFile, pendingFiles }
+        details: {
+            appliedFiles,
+            failedFile,
+            pendingFiles,
+            files: appliedResults,
+            totals: {
+                files: appliedResults.length,
+                addedLines: appliedResults.reduce((total, file) => total + file.addedLines, 0),
+                deletedLines: appliedResults.reduce((total, file) => total + file.deletedLines, 0)
+            }
+        }
     });
 }
 function resultPath(result) {

package/dist/agent-core/tools/output-projection.d.ts

@@ -1,5 +1,5 @@
 import type { SubagentTaskSnapshot } from '../subagent/contracts.js';
-import type { ApplyPatchResult, CodeCellEventData, ExecResult, MarAgentToolArtifact, ToolExecutionResult, ReadEventData, ViewImageResult } from './contracts.js';
+import type { ApplyPatchResult, ApplyPatchPartialResult, CodeCellEventData, ExecResult, MarAgentToolArtifact, ToolExecutionResult, ReadEventData, ViewImageResult } from './contracts.js';
 import type { ToolRuntimeImage } from './runtime-context.js';
 export declare function currentExecutionImages(modelInputImages: readonly {
     readonly mimeType: string;
@@ -11,6 +11,8 @@ export declare function boundedModelToolOutput(toolName: string, value: string,
 };
 /** Project only known, validated tool result shapes into public structured events. */
 export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SubagentTaskSnapshot | undefined;
+/** Partial patch facts are allowlisted; arbitrary error details never become public event data. */
+export declare function structuredToolFailureData(toolName: string, error: unknown): ApplyPatchPartialResult | undefined;
 export declare function structuredToolArtifacts(value: readonly MarAgentToolArtifact[] | undefined): readonly MarAgentToolArtifact[] | undefined;
 /** Shared result contract for model, programmatic, and native API callers. */
 export declare function validateToolResult(value: ToolExecutionResult): ToolExecutionResult;

package/dist/agent-core/tools/output-projection.js

@@ -1,4 +1,5 @@
 import { MarAgentError } from '../error.js';
+import { parseApplyPatchResult, parseApplyPatchPartialResult } from './shared/patch-result.js';
 import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { countModelTokens, countTextLines, truncateModelText } from '../runtime/token-budget.js';
 import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
@@ -127,25 +128,18 @@ export function structuredToolEventData(toolName, value) {
         isNonnegativeInteger(value.stdoutDroppedBytes) &&
         isNonnegativeInteger(value.stderrDroppedBytes))
         return value;
-    if (toolName === 'apply_patch' &&
-        Array.isArray(value.files) &&
-        value.files.every((file) => isRecord(file) &&
-            typeof file.path === 'string' &&
-            file.path.length > 0 &&
-            (file.targetPath === undefined || typeof file.targetPath === 'string') &&
-            (file.operation === 'added' ||
-                file.operation === 'modified' ||
-                file.operation === 'deleted' ||
-                file.operation === 'moved') &&
-            isNonnegativeInteger(file.addedLines) &&
-            isNonnegativeInteger(file.deletedLines)) &&
-        isRecord(value.totals) &&
-        isNonnegativeInteger(value.totals.files) &&
-        isNonnegativeInteger(value.totals.addedLines) &&
-        isNonnegativeInteger(value.totals.deletedLines))
-        return value;
+    if (toolName === 'apply_patch')
+        return parseApplyPatchResult(value);
     return undefined;
 }
+/** Partial patch facts are allowlisted; arbitrary error details never become public event data. */
+export function structuredToolFailureData(toolName, error) {
+    return toolName === 'apply_patch' &&
+        error instanceof MarAgentError &&
+        error.code === 'MAR_AGENT_PATCH_PARTIAL'
+        ? parseApplyPatchPartialResult(error.details)
+        : undefined;
+}
 export function structuredToolArtifacts(value) {
     if (value === undefined)
         return undefined;

package/dist/agent-core/tools/shared/patch-result.d.ts

@@ -0,0 +1,4 @@
+import type { ApplyPatchPartialResult, ApplyPatchResult } from '../contracts.js';
+/** Keep event projection and persisted GC evidence on the same file-result contract. */
+export declare function parseApplyPatchResult(value: unknown): ApplyPatchResult | undefined;
+export declare function parseApplyPatchPartialResult(value: unknown): ApplyPatchPartialResult | undefined;

package/dist/agent-core/tools/shared/patch-result.js

@@ -0,0 +1,66 @@
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
+/** Keep event projection and persisted GC evidence on the same file-result contract. */
+export function parseApplyPatchResult(value) {
+    if (!isRecord(value) ||
+        !Array.isArray(value.files) ||
+        value.files.length > TOOL_EXECUTION_LIMITS.patchMaxFiles ||
+        !isRecord(value.totals))
+        return undefined;
+    const files = [];
+    for (const file of value.files) {
+        if (!isRecord(file) ||
+            !isPath(file.path) ||
+            (file.operation !== 'added' &&
+                file.operation !== 'modified' &&
+                file.operation !== 'deleted' &&
+                file.operation !== 'moved') ||
+            (file.targetPath !== undefined && !isPath(file.targetPath)) ||
+            (file.operation === 'moved' && !isPath(file.targetPath)) ||
+            !isCount(file.addedLines) ||
+            !isCount(file.deletedLines))
+            return undefined;
+        files.push({
+            path: file.path,
+            operation: file.operation,
+            ...(typeof file.targetPath === 'string' ? { targetPath: file.targetPath } : {}),
+            addedLines: file.addedLines,
+            deletedLines: file.deletedLines
+        });
+    }
+    const totals = value.totals;
+    if (!isCount(totals.files) ||
+        !isCount(totals.addedLines) ||
+        !isCount(totals.deletedLines) ||
+        totals.files !== files.length ||
+        totals.addedLines !== files.reduce((n, file) => n + file.addedLines, 0) ||
+        totals.deletedLines !== files.reduce((n, file) => n + file.deletedLines, 0))
+        return undefined;
+    return {
+        files,
+        totals: {
+            files: totals.files,
+            addedLines: totals.addedLines,
+            deletedLines: totals.deletedLines
+        }
+    };
+}
+export function parseApplyPatchPartialResult(value) {
+    const result = parseApplyPatchResult(value);
+    if (!result?.files.length ||
+        !isRecord(value) ||
+        !isPath(value.failedFile) ||
+        !Array.isArray(value.pendingFiles) ||
+        !value.pendingFiles.every(isPath) ||
+        result.files.length + value.pendingFiles.length + 1 > TOOL_EXECUTION_LIMITS.patchMaxFiles)
+        return undefined;
+    return { ...result, failedFile: value.failedFile, pendingFiles: [...value.pendingFiles] };
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function isPath(value) {
+    return typeof value === 'string' && value.length > 0 && !value.includes('\0');
+}
+function isCount(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}

package/dist/index.d.ts

@@ -37,7 +37,7 @@ export type { CoreProcessesApi, CoreProcessesBackend, CoreProcessInput, CoreProc
 export type { CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, MarAgent, MarAgentSession, SessionTitleUpdateInput } from './agent-core/sdk/types.js';
 export { openMarAgentSessionCatalog, type MarAgentContextUsage, type MarAgentHistoryEntry, type MarAgentHistoryPage, type MarAgentSessionCatalog, type MarAgentSessionDeleteResult, type MarAgentSessionImage, type MarAgentSessionPage, type MarAgentSessionSummary } from './agent-core/session/catalog.js';
 export type { SessionListInput, SessionSource } from './agent-core/session/types.js';
-export type { ApplyPatchFileResult, ApplyPatchResult, ClientToolDefinition, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolCaller, ToolExecutionContext, ToolExecutionResult } from './agent-core/tools/contracts.js';
+export type { ApplyPatchFileResult, ApplyPatchResult, ApplyPatchPartialResult, ClientToolDefinition, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolCaller, ToolExecutionContext, ToolExecutionResult } from './agent-core/tools/contracts.js';
 export { MCP_DEFINITION_LIMITS, assertMcpToolCatalog, assertMcpToolDefinition } from './agent-core/tools/mcp/catalog.js';
 export type { WorkspacePathMount } from './agent-core/tools/shared/path-resolver.js';
 export type { CodeModeEngine, CodeModeEngineFactory, CreateCodeModeEngine } from './agent-core/tools/code-mode/engine.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",