@myagentroam/agent 0.9.159 → 0.9.161

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

@@ -8,5 +8,5 @@ export declare function agentStartToolDefinitionWithModels(models: readonly {
 }[]): ClientToolDefinition;
 export declare function executeAgentStart(arguments_: unknown, context: ToolRuntimeContext): Promise<{
     content: string;
-    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
+    data: import("../../subagent/contracts.js").SubagentRunResult;
 }>;

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

@@ -22,26 +22,16 @@ function options(value, wait) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Exec options must be an object.');
     const input = value;
-    const keys = wait
-        ? ['cellId', 'yieldMs', 'maxOutputTokens', 'action']
-        : ['yieldMs', 'maxOutputTokens'];
-    if (Object.keys(input).some((key) => !keys.includes(key)))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Unknown Code Exec option.');
     const yieldMs = input.yieldMs ?? (wait ? limits.codeDefaultWaitYieldMs : limits.codeDefaultYieldMs);
-    const maxOutputTokens = input.maxOutputTokens ?? limits.codeMaxOutputTokens;
     if (!Number.isSafeInteger(yieldMs) ||
         Number(yieldMs) < 0 ||
         Number(yieldMs) > (wait ? limits.codeMaxWaitYieldMs : limits.codeMaxYieldMs) ||
-        !Number.isSafeInteger(maxOutputTokens) ||
-        Number(maxOutputTokens) < 1 ||
-        Number(maxOutputTokens) > limits.codeMaxOutputTokens ||
         (wait && (typeof input.cellId !== 'string' || !input.cellId)) ||
         (input.action !== undefined && input.action !== 'poll' && input.action !== 'cancel'))
         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Exec options are out of range.');
     return {
         cellId: input.cellId,
         yieldMs: Number(yieldMs),
-        maxOutputTokens: Number(maxOutputTokens),
         action: input.action ?? 'poll'
     };
 }
@@ -208,12 +198,12 @@ export class CodeCells {
             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 bounded = boundObservations(cell.terminal.observations, limits.codeMaxOutputTokens);
                 const visible = selectObservationImages(bounded.observations, cell.terminal.images ?? []);
                 const original = cell.terminal.data;
                 const data = {
                     ...original,
-                    output: truncateModelText(original.output ?? '', input.maxOutputTokens).content,
+                    output: truncateModelText(original.output ?? '', limits.codeMaxOutputTokens).content,
                     observations: visible.observations,
                     cached: true,
                     truncated: cell.terminal.truncated === true || bounded.truncated
@@ -233,7 +223,7 @@ export class CodeCells {
                 };
             }
             const snapshot = cell.terminal.data;
-            const bounded = truncateModelText(snapshot.output, input.maxOutputTokens);
+            const bounded = truncateModelText(snapshot.output, limits.codeMaxOutputTokens);
             const data = {
                 ...snapshot,
                 output: bounded.content,
@@ -251,7 +241,7 @@ export class CodeCells {
         const images = cell.images.splice(0);
         const text = renderCapturedText(captured, images.length);
         cell.yielded = false;
-        const bounded = truncateModelText(text, input.maxOutputTokens);
+        const bounded = truncateModelText(text, limits.codeMaxOutputTokens);
         const pending = cell.observations.splice(0);
         if (!pending.length && captured.text)
             pending.push({
@@ -261,7 +251,7 @@ export class CodeCells {
                 value: captured.text,
                 truncated: captured.droppedBytes > 0
             });
-        const structured = boundObservations(pending, input.maxOutputTokens);
+        const structured = boundObservations(pending, limits.codeMaxOutputTokens);
         const visible = selectObservationImages(structured.observations, images, cell.imageOffset);
         const remapped = visible.observations;
         const visibleImages = visible.images;

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

@@ -14,6 +14,7 @@ export declare function createCodeToolDispatch(input: {
     expectations: ReadonlyMap<string, McpToolCallContext['expectedTool']>;
     parentCallId: string;
     schedule: ReturnType<typeof createSessionToolScheduler>;
+    assertLive: () => void;
     emit: (event: Payload) => Promise<void>;
 }): (call: ToolCall, signal: AbortSignal) => Promise<ToolExecutionResult>;
 export {};

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

@@ -8,24 +8,29 @@ import { executeRegisteredTool } from '../runtime.js';
 export function createCodeToolDispatch(input) {
     const definitions = new Map(input.tools.map((tool) => [tool.name, tool]));
     return async (call, signal) => {
+        input.assertLive();
         const definition = definitions.get(call.name);
         if (!definition || !allowsToolCaller(definition, 'programmatic'))
             throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'The requested nested tool is unavailable.');
         return input.schedule(definition, async () => {
+            input.assertLive();
             signal.throwIfAborted();
             const callId = call.callId ?? randomUUID();
             const identity = { toolName: call.name, callId, parentCallId: input.parentCallId };
             await input.emit({ type: 'tool.started', ...identity, input: call.arguments });
             try {
+                input.assertLive();
+                signal.throwIfAborted();
                 const expected = input.expectations.get(call.name);
                 const result = await executeRegisteredTool(call.name, call.arguments, callId, {
                     ...input.context,
                     signal,
                     ...(expected ? { expectedMcpTool: expected } : {})
-                });
+                }, 'programmatic');
                 const bounded = boundedModelToolOutput(call.name, result.content, result.data);
                 const data = structuredToolEventData(call.name, result.data);
                 const summary = result.content.slice(0, AGENT_EXECUTION_POLICY.toolEventSummaryCharacters);
+                input.assertLive();
                 await input.emit({
                     type: 'tool.completed',
                     ...identity,
@@ -43,6 +48,13 @@ export function createCodeToolDispatch(input) {
                 };
             }
             catch (error) {
+                // Retirement must not enqueue a failure event into the replacement Session epoch.
+                try {
+                    input.assertLive();
+                }
+                catch {
+                    throw error;
+                }
                 const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
                 await input.emit({
                     type: 'tool.failed',

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

@@ -39,7 +39,7 @@ Built-in namespaces:
 - catalog.tools() returns a read-only snapshot of the tools callable in this cell, including name, description, inputSchema and inputMode. It does not discover or authorize additional tools.
 - await cell.sleep(ms) performs a cancellable delay up to ${limits.codeSleepMaxMs} ms.
 - await cell.yield_control() returns accumulated output to the model immediately while this cell continues running.
-- Optionally start source with // @options: {"yieldMs": ${limits.codeDefaultYieldMs}, "maxOutputTokens": 10000}. yieldMs defaults to ${limits.codeDefaultYieldMs} ms and controls this call's wait window (0..${limits.codeMaxYieldMs}), not nested tool timeouts or wait windows. A running result includes cellId; use direct code_exec_wait for new output, completion or termination.
+- Optionally start source with // @options: {"yieldMs": ${limits.codeDefaultYieldMs}}. yieldMs defaults to ${limits.codeDefaultYieldMs} ms and controls this call's wait window (0..${limits.codeMaxYieldMs}), not nested tool timeouts or wait windows. A running result includes cellId; use direct code_exec_wait for new output, completion or termination.
 - Registered cells are Session warm resources: ending or cancelling the model Execution cancels its wait, not the cell. Reuse retained cellId; do not start duplicate work. Host cleanup or explicit termination stops the cell.
 - tools, observe, state, catalog and cell are frozen bindings. Do not shadow their names.
 
@@ -85,7 +85,6 @@ export const codeExecWaitToolDefinition = {
                 default: limits.codeDefaultWaitYieldMs,
                 description: `Wait up to this many milliseconds. Defaults to ${limits.codeDefaultWaitYieldMs}; maximum ${limits.codeMaxWaitYieldMs}. Zero returns immediately without stopping the cell. Waiting does not restart the cell or extend nested tool timeouts.`
             },
-            maxOutputTokens: { type: 'integer', minimum: 1, maximum: limits.codeMaxOutputTokens },
             action: {
                 type: 'string',
                 enum: ['poll', 'cancel'],

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

@@ -85,6 +85,9 @@ export declare function boundObservations(values: readonly CodeObservation[], ma
 export declare function newObservationId(): string;
 export declare function observationModelParts(message: {
     content?: string;
+    textBlocks?: readonly {
+        readonly text: string;
+    }[];
     observations?: readonly CodeObservation[];
     images?: readonly {
         mimeType: string;
@@ -100,4 +103,6 @@ export declare function observationModelParts(message: {
         dataBase64: string;
     };
 }> | undefined;
+/** Uses the same visible text as both adapters, without pixels or private observation data. */
+export declare function observationModelText(message: Parameters<typeof observationModelParts>[0]): string | undefined;
 export declare function parseObservations(value: unknown): CodeObservation[] | undefined;

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

@@ -69,6 +69,11 @@ export function visibleObservation(value) {
 export function renderObservations(values) {
     return JSON.stringify(values.map(visibleObservation));
 }
+function visibleObservationText(value) {
+    const { content: _content, value: _value, ...header } = visibleObservation(value);
+    const body = observationContent(value);
+    return JSON.stringify(header) + (body.length ? `\n${body}` : '');
+}
 export function renderObservationResult(values, original) {
     try {
         const envelope = JSON.parse(original);
@@ -89,7 +94,7 @@ export function boundObservations(values, maximumTokens) {
         const empty = original.type === 'tool_result'
             ? { ...original, result: { ...original.result, content: '', truncated: true } }
             : { ...original, value: '', truncated: true };
-        const overhead = countModelTokens(JSON.stringify(visibleObservation(empty))) + 8;
+        const overhead = countModelTokens(visibleObservationText(empty)) + 8;
         if (overheadBudget + overhead > remaining) {
             truncated = true;
             break;
@@ -119,7 +124,7 @@ export function boundObservations(values, maximumTokens) {
                         value: bounded.content,
                         truncated: original.truncated === true || bodyTruncated
                     };
-            if (countModelTokens(JSON.stringify(visibleObservation(value))) + 1 <=
+            if (countModelTokens(visibleObservationText(value)) + 1 <=
                 remaining - (overheadBudget - overhead) ||
                 bodyBudget === 0)
                 break;
@@ -127,7 +132,7 @@ export function boundObservations(values, maximumTokens) {
         }
         overheadBudget -= overhead;
         observations.push(value);
-        remaining -= countModelTokens(JSON.stringify(visibleObservation(value))) + 1;
+        remaining -= countModelTokens(visibleObservationText(value)) + 1;
         truncated ||=
             bodyTruncated ||
                 (original.type === 'tool_result'
@@ -140,7 +145,7 @@ export function newObservationId() {
     return randomUUID();
 }
 export function observationModelParts(message) {
-    if (!message.observations || !message.images?.length)
+    if (message.textBlocks !== undefined || !message.observations?.length)
         return undefined;
     const prefix = [];
     try {
@@ -154,7 +159,7 @@ export function observationModelParts(message) {
     return [
         ...prefix,
         ...message.observations.flatMap((value) => {
-            const parts = [{ type: 'text', text: JSON.stringify(visibleObservation(value)) }];
+            const parts = [{ type: 'text', text: visibleObservationText(value) }];
             for (const index of observationImages(value)) {
                 const image = message.images?.[index];
                 if (image)
@@ -164,6 +169,12 @@ export function observationModelParts(message) {
         })
     ];
 }
+/** Uses the same visible text as both adapters, without pixels or private observation data. */
+export function observationModelText(message) {
+    return observationModelParts(message)
+        ?.flatMap((part) => (part.type === 'text' ? [part.text] : []))
+        .join('\n');
+}
 export function parseObservations(value) {
     if (!Array.isArray(value) || value.length > 4096)
         return undefined;

package/dist/agent-core/tools/code-mode/quickjs-engine.js

@@ -111,8 +111,13 @@ export async function createCodeModeEngine(options) {
           'WebSocket', 'WebAssembly', 'SharedArrayBuffer', 'Atomics', 'text', 'image'])
           delete globalThis[name];
         globalThis.__parseJson = JSON.parse;
-        globalThis.__serialize = value => {
-          return JSON.stringify(value, (_key, item) => {
+        globalThis.__serialize = (value, toolInput = false) => {
+          let root = true;
+          return JSON.stringify(value, function (_key, item) {
+            const first = root;
+            root = false;
+            if (toolInput && !first && !Array.isArray(this) && typeof item === 'undefined')
+              return undefined;
             if (['bigint', 'function', 'symbol', 'undefined'].includes(typeof item))
               throw Object.assign(new TypeError('Only JSON values may cross the tool bridge.'),
                 { code: 'MAR_AGENT_TOOL_INPUT_INVALID' });
@@ -183,8 +188,8 @@ export async function createCodeModeEngine(options) {
                     handle.dispose();
                 }
             };
-            const jsonValue = (handle) => {
-                const result = callGuest(serialize, vm.undefined, handle);
+            const jsonValue = (handle, toolInput = false) => {
+                const result = callGuest(serialize, vm.undefined, handle, toolInput ? vm.true : vm.false);
                 if (result.error)
                     return { error: result.error };
                 try {
@@ -222,7 +227,7 @@ export async function createCodeModeEngine(options) {
             let toolCallSequence = 0;
             for (const name of input.tools) {
                 method(tools, name, (args = vm.undefined) => {
-                    const parsed = jsonValue(args);
+                    const parsed = jsonValue(args, true);
                     if (parsed.error)
                         return parsed;
                     const operationId = ++toolCallSequence;

package/dist/agent-core/tools/execution-limits.d.ts

@@ -6,7 +6,6 @@ export declare const TOOL_EXECUTION_LIMITS: Readonly<{
     readBatchConcurrency: 4;
     readMaxBatchBytes: 4194304;
     viewImageMaxBytes: 20971520;
-    execDefaultTimeoutMs: 120000;
     execMaxTimeoutMs: 3600000;
     execDefaultYieldMs: 10000;
     execMaxYieldMs: 30000;

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

@@ -6,7 +6,6 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     readBatchConcurrency: 4,
     readMaxBatchBytes: 4_194_304,
     viewImageMaxBytes: 20_971_520,
-    execDefaultTimeoutMs: 120_000,
     execMaxTimeoutMs: 3_600_000,
     execDefaultYieldMs: 10_000,
     execMaxYieldMs: 30_000,

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

@@ -3,6 +3,7 @@ import type { EventPayload } from '../runtime/events.js';
 import type { ClientToolDefinition, McpToolCallContext, ToolExecutionContext, ToolExecutionResult } from './contracts.js';
 import type { ToolRuntimeContext, ToolRuntimeImage } from './runtime-context.js';
 import { type createSessionToolScheduler } from './scheduler.js';
+import type { ToolCall } from './contracts.js';
 export type ClientToolCall = Extract<ModelEvent, {
     type: 'client_tool.call';
 }>;
@@ -26,11 +27,19 @@ export interface RoundToolScope {
     readonly expectations: ReadonlyMap<string, McpToolCallContext['expectedTool']>;
     readonly extensionToolNames: ReadonlySet<string>;
     readonly schedule: ReturnType<typeof createSessionToolScheduler>;
-    readonly emit: (event: EventPayload) => Promise<void>;
+    readonly assertLive: () => void;
+    readonly assertExecutionLive: () => void;
+    readonly emit: (event: EventPayload, assertLive?: () => void) => Promise<void>;
     readonly searchMcpTools: NonNullable<ToolRuntimeContext['searchMcpTools']>;
     readonly recentImages: () => ToolRuntimeImage[];
     readonly captureCodeContext: () => Omit<ToolRuntimeContext, 'signal' | 'codeMode' | 'expectedMcpTool' | 'searchMcpTools'>;
-    readonly codeModeContext: (call: ClientToolCall) => Promise<Omit<NonNullable<ToolExecutionContext['codeMode']>, 'invoke'>>;
+    readonly codeModeContext: (call: ToolCall & {
+        readonly callId: string;
+    }) => Promise<Omit<NonNullable<ToolExecutionContext['codeMode']>, 'invoke'>>;
 }
+/** Shared raw context construction for physical tools and native calls in a real model round. */
+export declare function createRoundToolRuntimeContext(scope: RoundToolScope, call: ToolCall & {
+    readonly callId: string;
+}, signal: AbortSignal): Promise<ToolRuntimeContext>;
 /** Complete every call in model order even if individual execution fails. */
 export declare function executeRoundTools(calls: readonly ClientToolCall[], scope: RoundToolScope): Promise<ExecutedToolCall[]>;

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

@@ -6,6 +6,62 @@ import { createCodeToolDispatch } from './code-mode/dispatch.js';
 import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData } 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. */
+export async function createRoundToolRuntimeContext(scope, call, signal) {
+    scope.assertLive();
+    signal.throwIfAborted();
+    const codeMode = await scope.codeModeContext(call);
+    scope.assertLive();
+    signal.throwIfAborted();
+    const assertSessionLive = scope.assertLive;
+    const assertExecutionLive = scope.assertExecutionLive;
+    const emitCodeEvent = scope.emit;
+    const retainSession = codeMode.retainSession?.bind(codeMode);
+    let retained = 0;
+    const assertDispatchLive = () => {
+        assertSessionLive();
+        if (retained === 0)
+            assertExecutionLive();
+    };
+    return {
+        ...scope.context,
+        ...(scope.expectations.get(call.name)
+            ? { expectedMcpTool: scope.expectations.get(call.name) }
+            : {}),
+        searchMcpTools: scope.searchMcpTools,
+        signal,
+        codeMode: {
+            ...codeMode,
+            ...(retainSession === undefined
+                ? {}
+                : {
+                    retainSession: async () => {
+                        assertDispatchLive();
+                        const release = await retainSession();
+                        retained++;
+                        let released = false;
+                        return async () => {
+                            if (released)
+                                return;
+                            released = true;
+                            retained--;
+                            await release();
+                        };
+                    }
+                }),
+            invoke: createCodeToolDispatch({
+                context: scope.captureCodeContext(),
+                tools: scope.tools,
+                expectations: scope.expectations,
+                parentCallId: call.callId,
+                schedule: scope.schedule,
+                assertLive: assertDispatchLive,
+                emit: (event) => emitCodeEvent(event, assertDispatchLive)
+            })
+        },
+        ...(scope.extensionToolNames.has(call.name) ? { recentImages: scope.recentImages() } : {})
+    };
+}
 /** Complete every call in model order even if individual execution fails. */
 export async function executeRoundTools(calls, scope) {
     const executeCall = async (call, signal = scope.context.signal, caller = 'direct', parentCallId) => {
@@ -21,29 +77,10 @@ export async function executeRoundTools(calls, scope) {
                 throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', call.argumentError);
             if (!scope.tools.some((tool) => tool.name === call.name && allowsToolCaller(tool, caller)))
                 throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable in this execution.');
-            const codeMode = await scope.codeModeContext(call);
+            const context = await createRoundToolRuntimeContext(scope, call, signal);
             const runTool = () => {
                 signal.throwIfAborted();
-                return executeRegisteredTool(call.name, call.arguments, call.callId, {
-                    ...scope.context,
-                    ...(scope.expectations.get(call.name)
-                        ? { expectedMcpTool: scope.expectations.get(call.name) }
-                        : {}),
-                    searchMcpTools: scope.searchMcpTools,
-                    signal,
-                    codeMode: {
-                        ...codeMode,
-                        invoke: createCodeToolDispatch({
-                            context: scope.captureCodeContext(),
-                            tools: scope.tools,
-                            expectations: scope.expectations,
-                            parentCallId: call.callId,
-                            schedule: scope.schedule,
-                            emit: scope.emit
-                        })
-                    },
-                    ...(scope.extensionToolNames.has(call.name) ? { recentImages: scope.recentImages() } : {})
-                });
+                return executeRegisteredTool(call.name, call.arguments, call.callId, context);
             };
             const output = call.name === 'code_exec' || call.name === 'code_exec_wait'
                 ? await runTool()

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

@@ -0,0 +1,2 @@
+/** Compatibility is not validation: required fields, types and values stay with the tool. */
+export declare function normalizeToolInput(input: unknown, schema: unknown): unknown;

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

@@ -0,0 +1,36 @@
+/** Compatibility is not validation: required fields, types and values stay with the tool. */
+export function normalizeToolInput(input, schema) {
+    const visit = (value, definition, depth) => {
+        if (depth > 64 || value === null || typeof value !== 'object')
+            return value;
+        const shape = record(definition) ? definition : {};
+        if (Array.isArray(value))
+            return value.map((item) => visit(item, shape.items, depth + 1));
+        if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+            return value;
+        const properties = record(shape.properties) ? shape.properties : {};
+        // Do not guess branch selection, resolve refs, or discard pattern-defined parameters.
+        const closed = shape.additionalProperties === false &&
+            !['$ref', 'anyOf', 'oneOf', 'allOf', 'if', 'patternProperties', 'dependentSchemas'].some((key) => Object.hasOwn(shape, key));
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (item === undefined)
+                continue;
+            const declared = Object.hasOwn(properties, key);
+            if (closed && !declared)
+                continue;
+            const child = declared ? properties[key] : shape.additionalProperties;
+            Object.defineProperty(result, key, {
+                value: visit(item, child, depth + 1),
+                enumerable: true,
+                writable: true,
+                configurable: true
+            });
+        }
+        return result;
+    };
+    return visit(input, schema, 0);
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -8,7 +8,7 @@ export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Omit unchanged file sections: an Update File must change or move the file, and its last hunk must not be context-only. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
+    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>. Context-only hunks, including trailing hunks, and unchanged file sections are validated in order but are not written or reported as edits. The patch must include a change or move. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',
     outputSchema: {
         type: 'object',
@@ -73,18 +73,28 @@ export class ApplyPatchTool {
         const resolvedChanges = await this.#resolveChanges(changes);
         const results = [];
         let totalBytes = 0;
-        for (const [index, resolvedChange] of resolvedChanges.entries()) {
+        const pendingChanges = [];
+        for (const resolvedChange of resolvedChanges) {
+            if (resolvedChange.kind === 'update' &&
+                resolvedChange.change.hunks.every((hunk) => hunk.anchor))
+                totalBytes = (await this.#preflight(resolvedChange, totalBytes)).totalBytes;
+            else
+                pendingChanges.push(resolvedChange);
+        }
+        for (const [index, resolvedChange] of pendingChanges.entries()) {
             try {
                 const preflight = await this.#preflight(resolvedChange, totalBytes);
-                await this.#commit(preflight.mutations);
-                results.push(preflight.result);
+                if (preflight.mutations.length)
+                    await this.#commit(preflight.mutations);
+                if (preflight.result)
+                    results.push(preflight.result);
                 totalBytes = preflight.totalBytes;
             }
             catch (error) {
                 if (!results.length ||
                     (error instanceof MarAgentError && error.code === 'MAR_AGENT_PATCH_ROLLBACK_FAILED'))
                     throw error;
-                throw partialPatchError(error, results, resolvedChanges.slice(index));
+                throw partialPatchError(error, results, pendingChanges.slice(index));
             }
         }
         return {
@@ -185,6 +195,8 @@ export class ApplyPatchTool {
         totalBytes = enforceContentLimits(content, totalBytes);
         const addedLines = change.hunks.reduce((sum, hunk) => sum + hunk.addedLines, 0);
         const deletedLines = change.hunks.reduce((sum, hunk) => sum + hunk.deletedLines, 0);
+        if (resolvedChange.kind === 'update' && !addedLines && !deletedLines)
+            return { mutations: [], totalBytes };
         if (resolvedChange.kind === 'move') {
             const moveChange = resolvedChange.change;
             const targetStat = await optionalLstat(resolvedChange.target);
@@ -385,18 +397,8 @@ function parsePatch(patch) {
                     anchor: !addedLines && !deletedLines
                 });
             }
-            let hasFollowingChange = false;
-            for (let hunkIndex = hunks.length - 1; hunkIndex >= 0; hunkIndex--) {
-                const hunk = hunks[hunkIndex];
-                if (hunk.anchor) {
-                    if (!hasFollowingChange)
-                        invalid('Context-only patch hunks must precede a changing hunk.');
-                }
-                else
-                    hasFollowingChange = true;
-            }
-            if (!hasFollowingChange && !targetPath)
-                invalid('Update operations must change or move a file.');
+            if (!hunks.length && !targetPath)
+                invalid('Update operations must contain hunks or move a file.');
             changes.push({ kind: 'update', path, ...(targetPath ? { targetPath } : {}), hunks });
         }
         else
@@ -404,6 +406,8 @@ function parsePatch(patch) {
         if (changes.length > TOOL_EXECUTION_LIMITS.patchMaxFiles)
             throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the file limit.');
     }
+    if (!changes.some((change) => change.kind !== 'update' || change.targetPath || change.hunks.some((hunk) => !hunk.anchor)))
+        invalid('Patch must change or move at least one file.');
     return changes;
 }
 function applyHunks(original, hunks, path) {

package/dist/agent-core/tools/local/exec.d.ts

@@ -2,6 +2,8 @@ import { type LocalProcessExecutor } from '../../host/local-process-executor.js'
 import type { ClientToolDefinition } from '../../model/contracts.js';
 import type { ExecResult } from '../contracts.js';
 import { WorkspacePathResolver } from '../shared/path-resolver.js';
+import { type CoreProcessInput, type CoreProcessHandle } from '../../extensions/processes.js';
+import type { CoreOperationContext } from '../../extensions/operation.js';
 export type { ExecResult } from '../contracts.js';
 export type ExecInput = {
     action?: 'start';
@@ -34,10 +36,8 @@ export declare class ExecTool {
     private readonly shell?;
     private readonly processExecutor;
     constructor(paths: WorkspacePathResolver, maxOutputBytes?: number, maxProcesses?: number, environment?: NodeJS.ProcessEnv, shell?: string | undefined, processExecutor?: LocalProcessExecutor);
-    execute(arguments_: unknown, signal?: AbortSignal, owner?: {
-        readonly sessionId: string;
-        readonly executionId: string;
-    }): Promise<ExecResult>;
+    execute(arguments_: unknown, signal?: AbortSignal, owner?: NonNullable<import('../../host/local-process-executor.js').LocalProcessSpawnRequest['owner']>): Promise<ExecResult>;
+    spawn(input: CoreProcessInput, call: CoreOperationContext): Promise<CoreProcessHandle>;
     listSessionResources(sessionId: string): {
         processId: string;
         status: "completed" | "cancelled" | "running";