@myagentroam/agent 0.9.88 → 0.9.90

package/dist/host/local-agent-host.d.ts

@@ -1,7 +1,14 @@
 import type { HostDescription } from './contracts.js';
 import type { LocalProcessExecutor } from './local-process-executor.js';
 import type { WorkspacePathMount } from '../tools/shared/path-resolver.js';
-import type { MarAgentEvent, MarAgentHost, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../sdk/types.js';
+import type { MarAgentEvent, MarAgentHost, McpToolCatalogContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../sdk/types.js';
+export interface LocalAgentMcpBinding {
+    readonly tools: readonly import('../model/contracts.js').ClientToolDefinition[];
+    call(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
+}
+export interface LocalAgentExecutionMcpBinding extends LocalAgentMcpBinding {
+    active: boolean;
+}
 export declare class LocalAgentHost implements MarAgentHost {
     #private;
     readonly events: MarAgentEvent[];
@@ -37,8 +44,13 @@ export declare class LocalAgentHost implements MarAgentHost {
         requestId: string;
         questions: unknown[];
     }, signal: AbortSignal): Promise<Record<string, unknown>>;
-    listMcpTools(): Promise<readonly import("../model/contracts.js").ClientToolDefinition[]>;
-    callMcpTool(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
+    bindExecutionMcp(binding?: LocalAgentMcpBinding): LocalAgentExecutionMcpBinding | undefined;
+    unbindExecutionMcp(binding: LocalAgentExecutionMcpBinding | undefined): void;
+    listMcpTools(context?: McpToolCatalogContext): Promise<import("../model/contracts.js").ClientToolDefinition[]>;
+    callMcpTool(call: ToolCall, signal: AbortSignal, context?: {
+        sessionId: string;
+        executionId: string;
+    }): Promise<ToolExecutionResult>;
     listSessionResources(sessionId: string): Promise<{
         processes: {
             processId: string;

package/dist/host/local-agent-host.js

@@ -13,6 +13,8 @@ export class LocalAgentHost {
     #question;
     #mcpTools;
     #callMcp;
+    #executionMcp = new Map();
+    #currentExecutionMcp;
     events = [];
     #mode;
     #environment;
@@ -94,11 +96,46 @@ export class LocalAgentHost {
             throw new MarAgentError('MAR_AGENT_USER_INPUT_UNAVAILABLE', 'User input is unavailable.');
         return this.#question(input, signal);
     }
-    listMcpTools() {
-        return Promise.resolve(this.#mcpTools);
+    bindExecutionMcp(binding) {
+        const current = binding === undefined ? undefined : { ...binding, active: true };
+        if (current === undefined)
+            this.#currentExecutionMcp = undefined;
+        else
+            this.#currentExecutionMcp = current;
+        return current;
     }
-    async callMcpTool(call, signal) {
-        if (!this.#callMcp)
+    unbindExecutionMcp(binding) {
+        if (binding !== undefined)
+            binding.active = false;
+        if (this.#currentExecutionMcp === binding)
+            this.#currentExecutionMcp = undefined;
+        for (const [executionId, candidate] of this.#executionMcp)
+            if (candidate === binding)
+                this.#executionMcp.delete(executionId);
+    }
+    listMcpTools(context) {
+        const execution = context?.claimExecutionScope === true
+            ? this.#currentExecutionMcp
+            : context?.executionScopeId === undefined
+                ? undefined
+                : this.#executionMcp.get(context.executionScopeId);
+        if (context !== undefined && execution !== undefined)
+            this.#executionMcp.set(context.executionId, execution);
+        const tools = [...this.#mcpTools, ...(execution?.tools ?? [])];
+        if (new Set(tools.map((tool) => tool.name)).size !== tools.length)
+            throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'MCP tool names conflict.');
+        return Promise.resolve(tools);
+    }
+    async callMcpTool(call, signal, context) {
+        const execution = context === undefined
+            ? this.#currentExecutionMcp
+            : this.#executionMcp.get(context.executionId);
+        if (execution?.tools.some((tool) => tool.name === call.name)) {
+            if (!execution.active)
+                throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'Execution MCP is no longer available.');
+            return execution.call(call, signal);
+        }
+        if (!this.#callMcp || !this.#mcpTools.some((tool) => tool.name === call.name))
             throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'MCP tool execution is unavailable.');
         return this.#callMcp(call, signal);
     }

package/dist/index.d.ts

@@ -7,11 +7,11 @@ export type { ClientToolDefinition, ModelAdapter, ModelEvent, ModelMessage, Mode
 export { LocalWorkspaceTools, type ExecInput, type ExecResult } from './tools/local-workspace-tools.js';
 export type { ApplyPatchFileResult, ApplyPatchResult } from './tools/apply-patch.js';
 export { openMarAgentSessionCatalog, type MarAgentContextUsage, type MarAgentSessionDeleteResult, type MarAgentHistoryEntry, type MarAgentHistoryPage, type MarAgentSessionCatalog, type MarAgentSessionImage, type MarAgentSessionPage, type MarAgentSessionSummary } from './session/catalog.js';
-export { LocalAgentHost, selectExecutionShell } from './host/local-agent-host.js';
+export { LocalAgentHost, selectExecutionShell, type LocalAgentExecutionMcpBinding, type LocalAgentMcpBinding } from './host/local-agent-host.js';
 export type { LocalProcessExecutor, LocalProcessSpawnRequest } from './host/local-process-executor.js';
 export type { WorkspacePathMount } from './tools/shared/path-resolver.js';
 export { createMarAgent } from './sdk/agent.js';
 export { MAR_AGENT_PROMPT_VERSION, buildSystemPrompt } from './prompts/index.js';
 export { TodoStore, type TodoItem } from './tools/todo.js';
 export { SubagentScheduler, type SubagentOutputOptions, type SubagentMessageOptions, type SubagentRunOptions, type SubagentTaskInput, type SubagentTaskResult, type SubagentTaskSnapshot } from './subagent/scheduler.js';
-export type { AccessMode, CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, ExecutionMode, ExecutionResult, HostSessionResourceSnapshot, MarAgent, MarAgentEvent, MarAgentHost, MarAgentImageMetadata, MarAgentSession, MarAgentToolArtifact, MarAgentToolImageArtifact, RolloutBudgetOptions, RunInput, RunInputImage, ToolCall, ToolExecutionContext, ToolExecutionResult } from './sdk/types.js';
+export type { AccessMode, CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, ExecutionMode, ExecutionResult, HostSessionResourceSnapshot, McpToolCatalogContext, MarAgent, MarAgentEvent, MarAgentHost, MarAgentImageMetadata, MarAgentSession, MarAgentToolArtifact, MarAgentToolImageArtifact, RolloutBudgetOptions, RunInput, RunInputImage, ToolCall, ToolExecutionContext, ToolExecutionResult } from './sdk/types.js';

package/dist/prompts/resources.js

@@ -2,7 +2,7 @@ export function retainedSessionResourcesSnapshot(input) {
     if (input.processes.length === 0 && input.subagents.length === 0)
         return undefined;
     const processes = [...input.processes].sort((left, right) => left.processId.localeCompare(right.processId));
-    const subagents = [...input.subagents].sort((left, right) => left.agentId.localeCompare(right.agentId));
+    const subagents = [...input.subagents];
     return [
         '# Retained Session resources',
         'These resources belong to this Session and survived the previous Execution. Reuse their stable IDs instead of starting duplicate processes or subagents.',

package/dist/sdk/agent.js

@@ -421,6 +421,7 @@ export async function createMarAgent(options) {
                                     access: input.access,
                                     initialMailbox: turn.initialMailbox,
                                     turnId: turn.turnId,
+                                    mcpExecutionScopeId: executionId,
                                     ...(turn.delivery ? { delivery: turn.delivery } : {}),
                                     ...(rolloutBudget === undefined ? {} : { sharedRolloutBudget: rolloutBudget })
                                 });
@@ -430,7 +431,15 @@ export async function createMarAgent(options) {
                         (input.images?.length || hasRestoredUserImages) &&
                         !selectedModel.inputCapabilities.includes('IMAGE'))
                         throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Selected model does not support image input.');
-                    const mcpTools = (await options.host.listMcpTools?.()) ?? [];
+                    const mcpTools = (await options.host.listMcpTools?.({
+                        sessionId,
+                        executionId,
+                        ...(sessionSource.type === 'subagent'
+                            ? internal.mcpExecutionScopeId === undefined
+                                ? {}
+                                : { executionScopeId: internal.mcpExecutionScopeId }
+                            : { claimExecutionScope: true })
+                    })) ?? [];
                     const selectedModelForTools = executionModels.get(input.modelId ?? executionDefaultModelId);
                     const availableTools = [...BUILTIN_TOOL_DEFINITIONS, ...mcpTools].filter((tool) => {
                         if (sessionSource.type === 'subagent' &&
@@ -642,6 +651,7 @@ export async function createMarAgent(options) {
                                         tools: executionTools,
                                         toolChoice: 'none',
                                         promptCacheKey: sessionId,
+                                        reasoningEffort,
                                         onAttemptDiagnostic: recordModelAttempt('COMPACTION')
                                     })) {
                                         if (event.type === 'text.completed' &&
@@ -1296,6 +1306,7 @@ export async function createMarAgent(options) {
                 inputSource: 'parent_agent',
                 initialMailbox: turn.initialMailbox,
                 turnId: turn.turnId,
+                mcpExecutionScopeId: turn.mcpExecutionScopeId,
                 ...(turn.delivery ? { delivery: turn.delivery } : {}),
                 ...(turn.sharedRolloutBudget === undefined
                     ? {}
@@ -1449,6 +1460,7 @@ function createSubagentBackend(store, workspace) {
             return Promise.all(sessions.map(async (session) => ({
                 id: session.id,
                 createdAt: session.createdAt,
+                lastActivityAt: session.lastActivityAt,
                 source: session.source,
                 records: await store.read(session.id)
             })));
@@ -1468,6 +1480,7 @@ function createSubagentBackend(store, workspace) {
             return {
                 id: session.id,
                 createdAt: session.createdAt,
+                lastActivityAt: session.lastActivityAt,
                 source: session.source,
                 records: await store.read(session.id)
             };

package/dist/sdk/types.d.ts

@@ -22,6 +22,10 @@ export interface ToolExecutionContext {
         invoke(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
     };
 }
+export interface McpToolCatalogContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId'> {
+    executionScopeId?: string;
+    claimExecutionScope?: boolean;
+}
 export interface MarAgentToolImageArtifact {
     kind: 'image';
     name: string;
@@ -58,8 +62,8 @@ export interface MarAgentHost {
         requestId: string;
         questions: unknown[];
     }, signal: AbortSignal): Promise<Record<string, unknown>>;
-    listMcpTools?(): Promise<readonly import('../model/contracts.js').ClientToolDefinition[]>;
-    callMcpTool?(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
+    listMcpTools?(context?: McpToolCatalogContext): Promise<readonly import('../model/contracts.js').ClientToolDefinition[]>;
+    callMcpTool?(call: ToolCall, signal: AbortSignal, context?: Pick<ToolExecutionContext, 'sessionId' | 'executionId'>): Promise<ToolExecutionResult>;
     listSessionResources?(sessionId: string): Promise<HostSessionResourceSnapshot>;
     disposeSessionResources?(sessionId: string): Promise<void>;
     dispose(): Promise<void>;

package/dist/subagent/session-controller.d.ts

@@ -43,6 +43,7 @@ export interface SubagentParentExecution {
 export interface PersistedSubagentSession {
     readonly id: string;
     readonly createdAt: string;
+    readonly lastActivityAt: string;
     readonly source: Extract<SessionSource, {
         type: 'subagent';
     }>;

package/dist/subagent/session-controller.js

@@ -11,6 +11,7 @@ export class SubagentSessionController {
     #completionWaiters = new Set();
     #activityWaiters = new Set();
     #activityRevision = 0;
+    #resourceRevision = 0;
     #running = 0;
     #disposed = false;
     #createdInExecution = 0;
@@ -23,9 +24,12 @@ export class SubagentSessionController {
     }
     static async open(input) {
         const controller = new SubagentSessionController(input.parentSessionId, input.rootSessionId, input.backend, input.limits);
-        const sessions = await input.backend.listChildren(input.parentSessionId);
-        for (const session of sessions)
-            controller.#agents.set(session.id, restoreAgentState(session));
+        const sessions = [...(await input.backend.listChildren(input.parentSessionId))].sort((a, b) => a.lastActivityAt.localeCompare(b.lastActivityAt));
+        for (const session of sessions) {
+            const state = restoreAgentState(session);
+            state.resourceRevision = ++controller.#resourceRevision;
+            controller.#agents.set(session.id, state);
+        }
         return controller;
     }
     async beginParentExecution(execution) {
@@ -78,7 +82,8 @@ export class SubagentSessionController {
             verification: [],
             evidence: [],
             terminalPending: false,
-            terminalObserved: false
+            terminalObserved: false,
+            resourceRevision: ++this.#resourceRevision
         };
         this.#createdInExecution++;
         this.#agents.set(state.agentId, state);
@@ -335,6 +340,7 @@ export class SubagentSessionController {
             if (index >= 0)
                 this.#queue.splice(index, 1);
             state.status = 'cancelled';
+            this.#touchResource(state);
             this.#closeReceipt(state);
             state.terminalPending = true;
             await this.#publishTerminal(state);
@@ -355,7 +361,15 @@ export class SubagentSessionController {
         }
     }
     listSessionResources() {
-        return [...this.#agents.values()].map((state) => ({
+        const states = [...this.#agents.values()];
+        const active = states
+            .filter((state) => state.status === 'queued' || state.status === 'running')
+            .sort((left, right) => right.resourceRevision - left.resourceRevision);
+        const terminal = states
+            .filter((state) => state.status !== 'queued' && state.status !== 'running')
+            .sort((left, right) => right.resourceRevision - left.resourceRevision)
+            .slice(0, 8);
+        return [...active, ...terminal].map((state) => ({
             agentId: state.agentId,
             status: state.status,
             description: state.description
@@ -389,6 +403,7 @@ export class SubagentSessionController {
         const completion = new Promise((done) => (resolve = done));
         const handleReady = new Promise((done) => (resolveHandleReady = done));
         state.status = 'queued';
+        this.#touchResource(state);
         delete state.summary;
         delete state.errorCode;
         delete state.errorMessage;
@@ -417,6 +432,7 @@ export class SubagentSessionController {
             if (!turn || state.status !== 'queued')
                 continue;
             state.status = 'running';
+            this.#touchResource(state);
             this.#running++;
             void this.#startAndConsumeTurn(state, turn);
         }
@@ -452,6 +468,7 @@ export class SubagentSessionController {
                         continue;
                     state.messageRevision++;
                     state.latestMessageActivityRevision = ++this.#activityRevision;
+                    this.#touchResource(state);
                     this.#notifyActivity({ state, kind: 'message' });
                 }
             })();
@@ -469,6 +486,7 @@ export class SubagentSessionController {
                 state.errorMessage = result.errorMessage ?? 'Subagent execution failed.';
             }
             state.terminalPending = true;
+            this.#touchResource(state);
             this.#closeReceipt(state);
             await this.#publishTerminal(state);
         }
@@ -504,6 +522,10 @@ export class SubagentSessionController {
         state.errorCode = diagnostic.code;
         state.errorMessage = diagnostic.message;
         state.terminalPending = true;
+        this.#touchResource(state);
+    }
+    #touchResource(state) {
+        state.resourceRevision = ++this.#resourceRevision;
     }
     #waitForAnyCompletion(candidates, waitMs, signal) {
         return waitForCompletionNotification(this.#completionWaiters, (state) => candidates.includes(state), waitMs, signal);
@@ -738,7 +760,8 @@ function restoreAgentState(session) {
         verification: [],
         evidence: [],
         terminalPending: false,
-        terminalObserved: false
+        terminalObserved: false,
+        resourceRevision: 0
     };
     for (const record of currentRecords) {
         if (!isRecord(record.payload) ||

package/dist/tools/apply-patch.js

@@ -7,7 +7,7 @@ import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 export const applyPatchToolDefinition = {
     name: 'apply_patch',
     parallelSafety: 'serial',
-    description: `Preferred for precise, reviewable local edits. Group small, related implementation and test changes in one patch when they are already understood. Split large or independent changes, and wait for intermediate results only when the next edit depends on them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. The complete patch is validated and committed atomically. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts. Limits: ${TOOL_EXECUTION_LIMITS.patchMaxBytes / 1_048_576} MiB patch input, ${TOOL_EXECUTION_LIMITS.patchMaxFiles} files, ${TOOL_EXECUTION_LIMITS.patchMaxFileBytes / 1_048_576} MiB per file, and ${TOOL_EXECUTION_LIMITS.patchMaxTotalBytes / 1_048_576} MiB working set. MAR_AGENT_PATCH_CONFLICT means no partial edit was applied; hunk match conflicts identify the affected path and hunk so you can reread 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 may also be used as ordered anchors before a later changing hunk. 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. 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',
@@ -63,8 +63,23 @@ export class ApplyPatchTool {
     }
     async execute(patch) {
         const changes = parsePatch(patch);
-        const { mutations, results } = await this.#preflight(changes);
-        await this.#commit(mutations);
+        const resolvedChanges = await this.#resolveChanges(changes);
+        const results = [];
+        let totalBytes = 0;
+        for (const [index, resolvedChange] of resolvedChanges.entries()) {
+            try {
+                const preflight = await this.#preflight(resolvedChange, totalBytes);
+                await this.#commit(preflight.mutations);
+                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));
+            }
+        }
         return {
             files: results,
             totals: {
@@ -74,9 +89,8 @@ export class ApplyPatchTool {
             }
         };
     }
-    async #preflight(changes) {
-        const mutations = [];
-        const results = [];
+    async #resolveChanges(changes) {
+        const resolvedChanges = [];
         const claimedTargets = new Set();
         const claimTarget = (target) => {
             const key = resolve(target);
@@ -84,83 +98,130 @@ export class ApplyPatchTool {
                 invalid('Patch contains duplicate or overlapping paths.');
             claimedTargets.add(key);
         };
-        let totalBytes = 0;
         for (const change of changes) {
             if (change.kind === 'add') {
                 const target = await this.paths.resolve(change.path, true, 'write');
                 claimTarget(target);
-                await assertMissing(target);
-                const content = Buffer.from(`${change.lines.join('\n')}\n`);
-                totalBytes = enforceContentLimits(content, totalBytes);
-                mutations.push({ path: change.path, target, content, expectedExisting: false });
-                results.push({
-                    path: change.path,
-                    operation: 'added',
-                    addedLines: change.lines.length,
-                    deletedLines: 0
-                });
+                resolvedChanges.push({ kind: 'add', change, target });
                 continue;
             }
-            const source = await this.paths.resolve(change.path, false, 'write');
+            const source = await this.paths.resolve(change.path, true, 'write');
             claimTarget(source);
-            const sourceStat = await lstat(source);
-            if (!sourceStat.isFile())
-                invalid('Patch sources must be regular files.');
-            const original = await readBoundedFile(source);
-            totalBytes = enforceContentLimits(original, totalBytes);
             if (change.kind === 'delete') {
-                mutations.push({ path: change.path, target: source, expectedExisting: true });
-                results.push({
-                    path: change.path,
-                    operation: 'deleted',
-                    addedLines: 0,
-                    deletedLines: logicalLineCount(original)
-                });
+                resolvedChanges.push({ kind: 'delete', change, source });
                 continue;
             }
-            const content = change.hunks.length
-                ? applyHunks(original, change.hunks, change.path)
-                : original;
-            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 (change.targetPath) {
                 const target = await this.paths.resolve(change.targetPath, true, 'write');
                 claimTarget(target);
-                await assertMissing(target);
-                mutations.push({ path: change.path, target: source, expectedExisting: true });
-                mutations.push({
-                    path: change.targetPath,
-                    target,
-                    content,
-                    mode: sourceStat.mode & 0o7777,
-                    expectedExisting: false
+                resolvedChanges.push({
+                    kind: 'move',
+                    change: { ...change, targetPath: change.targetPath },
+                    source,
+                    target
                 });
-                results.push({
+            }
+            else
+                resolvedChanges.push({ kind: 'update', change, source });
+        }
+        return resolvedChanges;
+    }
+    async #preflight(resolvedChange, currentTotalBytes) {
+        if (resolvedChange.kind === 'add') {
+            const { change } = resolvedChange;
+            const targetStat = await optionalLstat(resolvedChange.target);
+            if (targetStat && !targetStat.isFile())
+                invalid('Patch targets must be regular files.');
+            const content = Buffer.from(`${change.lines.join('\n')}\n`);
+            const totalBytes = enforceContentLimits(content, currentTotalBytes);
+            return {
+                mutations: [
+                    {
+                        path: change.path,
+                        target: resolvedChange.target,
+                        content,
+                        ...(targetStat ? { mode: targetStat.mode & 0o7777 } : {}),
+                        expectedExisting: targetStat !== undefined
+                    }
+                ],
+                result: {
                     path: change.path,
-                    targetPath: change.targetPath,
+                    operation: 'added',
+                    addedLines: change.lines.length,
+                    deletedLines: 0
+                },
+                totalBytes
+            };
+        }
+        const sourceStat = await lstat(resolvedChange.source);
+        if (!sourceStat.isFile())
+            invalid('Patch sources must be regular files.');
+        const original = await readBoundedFile(resolvedChange.source);
+        let totalBytes = enforceContentLimits(original, currentTotalBytes);
+        if (resolvedChange.kind === 'delete') {
+            const { change } = resolvedChange;
+            return {
+                mutations: [{ path: change.path, target: resolvedChange.source, expectedExisting: true }],
+                result: {
+                    path: change.path,
+                    operation: 'deleted',
+                    addedLines: 0,
+                    deletedLines: logicalLineCount(original)
+                },
+                totalBytes
+            };
+        }
+        const { change } = resolvedChange;
+        const content = change.hunks.length
+            ? applyHunks(original, change.hunks, change.path)
+            : original;
+        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 === 'move') {
+            const moveChange = resolvedChange.change;
+            const targetStat = await optionalLstat(resolvedChange.target);
+            if (targetStat && !targetStat.isFile())
+                invalid('Patch targets must be regular files.');
+            return {
+                mutations: [
+                    { path: change.path, target: resolvedChange.source, expectedExisting: true },
+                    {
+                        path: moveChange.targetPath,
+                        target: resolvedChange.target,
+                        content,
+                        mode: (targetStat ?? sourceStat).mode & 0o7777,
+                        expectedExisting: targetStat !== undefined
+                    }
+                ],
+                result: {
+                    path: change.path,
+                    targetPath: moveChange.targetPath,
                     operation: 'moved',
                     addedLines,
                     deletedLines
-                });
-            }
-            else {
-                mutations.push({
+                },
+                totalBytes
+            };
+        }
+        return {
+            mutations: [
+                {
                     path: change.path,
-                    target: source,
+                    target: resolvedChange.source,
                     content,
                     mode: sourceStat.mode & 0o7777,
                     expectedExisting: true
-                });
-                results.push({
-                    path: change.path,
-                    operation: 'modified',
-                    addedLines,
-                    deletedLines
-                });
-            }
-        }
-        return { mutations, results };
+                }
+            ],
+            result: {
+                path: change.path,
+                operation: 'modified',
+                addedLines,
+                deletedLines
+            },
+            totalBytes
+        };
     }
     async #commit(mutations) {
         const staged = [];
@@ -447,9 +508,40 @@ function enforceContentLimits(content, current) {
         throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch working set exceeds the byte limit.');
     return total;
 }
-async function assertMissing(path) {
-    if (await exists(path))
-        throw new MarAgentError('MAR_AGENT_PATCH_CONFLICT', 'Patch target already exists.');
+function partialPatchError(cause, appliedResults, pendingChanges) {
+    const appliedFiles = appliedResults.map(resultPath);
+    const failedFile = changePath(pendingChanges[0].change);
+    const pendingFiles = pendingChanges.slice(1).map(({ change }) => changePath(change));
+    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 }
+    });
+}
+function resultPath(result) {
+    return result.targetPath === undefined ? result.path : `${result.path} -> ${result.targetPath}`;
+}
+function changePath(change) {
+    return change.kind === 'update' && change.targetPath !== undefined
+        ? `${change.path} -> ${change.targetPath}`
+        : change.path;
+}
+function summarizePaths(paths) {
+    if (!paths.length)
+        return '(none)';
+    const visible = paths.slice(0, 12);
+    const suffix = paths.length > visible.length ? `, … (${paths.length} total)` : '';
+    return `${visible.join(', ')}${suffix}`;
+}
+async function optionalLstat(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
 }
 async function ensureDirectory(path, created) {
     const missing = [];

package/dist/tools/runtime.js

@@ -8,7 +8,10 @@ export async function executeRegisteredTool(name, arguments_, callId, context) {
     if (name.startsWith('mcp__')) {
         if (!context.host.callMcpTool)
             throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'MCP execution is unavailable.');
-        return context.host.callMcpTool(call, context.signal);
+        return context.host.callMcpTool(call, context.signal, {
+            sessionId: context.sessionId,
+            executionId: context.executionId
+        });
     }
     return context.host.executeTool(call, {
         access: context.access,

package/package.json

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