@akira-tl/forgerelay 0.5.4 → 0.5.6

package/dist/server.js

@@ -36,6 +36,10 @@ import { createOpenAIIncomingArtifactAdapter, IncomingArtifactAdapterRegistry, }
 import { logEvent, requestIp, requestPath, commandPreview, transportSessionIdPrefix, workspaceLogLabel, } from "./logger.js";
 import { editFileTool, readFileTool, writeFileTool, } from "./pi-tools.js";
 import { SingleUserOAuthProvider } from "./oauth-provider.js";
+import { BatchExecutor } from "./operations/batch/executor.js";
+import { executeBulkRead } from "./operations/bulk-read.js";
+import { NativeBulkMutationExecutor } from "./operations/native-bulk-mutations.js";
+import { createCoreOperationExecutor, } from "./operations/core-operation-executor.js";
 import { McpTransportRegistry, } from "./mcp-sessions.js";
 import { ProcessManager, resolveProcessId, } from "./process-sessions.js";
 import { createReviewCheckpointManager } from "./review-checkpoints.js";
@@ -171,6 +175,7 @@ const capabilityCatalogOutputSchema = z.object({
     description: z.string(),
     available: z.boolean(),
     unavailableReason: z.string().optional(),
+    batchPolicy: z.enum(["parallel", "serial", "unsupported"]),
     guide: capabilityCatalogGuideOutputSchema,
 });
 const capabilityErrorOutputSchema = z.object({
@@ -724,6 +729,53 @@ async function reviewWorkspaceChanges(reviewCheckpoints, workspace) {
 function toolResultIsError(result) {
     return typeof result === "object" && result !== null && result.isError === true;
 }
+function toolResultText(result) {
+    if (typeof result !== "object" || result === null)
+        return String(result ?? "");
+    const record = result;
+    if (Array.isArray(record.content)) {
+        const text = record.content
+            .map((entry) => {
+            if (typeof entry !== "object" || entry === null)
+                return "";
+            const value = entry.text;
+            return typeof value === "string" ? value : "";
+        })
+            .filter(Boolean)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    if (typeof record.structuredContent === "object" && record.structuredContent !== null) {
+        const value = record.structuredContent.result;
+        if (typeof value === "string")
+            return value;
+    }
+    return "";
+}
+function toolResultContent(result) {
+    if (typeof result !== "object" || result === null)
+        return [];
+    const content = result.content;
+    return Array.isArray(content) ? content : [];
+}
+function toolResultAgentsFiles(result) {
+    if (typeof result !== "object" || result === null)
+        return [];
+    const structured = result.structuredContent;
+    if (typeof structured !== "object" || structured === null)
+        return [];
+    const agentsFiles = structured.agentsFiles;
+    if (!Array.isArray(agentsFiles))
+        return [];
+    return agentsFiles.flatMap((entry) => {
+        if (typeof entry !== "object" || entry === null)
+            return [];
+        const path = entry.path;
+        const content = entry.content;
+        return typeof path === "string" && typeof content === "string" ? [{ path, content }] : [];
+    });
+}
 function workspaceActivitySnapshot(workspace) {
     return {
         id: workspace.id,
@@ -781,7 +833,13 @@ function processActivityOutcome(result) {
     }
     return { type: "succeeded" };
 }
-function runActivityTool(lifecycle, workspace, requestMeta, tool, request, operation, outcome = standardActivityOutcome) {
+function activityRelationFor(context) {
+    return {
+        ...(context.parentActivityId ? { parentActivityId: context.parentActivityId } : {}),
+        ...(context.turnId ? { turnId: context.turnId } : {}),
+    };
+}
+function runActivityTool(lifecycle, workspace, requestMeta, tool, request, operation, outcome = standardActivityOutcome, relation = {}) {
     return lifecycle.run({
         tool,
         workspace: workspaceActivitySnapshot(workspace),
@@ -789,12 +847,13 @@ function runActivityTool(lifecycle, workspace, requestMeta, tool, request, opera
         request,
         operation,
         outcome,
+        ...relation,
     });
 }
-function runActivityToolWithHooks(lifecycle, hooks, workspace, requestMeta, request, hookOptions) {
-    return runActivityTool(lifecycle, workspace, requestMeta, hookOptions.tool, request, () => runToolWithHooks(hooks, hookOptions));
+function runActivityToolWithHooks(lifecycle, hooks, workspace, requestMeta, request, hookOptions, relation = {}) {
+    return runActivityTool(lifecycle, workspace, requestMeta, hookOptions.tool, request, () => runToolWithHooks(hooks, hookOptions), standardActivityOutcome, relation);
 }
-function registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore) {
+function registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore, shellRun) {
     if (config.toolMode === "codex") {
         registerAppTool(server, "exec_command", {
             title: "Execute command",
@@ -837,70 +896,22 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
             outputSchema: processOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "shell"),
             annotations: SHELL_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            let undeliveredProcessId;
-            const activityResult = await runActivityTool(activityLifecycle, workspace, extra._meta, "exec_command", { workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, async (activityContext) => {
-                try {
-                    const result = await runToolWithHooks(hooks, {
-                        signal: extra.signal,
-                        tool: "exec_command",
-                        invocation: workspaceHookInvocation(workspace),
-                        payload: { command: cmd, workingDirectory: workingDirectory ?? "." },
-                        operation: async () => {
-                            const startedAt = performance.now();
-                            const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
-                            await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
-                            const snapshot = await processSessions.start({
-                                workspaceId,
-                                command: cmd,
-                                cwd,
-                                workspaceRoot: workspace.root,
-                                tty,
-                                columns,
-                                rows,
-                                yieldTimeMs,
-                                timeoutMs,
-                                maxOutputTokens,
-                                codexCi: true,
-                                signal: extra.signal,
-                                audit: activityContext,
-                            });
-                            undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
-                            logToolCall(config, {
-                                tool: "exec_command",
-                                ...workspaceLogContext(workspace, extra.sessionId),
-                                workingDirectory: workingDirectory ?? ".",
-                                command: cmd,
-                                commandLength: cmd.length,
-                                exitCode: snapshot.exitCode,
-                                running: snapshot.running,
-                                processId: snapshot.processId,
-                                success: snapshot.running || snapshot.exitCode === 0,
-                                durationMs: Math.round(performance.now() - startedAt),
-                            });
-                            return processToolResponse("exec_command", workspaceId, snapshot, {
-                                command: cmd,
-                                workingDirectory: workingDirectory ?? ".",
-                                running: snapshot.running,
-                                exitCode: snapshot.exitCode,
-                                wallTimeMs: snapshot.wallTimeMs,
-                            });
-                        },
-                    });
-                    extra.signal.throwIfAborted();
-                    return result;
-                }
-                catch (error) {
-                    if (undeliveredProcessId !== undefined) {
-                        processSessions.discardUndelivered(workspaceId, undeliveredProcessId);
-                    }
-                    throw error;
-                }
-            }, processActivityOutcome);
-            markReturnedOutput(bashOutputStore, activityResult);
-            return activityResult;
-        });
+        }, async ({ workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, extra) => shellRun({
+            workspaceId,
+            command: cmd,
+            surface: "exec_command",
+            tty,
+            columns,
+            rows,
+            workingDirectory,
+            yieldTimeMs,
+            timeoutMs,
+            maxOutputTokens,
+        }, {
+            requestMeta: extra._meta,
+            signal: extra.signal,
+            sessionId: extra.sessionId,
+        }));
     }
     if (config.toolMode !== "codex")
         return;
@@ -1001,8 +1012,27 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
     const artifactDownloadAvailable = config.artifactsEnabled && isArtifactDownloadSupportedPlatform();
     const reviewChangesAvailable = config.widgets === "changes";
+    let batchExecutor;
+    const batchExecuteAvailable = config.toolMode !== "codex";
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
+        batchExecute: {
+            available: batchExecuteAvailable,
+            unavailableReason: batchExecuteAvailable
+                ? undefined
+                : "batch.execute is unavailable in Codex tool mode because v0.5.5 core batch tasks use the regular Read/Write/Edit/Bash operation surface.",
+            run: async (input, context, options) => {
+                if (!batchExecutor)
+                    throw new Error("Batch executor is not initialized.");
+                return {
+                    value: await batchExecutor.run(context.workspaceId, input, {
+                        requestMeta: options.requestMeta,
+                        signal: options.signal,
+                        sessionId: options.sessionId,
+                    }),
+                };
+            },
+        },
         codeIntelligence: {
             available: true,
             run: async (input, context, options) => {
@@ -1074,6 +1104,510 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             },
         },
     });
+    const coreOperations = createCoreOperationExecutor({
+        read: async (input, context) => {
+            const { workspaceId, ...readInput } = input;
+            const workspace = workspaces.getWorkspace(workspaceId);
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, context.requestMeta, input, {
+                signal: context.signal,
+                tool: toolNames.read,
+                invocation: workspaceHookInvocation(workspace),
+                payload: { path: readInput.path, offset: readInput.offset, limit: readInput.limit },
+                isFailure: toolResultIsError,
+                operation: async () => {
+                    const startedAt = performance.now();
+                    const readPath = workspaces.resolveReadPath(workspace, readInput.path);
+                    const discoveredInstructions = (await workspaces.discoverPathInstructions(workspace, readPath.absolutePath)).filter((file) => file.path !== readPath.absolutePath);
+                    const response = await readFileTool({ ...readInput, path: readPath.absolutePath }, {
+                        cwd: workspace.root,
+                        root: workspace.root,
+                        readRoots: readPath.readRoots,
+                    });
+                    if (response.isError) {
+                        logFailedToolResponse(config, {
+                            tool: toolNames.read,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            path: readInput.path,
+                        }, response.content, startedAt);
+                        return response;
+                    }
+                    workspaces.markReadPathLoaded(workspace, readPath);
+                    const discoveredInstructionContent = discoveredInstructions.length > 0
+                        ? textBlock(formatDiscoveredWorkspaceInstructions(discoveredInstructions, workspace.root))
+                        : undefined;
+                    const content = discoveredInstructionContent
+                        ? [discoveredInstructionContent, ...response.content]
+                        : response.content;
+                    const summary = {
+                        ...textSummary(response.content),
+                        offset: readInput.offset ?? 1,
+                        limited: readInput.limit !== undefined,
+                    };
+                    logToolCall(config, {
+                        tool: toolNames.read,
+                        ...workspaceLogContext(workspace, context.sessionId),
+                        path: readInput.path,
+                        success: true,
+                        durationMs: Math.round(performance.now() - startedAt),
+                    });
+                    return {
+                        ...response,
+                        content,
+                        _meta: {
+                            tool: toolNames.read,
+                            card: {
+                                workspaceId,
+                                path: readInput.path,
+                                summary,
+                                payload: { content: response.content },
+                            },
+                        },
+                        structuredContent: {
+                            result: contentText(content),
+                            ...(discoveredInstructions.length > 0
+                                ? {
+                                    agentsFiles: discoveredInstructions.map((file) => ({
+                                        path: formatAgentsPath(file.path, workspace.root),
+                                        content: file.content,
+                                    })),
+                                }
+                                : {}),
+                        },
+                    };
+                },
+            }, activityRelationFor(context));
+        },
+        write: async (input, context) => {
+            const { workspaceId, ...writeInput } = input;
+            const workspace = workspaces.getWorkspace(workspaceId);
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, context.requestMeta, input, {
+                signal: context.signal,
+                tool: toolNames.write,
+                invocation: workspaceHookInvocation(workspace),
+                payload: { path: writeInput.path },
+                isFailure: toolResultIsError,
+                changedPaths: (result) => toolResultIsError(result) ? [] : [writeInput.path],
+                operation: async () => {
+                    const startedAt = performance.now();
+                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [writeInput.path]);
+                    const response = await writeFileTool(writeInput, {
+                        cwd: workspace.root,
+                        root: workspace.root,
+                        fileRoots: workspaces.fileToolRoots(workspace),
+                    });
+                    if (response.isError) {
+                        logFailedToolResponse(config, {
+                            tool: toolNames.write,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            path: writeInput.path,
+                        }, response.content, startedAt);
+                        return response;
+                    }
+                    const patch = newFilePatch(writeInput.path, writeInput.content);
+                    const stats = countDiffStats(patch);
+                    const summary = {
+                        ...stats,
+                        lines: contentLineCount(writeInput.content),
+                        characters: writeInput.content.length,
+                    };
+                    logToolCall(config, {
+                        tool: toolNames.write,
+                        ...workspaceLogContext(workspace, context.sessionId),
+                        path: writeInput.path,
+                        success: true,
+                        durationMs: Math.round(performance.now() - startedAt),
+                    });
+                    return {
+                        ...response,
+                        _meta: {
+                            tool: toolNames.write,
+                            card: {
+                                workspaceId,
+                                path: writeInput.path,
+                                summary,
+                                payload: {
+                                    content: response.content,
+                                    patch,
+                                },
+                            },
+                        },
+                        structuredContent: {
+                            result: contentText(response.content),
+                        },
+                    };
+                },
+            }, activityRelationFor(context));
+        },
+        edit: async (input, context) => {
+            const { workspaceId, ...editInput } = input;
+            const workspace = workspaces.getWorkspace(workspaceId);
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, context.requestMeta, input, {
+                signal: context.signal,
+                tool: toolNames.edit,
+                invocation: workspaceHookInvocation(workspace),
+                payload: { path: editInput.path, editCount: editInput.edits.length },
+                isFailure: toolResultIsError,
+                changedPaths: (result) => toolResultIsError(result) ? [] : [editInput.path],
+                operation: async () => {
+                    const startedAt = performance.now();
+                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [editInput.path]);
+                    const response = await editFileTool(editInput, {
+                        cwd: workspace.root,
+                        root: workspace.root,
+                        fileRoots: workspaces.fileToolRoots(workspace),
+                    });
+                    if (response.isError) {
+                        logFailedToolResponse(config, {
+                            tool: toolNames.edit,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            path: editInput.path,
+                        }, response.content, startedAt);
+                        return response;
+                    }
+                    const stats = countDiffStats(response.details?.patch ?? response.details?.diff);
+                    const summary = {
+                        ...stats,
+                        editCount: editInput.edits.length,
+                    };
+                    const editResultText = `Edited ${editInput.path} (+${stats.additions} -${stats.removals}).`;
+                    const editContent = [textBlock(editResultText)];
+                    logToolCall(config, {
+                        tool: toolNames.edit,
+                        ...workspaceLogContext(workspace, context.sessionId),
+                        path: editInput.path,
+                        success: true,
+                        durationMs: Math.round(performance.now() - startedAt),
+                    });
+                    return {
+                        content: editContent,
+                        _meta: {
+                            tool: toolNames.edit,
+                            card: {
+                                workspaceId,
+                                path: editInput.path,
+                                summary,
+                                payload: {
+                                    diff: response.details?.diff,
+                                    patch: response.details?.patch,
+                                },
+                            },
+                        },
+                        structuredContent: {
+                            status: "applied",
+                            result: contentText(editContent),
+                        },
+                    };
+                },
+            }, activityRelationFor(context));
+        },
+        rename: async (input, context) => {
+            const { workspaceId, path, newPath } = input;
+            const workspace = workspaces.getWorkspace(workspaceId);
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, context.requestMeta, input, {
+                signal: context.signal,
+                tool: toolNames.rename,
+                invocation: workspaceHookInvocation(workspace),
+                payload: { path, newPath, paths: [path, newPath] },
+                changedPaths: () => [path, newPath],
+                operation: async () => {
+                    const startedAt = performance.now();
+                    try {
+                        await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [path, newPath]);
+                        await renamePath({ path, newPath }, {
+                            cwd: workspace.root,
+                            allowedRoots: workspaces.fileToolRoots(workspace),
+                        });
+                        const result = `Renamed ${path} to ${newPath}.`;
+                        const content = [textBlock(result)];
+                        logToolCall(config, {
+                            tool: toolNames.rename,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            path: `${path} -> ${newPath}`,
+                            success: true,
+                            durationMs: Math.round(performance.now() - startedAt),
+                        });
+                        return {
+                            content,
+                            _meta: {
+                                tool: toolNames.rename,
+                                card: {
+                                    workspaceId,
+                                    path: newPath,
+                                    summary: { previousPath: path },
+                                    payload: { content },
+                                },
+                            },
+                            structuredContent: {
+                                result,
+                                status: "renamed",
+                                path,
+                                newPath,
+                            },
+                        };
+                    }
+                    catch (error) {
+                        logToolCall(config, {
+                            tool: toolNames.rename,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            path: `${path} -> ${newPath}`,
+                            success: false,
+                            durationMs: Math.round(performance.now() - startedAt),
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        throw error;
+                    }
+                },
+            }, activityRelationFor(context));
+        },
+        delete: async (input, context) => {
+            const { workspaceId, path, recursive } = input;
+            const workspace = workspaces.getWorkspace(workspaceId);
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, context.requestMeta, input, {
+                signal: context.signal,
+                tool: toolNames.delete,
+                invocation: workspaceHookInvocation(workspace),
+                payload: { path, recursive: recursive ?? false },
+                changedPaths: () => [path],
+                operation: async () => {
+                    const startedAt = performance.now();
+                    try {
+                        await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [path]);
+                        const deleted = await deletePath({ path, recursive }, {
+                            cwd: workspace.root,
+                            allowedRoots: workspaces.fileToolRoots(workspace),
+                        });
+                        const result = `Deleted ${path}${deleted.recursive ? " recursively" : ""}.`;
+                        const content = [textBlock(result)];
+                        logToolCall(config, {
+                            tool: toolNames.delete,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            path,
+                            success: true,
+                            durationMs: Math.round(performance.now() - startedAt),
+                        });
+                        return {
+                            content,
+                            _meta: {
+                                tool: toolNames.delete,
+                                card: {
+                                    workspaceId,
+                                    path,
+                                    summary: { recursive: deleted.recursive },
+                                    payload: { content },
+                                },
+                            },
+                            structuredContent: {
+                                result,
+                                status: "deleted",
+                                path,
+                                recursive: deleted.recursive,
+                            },
+                        };
+                    }
+                    catch (error) {
+                        logToolCall(config, {
+                            tool: toolNames.delete,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            path,
+                            success: false,
+                            durationMs: Math.round(performance.now() - startedAt),
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        throw error;
+                    }
+                },
+            }, activityRelationFor(context));
+        },
+        shellRun: async (input, context) => {
+            const { workspaceId, command, surface, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, } = input;
+            const workspace = workspaces.getWorkspace(workspaceId);
+            const activityRequest = surface === "exec_command"
+                ? {
+                    workspaceId,
+                    cmd: command,
+                    tty,
+                    columns,
+                    rows,
+                    workingDirectory,
+                    yieldTimeMs,
+                    timeoutMs,
+                    maxOutputTokens,
+                }
+                : {
+                    workspaceId,
+                    action: "run",
+                    command,
+                    tty,
+                    columns,
+                    rows,
+                    workingDirectory,
+                    yieldTimeMs,
+                    timeoutMs,
+                    maxOutputTokens,
+                };
+            let undeliveredProcessId;
+            const activityResult = await runActivityTool(activityLifecycle, workspace, context.requestMeta, surface, activityRequest, async (activityContext) => {
+                try {
+                    const result = await runToolWithHooks(hooks, {
+                        signal: context.signal,
+                        tool: surface,
+                        invocation: workspaceHookInvocation(workspace),
+                        payload: surface === "exec_command"
+                            ? { command, workingDirectory: workingDirectory ?? "." }
+                            : { action: "run", command, workingDirectory: workingDirectory ?? "." },
+                        ...(surface === "bash" ? { isFailure: toolResultIsError } : {}),
+                        operation: async () => {
+                            const startedAt = performance.now();
+                            const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+                            await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
+                            const snapshot = await processSessions.start({
+                                workspaceId,
+                                command,
+                                cwd,
+                                workspaceRoot: workspace.root,
+                                tty,
+                                columns,
+                                rows,
+                                yieldTimeMs,
+                                timeoutMs,
+                                maxOutputTokens,
+                                ...(surface === "exec_command" ? { codexCi: true } : {}),
+                                signal: context.signal,
+                                audit: activityContext,
+                            });
+                            undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
+                            logToolCall(config, {
+                                tool: surface,
+                                ...workspaceLogContext(workspace, context.sessionId),
+                                workingDirectory: workingDirectory ?? ".",
+                                command,
+                                commandLength: command.length,
+                                exitCode: snapshot.exitCode,
+                                running: snapshot.running,
+                                processId: snapshot.processId,
+                                success: surface === "exec_command"
+                                    ? snapshot.running || snapshot.exitCode === 0
+                                    : snapshot.running || (snapshot.exitCode === 0 && !snapshot.signal),
+                                durationMs: Math.round(performance.now() - startedAt),
+                            });
+                            const response = processToolResponse(surface, workspaceId, snapshot, {
+                                ...(surface === "bash" ? { action: "run" } : {}),
+                                command,
+                                workingDirectory: workingDirectory ?? ".",
+                                running: snapshot.running,
+                                exitCode: snapshot.exitCode,
+                                wallTimeMs: snapshot.wallTimeMs,
+                            });
+                            return surface === "bash" && !snapshot.running && (snapshot.signal || snapshot.exitCode !== 0)
+                                ? { ...response, isError: true }
+                                : response;
+                        },
+                    });
+                    context.signal?.throwIfAborted();
+                    return result;
+                }
+                catch (error) {
+                    if (undeliveredProcessId !== undefined) {
+                        processSessions.discardUndelivered(workspaceId, undeliveredProcessId);
+                    }
+                    throw error;
+                }
+            }, processActivityOutcome, activityRelationFor(context));
+            markReturnedOutput(bashOutputStore, activityResult);
+            return activityResult;
+        },
+        capabilityRun: async (input, context) => {
+            const { workspaceId, name, arguments: capabilityArguments, file } = input;
+            const workspace = workspaces.getWorkspace(workspaceId);
+            let changedPaths = [];
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, context.requestMeta, { workspaceId, name, action: "run", arguments: capabilityArguments, file }, {
+                signal: context.signal,
+                tool: toolNames.capability,
+                invocation: workspaceHookInvocation(workspace),
+                payload: { name, action: "run" },
+                isFailure: toolResultIsError,
+                changedPaths: () => changedPaths,
+                operation: async () => {
+                    const startedAt = performance.now();
+                    try {
+                        const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), {
+                            nativeFile: file,
+                            signal: context.signal,
+                            requestMeta: context.requestMeta,
+                            sessionId: context.sessionId,
+                            batch: context.batch,
+                        });
+                        changedPaths = execution.changedPaths ?? [];
+                        const result = {
+                            content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
+                            ...(execution.card
+                                ? {
+                                    _meta: {
+                                        tool: toolNames.capability,
+                                        card: {
+                                            workspaceId,
+                                            capabilityName: name,
+                                            summary: execution.card.summary ?? {},
+                                            files: execution.card.files,
+                                            payload: execution.card.payload ?? {},
+                                        },
+                                    },
+                                }
+                                : {}),
+                            structuredContent: { name, action: "run", result: execution.value },
+                        };
+                        logToolCall(config, {
+                            tool: toolNames.capability,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            capability: name,
+                            action: "run",
+                            success: true,
+                            durationMs: Math.round(performance.now() - startedAt),
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        const capabilityError = error instanceof CapabilityError
+                            ? error
+                            : new CapabilityError("execution_failed", error instanceof Error ? error.message : String(error));
+                        const result = {
+                            content: [textBlock(`${capabilityError.code}: ${capabilityError.message}`)],
+                            structuredContent: {
+                                name,
+                                action: "run",
+                                error: { code: capabilityError.code, message: capabilityError.message },
+                            },
+                            isError: true,
+                        };
+                        logFailedToolResponse(config, {
+                            tool: toolNames.capability,
+                            ...workspaceLogContext(workspace, context.sessionId),
+                            capability: name,
+                            action: "run",
+                        }, result.content, startedAt);
+                        return result;
+                    }
+                },
+            }, activityRelationFor(context));
+        },
+    });
+    batchExecutor = new BatchExecutor({
+        lifecycle: activityLifecycle,
+        workspaces,
+        coreOperations,
+        resultIsError: toolResultIsError,
+        capabilityBatchPolicy: (name) => capabilityRegistry.batchPolicy(name),
+        shellSurface: "bash",
+    });
+    const nativeBulkMutations = new NativeBulkMutationExecutor({
+        lifecycle: activityLifecycle,
+        workspaces,
+        coreOperations,
+        preflightInstructions: (workspace, paths) => assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, paths),
+        resultIsError: toolResultIsError,
+        resultText: toolResultText,
+        resultContent: toolResultContent,
+    });
     const server = new McpServer({
         name: "forgerelay",
         title: "ForgeRelay",
@@ -1506,60 +2040,82 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             openWorldHint: true,
         },
     }, async ({ workspaceId, name, action, arguments: capabilityArguments, file }, extra) => {
+        if (action === "run" && name === "batch.execute") {
+            const workspace = workspaces.getWorkspace(workspaceId);
+            const startedAt = performance.now();
+            try {
+                const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), {
+                    nativeFile: file,
+                    signal: extra.signal,
+                    requestMeta: extra._meta,
+                    sessionId: extra.sessionId,
+                });
+                const result = {
+                    content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
+                    structuredContent: { name, action, result: execution.value },
+                };
+                logToolCall(config, {
+                    tool: toolNames.capability,
+                    ...workspaceLogContext(workspace, extra.sessionId),
+                    capability: name,
+                    action,
+                    success: true,
+                    durationMs: Math.round(performance.now() - startedAt),
+                });
+                return result;
+            }
+            catch (error) {
+                if (extra.signal.aborted)
+                    throw error;
+                const capabilityError = error instanceof CapabilityError
+                    ? error
+                    : new CapabilityError("execution_failed", error instanceof Error ? error.message : String(error));
+                const result = {
+                    content: [textBlock(`${capabilityError.code}: ${capabilityError.message}`)],
+                    structuredContent: {
+                        name,
+                        action,
+                        error: { code: capabilityError.code, message: capabilityError.message },
+                    },
+                    isError: true,
+                };
+                logFailedToolResponse(config, {
+                    tool: toolNames.capability,
+                    ...workspaceLogContext(workspace, extra.sessionId),
+                    capability: name,
+                    action,
+                }, result.content, startedAt);
+                return result;
+            }
+        }
+        if (action === "run") {
+            return coreOperations.capabilityRun({ workspaceId, name, arguments: capabilityArguments, file }, {
+                requestMeta: extra._meta,
+                signal: extra.signal,
+                sessionId: extra.sessionId,
+            });
+        }
         const workspace = workspaces.getWorkspace(workspaceId);
-        let changedPaths = [];
         return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, name, action, arguments: capabilityArguments, file }, {
             signal: extra.signal,
             tool: toolNames.capability,
             invocation: workspaceHookInvocation(workspace),
             payload: { name, action },
             isFailure: toolResultIsError,
-            changedPaths: () => changedPaths,
             operation: async () => {
                 const startedAt = performance.now();
                 try {
-                    if (action === "describe") {
-                        const capability = capabilityRegistry.describe(name, capabilityContextFor(workspace));
-                        const result = {
-                            content: [textBlock([
-                                    `${capability.name}: ${capability.description}`,
-                                    `Available: ${capability.available}`,
-                                    `Guide: ${capability.guide.path}`,
-                                    capability.guide.readBeforeFirstUse
-                                        ? "Read the guide before first use when this contract is unfamiliar."
-                                        : undefined,
-                                ].filter(Boolean).join("\n"))],
-                            structuredContent: { name, action, capability },
-                        };
-                        logToolCall(config, {
-                            tool: toolNames.capability,
-                            ...workspaceLogContext(workspace),
-                            capability: name,
-                            action,
-                            success: true,
-                            durationMs: Math.round(performance.now() - startedAt),
-                        });
-                        return result;
-                    }
-                    const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), { nativeFile: file, signal: extra.signal });
-                    changedPaths = execution.changedPaths ?? [];
-                    const result = {
-                        content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
-                        ...(execution.card
-                            ? {
-                                _meta: {
-                                    tool: toolNames.capability,
-                                    card: {
-                                        workspaceId,
-                                        capabilityName: name,
-                                        summary: execution.card.summary ?? {},
-                                        files: execution.card.files,
-                                        payload: execution.card.payload ?? {},
-                                    },
-                                },
-                            }
-                            : {}),
-                        structuredContent: { name, action, result: execution.value },
+                    const capability = capabilityRegistry.describe(name, capabilityContextFor(workspace));
+                    const result = {
+                        content: [textBlock([
+                                `${capability.name}: ${capability.description}`,
+                                `Available: ${capability.available}`,
+                                `Guide: ${capability.guide.path}`,
+                                capability.guide.readBeforeFirstUse
+                                    ? "Read the guide before first use when this contract is unfamiliar."
+                                    : undefined,
+                            ].filter(Boolean).join("\n"))],
+                        structuredContent: { name, action, capability },
                     };
                     logToolCall(config, {
                         tool: toolNames.capability,
@@ -1708,9 +2264,16 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 .describe("Workspace identifier returned by open_workspace."),
             path: z
                 .string()
+                .optional()
                 .describe(config.skillsEnabled
-                ? "File path to read, relative to the workspace root or absolute inside the OS temp directory. May also be an advertised skill or capability-guide path from open_workspace, including a ~/... home-relative path."
-                : "File path to read, relative to the workspace root or absolute inside the OS temp directory. May also be an advertised capability-guide path from open_workspace."),
+                ? "One file path to read, relative to the workspace root or absolute inside the OS temp directory. May also be an advertised skill or capability-guide path from open_workspace, including a ~/... home-relative path. Use exactly one of path or paths."
+                : "One file path to read, relative to the workspace root or absolute inside the OS temp directory. May also be an advertised capability-guide path from open_workspace. Use exactly one of path or paths."),
+            paths: z
+                .array(z.string())
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("Multiple file paths to read in one call. Uses the same offset/limit for every file. Use exactly one of path or paths."),
             offset: z
                 .number()
                 .int()
@@ -1726,79 +2289,81 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         },
         outputSchema: resultOutputSchema({
             agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
+            results: z.array(z.object({
+                path: z.string(),
+                status: z.enum(["done", "error"]),
+                result: z.string(),
+            })).optional(),
+            files: z.number().int().nonnegative().optional(),
+            failed: z.number().int().nonnegative().optional(),
         }),
         ...toolWidgetDescriptorMeta(config, "read"),
         annotations: { readOnlyHint: true },
-    }, async ({ workspaceId, ...input }, extra) => {
+    }, async ({ workspaceId, path, paths, offset, limit }, extra) => {
+        if ((path === undefined) === (paths === undefined)) {
+            throw new Error("read requires exactly one of path or paths.");
+        }
+        if (path !== undefined) {
+            return coreOperations.read({ workspaceId, path, offset, limit }, {
+                requestMeta: extra._meta,
+                signal: extra.signal,
+                sessionId: extra.sessionId,
+            });
+        }
         const workspace = workspaces.getWorkspace(workspaceId);
-        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, ...input }, {
-            signal: extra.signal,
-            tool: toolNames.read,
-            invocation: workspaceHookInvocation(workspace),
-            payload: { path: input.path, offset: input.offset, limit: input.limit },
-            isFailure: toolResultIsError,
-            operation: async () => {
-                const startedAt = performance.now();
-                const readPath = workspaces.resolveReadPath(workspace, input.path);
-                const discoveredInstructions = (await workspaces.discoverPathInstructions(workspace, readPath.absolutePath)).filter((file) => file.path !== readPath.absolutePath);
-                const response = await readFileTool({ ...input, path: readPath.absolutePath }, {
-                    cwd: workspace.root,
-                    root: workspace.root,
-                    readRoots: readPath.readRoots,
-                });
-                if (response.isError) {
-                    logFailedToolResponse(config, {
-                        tool: toolNames.read,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: input.path,
-                    }, response.content, startedAt);
-                    return response;
-                }
-                workspaces.markReadPathLoaded(workspace, readPath);
-                const discoveredInstructionContent = discoveredInstructions.length > 0
-                    ? textBlock(formatDiscoveredWorkspaceInstructions(discoveredInstructions, workspace.root))
-                    : undefined;
-                const content = discoveredInstructionContent
-                    ? [discoveredInstructionContent, ...response.content]
-                    : response.content;
-                const summary = {
-                    ...textSummary(response.content),
-                    offset: input.offset ?? 1,
-                    limited: input.limit !== undefined,
-                };
-                logToolCall(config, {
-                    tool: toolNames.read,
-                    ...workspaceLogContext(workspace, extra.sessionId),
-                    path: input.path,
-                    success: true,
-                    durationMs: Math.round(performance.now() - startedAt),
-                });
-                return {
-                    ...response,
-                    content,
-                    _meta: {
-                        tool: toolNames.read,
-                        card: {
-                            workspaceId,
-                            path: input.path,
-                            summary,
-                            payload: { content: response.content },
-                        },
-                    },
-                    structuredContent: {
-                        result: contentText(content),
-                        ...(discoveredInstructions.length > 0
-                            ? {
-                                agentsFiles: discoveredInstructions.map((file) => ({
-                                    path: formatAgentsPath(file.path, workspace.root),
-                                    content: file.content,
-                                })),
-                            }
-                            : {}),
-                    },
-                };
-            },
-        });
+        let response;
+        await runActivityTool(activityLifecycle, workspace, extra._meta, toolNames.read, { workspaceId, paths, offset, limit }, async (parentContext) => {
+            const execution = await executeBulkRead({
+                paths: paths,
+                signal: extra.signal,
+                run: (childPath) => coreOperations.read({ workspaceId, path: childPath, offset, limit }, {
+                    requestMeta: extra._meta,
+                    signal: extra.signal,
+                    sessionId: extra.sessionId,
+                    parentActivityId: parentContext.activityId,
+                    turnId: parentContext.turnId,
+                }),
+                isError: toolResultIsError,
+                resultText: toolResultText,
+            });
+            const content = execution.children.flatMap((child) => [
+                textBlock(`--- ${child.path} · ${child.status} ---`),
+                ...(child.response
+                    ? toolResultContent(child.response)
+                    : [textBlock(child.result)]),
+            ]);
+            const seenAgentPaths = new Set();
+            const agentsFiles = execution.children.flatMap((child) => child.response ? toolResultAgentsFiles(child.response) : []).filter((file) => {
+                if (seenAgentPaths.has(file.path))
+                    return false;
+                seenAgentPaths.add(file.path);
+                return true;
+            });
+            response = {
+                content,
+                structuredContent: {
+                    result: contentText(content),
+                    results: execution.children.map(({ path: childPath, status, result }) => ({
+                        path: childPath,
+                        status,
+                        result,
+                    })),
+                    files: execution.children.length,
+                    failed: execution.failed,
+                    ...(agentsFiles.length > 0 ? { agentsFiles } : {}),
+                },
+            };
+            return {
+                childCount: execution.children.length,
+                succeeded: execution.succeeded,
+                failed: execution.failed,
+            };
+        }, (summary) => summary.failed > 0
+            ? { type: "failed", error: `${summary.failed} of ${summary.childCount} child Reads failed.` }
+            : { type: "succeeded" });
+        if (!response)
+            throw new Error("Bulk Read completed without a response.");
+        return response;
     });
     if (config.toolMode !== "codex") {
         registerAppTool(server, toolNames.write, {
@@ -1816,66 +2381,11 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             outputSchema: resultOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "write"),
             annotations: WRITE_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, ...input }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, ...input }, {
-                signal: extra.signal,
-                tool: toolNames.write,
-                invocation: workspaceHookInvocation(workspace),
-                payload: { path: input.path },
-                isFailure: toolResultIsError,
-                changedPaths: (result) => toolResultIsError(result) ? [] : [input.path],
-                operation: async () => {
-                    const startedAt = performance.now();
-                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [input.path]);
-                    const response = await writeFileTool(input, {
-                        cwd: workspace.root,
-                        root: workspace.root,
-                        fileRoots: workspaces.fileToolRoots(workspace),
-                    });
-                    if (response.isError) {
-                        logFailedToolResponse(config, {
-                            tool: toolNames.write,
-                            ...workspaceLogContext(workspace, extra.sessionId),
-                            path: input.path,
-                        }, response.content, startedAt);
-                        return response;
-                    }
-                    const patch = newFilePatch(input.path, input.content);
-                    const stats = countDiffStats(patch);
-                    const summary = {
-                        ...stats,
-                        lines: contentLineCount(input.content),
-                        characters: input.content.length,
-                    };
-                    logToolCall(config, {
-                        tool: toolNames.write,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: input.path,
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        ...response,
-                        _meta: {
-                            tool: toolNames.write,
-                            card: {
-                                workspaceId,
-                                path: input.path,
-                                summary,
-                                payload: {
-                                    content: response.content,
-                                    patch,
-                                },
-                            },
-                        },
-                        structuredContent: {
-                            result: contentText(response.content),
-                        },
-                    };
-                },
-            });
-        });
+        }, async ({ workspaceId, ...input }, extra) => coreOperations.write({ workspaceId, ...input }, {
+            requestMeta: extra._meta,
+            signal: extra.signal,
+            sessionId: extra.sessionId,
+        }));
         registerAppTool(server, toolNames.edit, {
             title: "Edit file",
             description: toolDescriptions.edit,
@@ -1885,7 +2395,14 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     .describe("Workspace identifier returned by open_workspace."),
                 path: z
                     .string()
-                    .describe("File path to edit, relative to the workspace root or absolute inside the OS temp directory."),
+                    .optional()
+                    .describe("One file path to edit. Use exactly one of path or paths."),
+                paths: z
+                    .array(z.string())
+                    .min(1)
+                    .max(100)
+                    .optional()
+                    .describe("Multiple file paths to edit with the same edits. Use exactly one of path or paths."),
                 edits: z
                     .array(z.object({
                     oldText: z
@@ -1896,69 +2413,34 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     .min(1),
             },
             outputSchema: resultOutputSchema({
-                status: z.literal("applied"),
+                status: z.enum(["applied", "partial"]),
+                results: z.array(z.object({
+                    path: z.string(),
+                    status: z.enum(["done", "error", "unexecuted"]),
+                    result: z.string().optional(),
+                })).optional(),
+                files: z.number().int().nonnegative().optional(),
+                completed: z.number().int().nonnegative().optional(),
+                failed: z.number().int().nonnegative().optional(),
+                unexecuted: z.number().int().nonnegative().optional(),
             }),
             ...toolWidgetDescriptorMeta(config, "edit"),
             annotations: EDIT_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, ...input }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, ...input }, {
+        }, async ({ workspaceId, path, paths, edits }, extra) => {
+            if ((path === undefined) === (paths === undefined)) {
+                throw new Error("edit requires exactly one of path or paths.");
+            }
+            if (path !== undefined) {
+                return coreOperations.edit({ workspaceId, path, edits }, {
+                    requestMeta: extra._meta,
+                    signal: extra.signal,
+                    sessionId: extra.sessionId,
+                });
+            }
+            return nativeBulkMutations.edit({ workspaceId, paths: paths, edits }, {
+                requestMeta: extra._meta,
                 signal: extra.signal,
-                tool: toolNames.edit,
-                invocation: workspaceHookInvocation(workspace),
-                payload: { path: input.path, editCount: input.edits.length },
-                isFailure: toolResultIsError,
-                changedPaths: (result) => toolResultIsError(result) ? [] : [input.path],
-                operation: async () => {
-                    const startedAt = performance.now();
-                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [input.path]);
-                    const response = await editFileTool(input, {
-                        cwd: workspace.root,
-                        root: workspace.root,
-                        fileRoots: workspaces.fileToolRoots(workspace),
-                    });
-                    if (response.isError) {
-                        logFailedToolResponse(config, {
-                            tool: toolNames.edit,
-                            ...workspaceLogContext(workspace, extra.sessionId),
-                            path: input.path,
-                        }, response.content, startedAt);
-                        return response;
-                    }
-                    const stats = countDiffStats(response.details?.patch ?? response.details?.diff);
-                    const summary = {
-                        ...stats,
-                        editCount: input.edits.length,
-                    };
-                    const editResultText = `Edited ${input.path} (+${stats.additions} -${stats.removals}).`;
-                    const editContent = [textBlock(editResultText)];
-                    logToolCall(config, {
-                        tool: toolNames.edit,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: input.path,
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        content: editContent,
-                        _meta: {
-                            tool: toolNames.edit,
-                            card: {
-                                workspaceId,
-                                path: input.path,
-                                summary,
-                                payload: {
-                                    diff: response.details?.diff,
-                                    patch: response.details?.patch,
-                                },
-                            },
-                        },
-                        structuredContent: {
-                            status: "applied",
-                            result: contentText(editContent),
-                        },
-                    };
-                },
+                sessionId: extra.sessionId,
             });
         });
     }
@@ -1977,135 +2459,56 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         }),
         ...toolWidgetDescriptorMeta(config, "edit"),
         annotations: EDIT_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, path, newPath }, extra) => {
-        const workspace = workspaces.getWorkspace(workspaceId);
-        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, path, newPath }, {
-            signal: extra.signal,
-            tool: toolNames.rename,
-            invocation: workspaceHookInvocation(workspace),
-            payload: { path, newPath, paths: [path, newPath] },
-            changedPaths: () => [path, newPath],
-            operation: async () => {
-                const startedAt = performance.now();
-                try {
-                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [path, newPath]);
-                    await renamePath({ path, newPath }, {
-                        cwd: workspace.root,
-                        allowedRoots: workspaces.fileToolRoots(workspace),
-                    });
-                    const result = `Renamed ${path} to ${newPath}.`;
-                    const content = [textBlock(result)];
-                    logToolCall(config, {
-                        tool: toolNames.rename,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: `${path} -> ${newPath}`,
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        content,
-                        _meta: {
-                            tool: toolNames.rename,
-                            card: {
-                                workspaceId,
-                                path: newPath,
-                                summary: { previousPath: path },
-                                payload: { content },
-                            },
-                        },
-                        structuredContent: {
-                            result,
-                            status: "renamed",
-                            path,
-                            newPath,
-                        },
-                    };
-                }
-                catch (error) {
-                    logToolCall(config, {
-                        tool: toolNames.rename,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: `${path} -> ${newPath}`,
-                        success: false,
-                        durationMs: Math.round(performance.now() - startedAt),
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    throw error;
-                }
-            },
-        });
-    });
+    }, async ({ workspaceId, path, newPath }, extra) => coreOperations.rename({ workspaceId, path, newPath }, {
+        requestMeta: extra._meta,
+        signal: extra.signal,
+        sessionId: extra.sessionId,
+    }));
     registerAppTool(server, toolNames.delete, {
         title: "Delete path",
         description: toolDescriptions.delete,
         inputSchema: {
             workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
-            path: z.string().describe("File or directory path relative to the workspace root, or absolute inside the OS temp directory."),
-            recursive: z.boolean().optional().describe("Delete a non-empty directory tree. Defaults to false."),
+            path: z.string().optional().describe("One file or directory path to delete. Use exactly one of path or paths."),
+            paths: z
+                .array(z.string())
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("Multiple paths to delete in one call. Use exactly one of path or paths."),
+            recursive: z.boolean().optional().describe("Delete non-empty directory trees. Defaults to false and applies to every bulk target."),
         },
         outputSchema: resultOutputSchema({
-            status: z.literal("deleted"),
-            path: z.string(),
-            recursive: z.boolean(),
+            status: z.enum(["deleted", "partial"]),
+            path: z.string().optional(),
+            recursive: z.boolean().optional(),
+            results: z.array(z.object({
+                path: z.string(),
+                status: z.enum(["done", "error", "unexecuted"]),
+                result: z.string().optional(),
+            })).optional(),
+            paths: z.number().int().nonnegative().optional(),
+            completed: z.number().int().nonnegative().optional(),
+            failed: z.number().int().nonnegative().optional(),
+            unexecuted: z.number().int().nonnegative().optional(),
         }),
         ...toolWidgetDescriptorMeta(config, "edit"),
         annotations: EDIT_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, path, recursive }, extra) => {
-        const workspace = workspaces.getWorkspace(workspaceId);
-        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, path, recursive }, {
+    }, async ({ workspaceId, path, paths, recursive }, extra) => {
+        if ((path === undefined) === (paths === undefined)) {
+            throw new Error("delete requires exactly one of path or paths.");
+        }
+        if (path !== undefined) {
+            return coreOperations.delete({ workspaceId, path, recursive }, {
+                requestMeta: extra._meta,
+                signal: extra.signal,
+                sessionId: extra.sessionId,
+            });
+        }
+        return nativeBulkMutations.delete({ workspaceId, paths: paths, recursive }, {
+            requestMeta: extra._meta,
             signal: extra.signal,
-            tool: toolNames.delete,
-            invocation: workspaceHookInvocation(workspace),
-            payload: { path, recursive: recursive ?? false },
-            changedPaths: () => [path],
-            operation: async () => {
-                const startedAt = performance.now();
-                try {
-                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [path]);
-                    const deleted = await deletePath({ path, recursive }, {
-                        cwd: workspace.root,
-                        allowedRoots: workspaces.fileToolRoots(workspace),
-                    });
-                    const result = `Deleted ${path}${deleted.recursive ? " recursively" : ""}.`;
-                    const content = [textBlock(result)];
-                    logToolCall(config, {
-                        tool: toolNames.delete,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path,
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        content,
-                        _meta: {
-                            tool: toolNames.delete,
-                            card: {
-                                workspaceId,
-                                path,
-                                summary: { recursive: deleted.recursive },
-                                payload: { content },
-                            },
-                        },
-                        structuredContent: {
-                            result,
-                            status: "deleted",
-                            path,
-                            recursive: deleted.recursive,
-                        },
-                    };
-                }
-                catch (error) {
-                    logToolCall(config, {
-                        tool: toolNames.delete,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path,
-                        success: false,
-                        durationMs: Math.round(performance.now() - startedAt),
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    throw error;
-                }
-            },
+            sessionId: extra.sessionId,
         });
     });
     if (config.toolMode === "codex") {
@@ -2272,11 +2675,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 if (processId !== undefined || outputId !== undefined || input !== undefined || interrupt !== undefined) {
                     throw new Error("bash action=run does not accept processId, outputId, input, or interrupt.");
                 }
-                let undeliveredProcessId;
-                const activityResult = await runActivityTool(activityLifecycle, workspace, extra._meta, toolNames.shell, {
+                return coreOperations.shellRun({
                     workspaceId,
-                    action,
                     command,
+                    surface: "bash",
                     tty,
                     columns,
                     rows,
@@ -2284,74 +2686,11 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     yieldTimeMs,
                     timeoutMs,
                     maxOutputTokens,
-                }, async (activityContext) => {
-                    try {
-                        const result = await runToolWithHooks(hooks, {
-                            signal: extra.signal,
-                            tool: toolNames.shell,
-                            invocation: workspaceHookInvocation(workspace),
-                            payload: {
-                                action,
-                                command,
-                                workingDirectory: workingDirectory ?? ".",
-                            },
-                            isFailure: toolResultIsError,
-                            operation: async () => {
-                                const startedAt = performance.now();
-                                const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
-                                await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
-                                const snapshot = await processSessions.start({
-                                    workspaceId,
-                                    command,
-                                    cwd,
-                                    workspaceRoot: workspace.root,
-                                    tty,
-                                    columns,
-                                    rows,
-                                    yieldTimeMs,
-                                    timeoutMs,
-                                    maxOutputTokens,
-                                    signal: extra.signal,
-                                    audit: activityContext,
-                                });
-                                undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
-                                logToolCall(config, {
-                                    tool: toolNames.shell,
-                                    ...workspaceLogContext(workspace, extra.sessionId),
-                                    workingDirectory: workingDirectory ?? ".",
-                                    command,
-                                    commandLength: command.length,
-                                    exitCode: snapshot.exitCode,
-                                    running: snapshot.running,
-                                    processId: snapshot.processId,
-                                    success: snapshot.running || (snapshot.exitCode === 0 && !snapshot.signal),
-                                    durationMs: Math.round(performance.now() - startedAt),
-                                });
-                                const response = processToolResponse(toolNames.shell, workspaceId, snapshot, {
-                                    action,
-                                    command,
-                                    workingDirectory: workingDirectory ?? ".",
-                                    running: snapshot.running,
-                                    exitCode: snapshot.exitCode,
-                                    wallTimeMs: snapshot.wallTimeMs,
-                                });
-                                return !snapshot.running && (snapshot.signal || snapshot.exitCode !== 0)
-                                    ? { ...response, isError: true }
-                                    : response;
-                            },
-                        });
-                        extra.signal.throwIfAborted();
-                        return result;
-                    }
-                    catch (error) {
-                        if (undeliveredProcessId !== undefined) {
-                            processSessions.discardUndelivered(workspaceId, undeliveredProcessId);
-                        }
-                        throw error;
-                    }
-                }, processActivityOutcome);
-                markReturnedOutput(bashOutputStore, activityResult);
-                return activityResult;
+                }, {
+                    requestMeta: extra._meta,
+                    signal: extra.signal,
+                    sessionId: extra.sessionId,
+                });
             }
             if (action === "output") {
                 if (!outputId)
@@ -2430,7 +2769,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             });
         });
     }
-    registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore);
+    registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore, (input, context) => coreOperations.shellRun(input, context));
     return server;
 }
 export function createServer(config = loadConfig(), options = {}) {