@akira-tl/forgerelay 0.3.3 → 0.3.5

package/dist/server.js

@@ -17,7 +17,7 @@ import { applyPatch } from "./apply-patch.js";
 import { buildCapabilityFingerprint } from "./capabilities.js";
 import { CapabilityError, createCapabilityRegistry, } from "./capability-registry.js";
 import { deletePath, renamePath } from "./file-mutations.js";
-import { downloadIncomingArtifact, isArtifactDownloadSupportedPlatform, registerArtifactTools, } from "./artifact-tools.js";
+import { downloadIncomingArtifact, isArtifactDownloadSupportedPlatform, } from "./artifact-tools.js";
 import { ArtifactError } from "./artifact-error.js";
 import { loadConfig } from "./config.js";
 import { attachHookReports, HookRunner, runToolWithHooks } from "./hooks.js";
@@ -25,7 +25,7 @@ import { checkHookConfiguration } from "./hook-cli.js";
 import { buildServerInstructions, buildShellMutationPolicy, buildToolDescriptions, toolNames, } from "./mcp/server-instructions.js";
 import { createOpenAIIncomingArtifactAdapter, IncomingArtifactAdapterRegistry, } from "./incoming-artifacts.js";
 import { logEvent, requestIp, requestPath, commandPreview, transportSessionIdPrefix, workspaceLogLabel, } from "./logger.js";
-import { editFileTool, findFilesTool, grepFilesTool, listDirectoryTool, readFileTool, writeFileTool, } from "./pi-tools.js";
+import { editFileTool, readFileTool, writeFileTool, } from "./pi-tools.js";
 import { SingleUserOAuthProvider } from "./oauth-provider.js";
 import { McpTransportRegistry, } from "./mcp-sessions.js";
 import { ProcessManager, resolveProcessId, } from "./process-sessions.js";
@@ -67,7 +67,7 @@ function shouldAttachWidget(mode, kind) {
         case "off":
             return false;
         case "changes":
-            return kind === "workspace" || kind === "show_changes" || kind === "capability";
+            return kind === "workspace" || kind === "capability";
         case "full":
             return true;
     }
@@ -461,7 +461,7 @@ function attachCompletedProcessNotices(processSessions, workspaceId, result) {
 }
 function processOutputSchema() {
     return resultOutputSchema({
-        processId: z.number().int().positive().optional().describe("Canonical process handle for write_stdin."),
+        processId: z.number().int().positive().optional().describe("Canonical process handle for bash(action=\"process\") or the active command adapter."),
         sessionId: z.number().int().positive().optional().describe("Deprecated alias of processId for compatibility."),
         running: z.boolean(),
         exitCode: z.number().int().optional(),
@@ -613,6 +613,8 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
             });
         });
     }
+    if (config.toolMode !== "codex")
+        return;
     registerAppTool(server, "write_stdin", {
         title: "Write to process",
         description: "Poll or write characters to a running process returned by bash or exec_command. Omit chars or pass an empty string to poll. Waiting never kills the process; pass \\u0003 to explicitly send Ctrl-C.",
@@ -709,7 +711,6 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         files: review.files,
                     },
                     card: {
-                        tool: "show_changes",
                         summary: review.summary,
                         files: review.files,
                         payload: { patch: review.patch },
@@ -1118,9 +1119,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         ...(execution.card
                             ? {
                                 _meta: {
-                                    tool: execution.card.tool ?? toolNames.capability,
+                                    tool: toolNames.capability,
                                     card: {
                                         workspaceId,
+                                        capabilityName: name,
                                         summary: execution.card.summary ?? {},
                                         files: execution.card.files,
                                         payload: execution.card.payload ?? {},
@@ -1165,53 +1167,25 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         });
     });
     registerAppTool(server, toolNames.closeWorkspace, {
-        title: "Close logical workspace",
-        description: "Release one logical workspaceId after the user chooses cleanup. This does not delete checkout files. Use close_worktree to finalize and remove a managed worktree. Running or unconsumed processes prevent closure.",
-        inputSchema: {
-            workspaceId: z.string().describe("Logical workspace ID to release."),
-        },
-        outputSchema: resultOutputSchema({ workspaceId: z.string() }),
-        _meta: {},
-        annotations: WRITE_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId }) => {
-        const workspace = workspaces.getWorkspace(workspaceId);
-        return runToolWithHooks(hooks, {
-            tool: toolNames.closeWorkspace,
-            invocation: workspaceHookInvocation(workspace),
-            payload: { workspaceId },
-            operation: async () => {
-                if (processSessions.activeWorkspaceIds().has(workspaceId)) {
-                    throw new Error(`Workspace ${workspaceId} still owns a running process or an unconsumed process completion. Poll or consume it before closing this workspace.`);
-                }
-                workspaces.closeWorkspace(workspaceId);
-                const result = `Closed logical workspace ${workspaceId}. Physical project files were not removed.`;
-                return {
-                    content: [textBlock(result)],
-                    structuredContent: { result, workspaceId },
-                };
-            },
-        });
-    });
-    registerAppTool(server, toolNames.closeWorktree, {
-        title: "Close worktree",
-        description: "Finalize a managed worktree after its task is complete and verified. ForgeRelay may commit remaining changes, integrate the target branch when safe, and clean up the managed worktree. Read the managed-worktrees capability guide for advanced close, safety, and failure semantics.",
+        title: "Close workspace",
+        description: "Close one workspace after the user chooses cleanup. Checkout-backed workspaces release only the logical handle. Managed-worktree-backed workspaces finalize the existing safe worktree lifecycle, including hooks, commit/integration, and cleanup; provide commitMessage for that mode. Running or unconsumed processes prevent closure.",
         inputSchema: {
-            workspaceId: z
-                .string()
-                .describe("Managed worktree workspace identifier returned by open_workspace."),
+            workspaceId: z.string().describe("Workspace identifier to close."),
             commitMessage: z
                 .string()
                 .min(1)
-                .describe("Concise Git commit message describing the completed worktree changes."),
+                .optional()
+                .describe("Required only for a managed-worktree-backed workspace; concise Git commit message for remaining worktree changes."),
         },
         outputSchema: resultOutputSchema({
             workspaceId: z.string(),
-            sourceRoot: z.string(),
-            branch: z.string(),
-            targetBranch: z.string(),
-            commitSha: z.string(),
-            mergedSha: z.string(),
-            committed: z.boolean(),
+            mode: z.enum(["checkout", "worktree"]),
+            sourceRoot: z.string().optional(),
+            branch: z.string().optional(),
+            targetBranch: z.string().optional(),
+            commitSha: z.string().optional(),
+            mergedSha: z.string().optional(),
+            committed: z.boolean().optional(),
             cleanupWarning: z.string().optional(),
         }),
         _meta: {},
@@ -1219,49 +1193,70 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     }, async ({ workspaceId, commitMessage }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
         return runToolWithHooks(hooks, {
-            tool: toolNames.closeWorktree,
+            tool: toolNames.closeWorkspace,
             invocation: workspaceHookInvocation(workspace),
-            payload: { commitMessage },
-            afterCwd: (response) => response.structuredContent.sourceRoot,
+            payload: { workspaceId, commitMessage, mode: workspace.mode },
+            afterCwd: (response) => "sourceRoot" in response.structuredContent &&
+                typeof response.structuredContent.sourceRoot === "string"
+                ? response.structuredContent.sourceRoot
+                : undefined,
             operation: async () => {
-                const busyWorkspaceIds = workspaces
-                    .workspaceIdsForPhysicalWorkspace(workspace)
-                    .filter((id) => processSessions.activeWorkspaceIds().has(id));
-                if (busyWorkspaceIds.length > 0) {
-                    throw new Error(`Cannot close this worktree while logical workspace processes are still running or awaiting completion delivery: ${busyWorkspaceIds.join(", ")}.`);
+                if (workspace.mode === "worktree") {
+                    if (!commitMessage) {
+                        throw new Error(`Managed-worktree-backed workspace ${workspaceId} requires commitMessage when closing.`);
+                    }
+                    const busyWorkspaceIds = workspaces
+                        .workspaceIdsForPhysicalWorkspace(workspace)
+                        .filter((id) => processSessions.activeWorkspaceIds().has(id));
+                    if (busyWorkspaceIds.length > 0) {
+                        throw new Error(`Cannot close this worktree-backed workspace while logical workspace processes are still running or awaiting completion delivery: ${busyWorkspaceIds.join(", ")}.`);
+                    }
+                    const startedAt = performance.now();
+                    const closed = await workspaces.closeWorktree(workspaceId, commitMessage);
+                    const result = [
+                        `Closed managed-worktree-backed workspace ${workspaceId}.`,
+                        `Merged ${closed.branch} into ${closed.targetBranch} by fast-forward.`,
+                        `Source checkout: ${closed.sourceRoot}`,
+                        `Commit: ${closed.commitSha}`,
+                        closed.cleanupWarning
+                            ? `Cleanup warning: ${closed.cleanupWarning}`
+                            : "The managed worktree directory and branch were removed.",
+                    ].join("\n");
+                    logToolCall(config, {
+                        tool: toolNames.closeWorkspace,
+                        ...workspaceLogContext(workspace, extra.sessionId),
+                        path: closed.sourceRoot,
+                        success: true,
+                        durationMs: Math.round(performance.now() - startedAt),
+                    });
+                    return attachHookReports({
+                        content: [textBlock(result)],
+                        structuredContent: {
+                            result,
+                            workspaceId,
+                            mode: "worktree",
+                            sourceRoot: closed.sourceRoot,
+                            branch: closed.branch,
+                            targetBranch: closed.targetBranch,
+                            commitSha: closed.commitSha,
+                            mergedSha: closed.mergedSha,
+                            committed: closed.committed,
+                            cleanupWarning: closed.cleanupWarning,
+                        },
+                    }, closed.hookReports);
                 }
-                const startedAt = performance.now();
-                const closed = await workspaces.closeWorktree(workspaceId, commitMessage);
-                const result = [
-                    `Closed managed worktree ${workspaceId}.`,
-                    `Merged ${closed.branch} into ${closed.targetBranch} by fast-forward.`,
-                    `Source checkout: ${closed.sourceRoot}`,
-                    `Commit: ${closed.commitSha}`,
-                    closed.cleanupWarning
-                        ? `Cleanup warning: ${closed.cleanupWarning}`
-                        : "The worktree directory and managed branch were removed.",
-                ].join("\n");
-                logToolCall(config, {
-                    tool: toolNames.closeWorktree,
-                    ...workspaceLogContext(workspace, extra.sessionId),
-                    path: closed.sourceRoot,
-                    success: true,
-                    durationMs: Math.round(performance.now() - startedAt),
-                });
-                return attachHookReports({
-                    content: [{ type: "text", text: result }],
-                    structuredContent: {
-                        result,
-                        workspaceId,
-                        sourceRoot: closed.sourceRoot,
-                        branch: closed.branch,
-                        targetBranch: closed.targetBranch,
-                        commitSha: closed.commitSha,
-                        mergedSha: closed.mergedSha,
-                        committed: closed.committed,
-                        cleanupWarning: closed.cleanupWarning,
-                    },
-                }, closed.hookReports);
+                if (commitMessage !== undefined) {
+                    throw new Error("close_workspace commitMessage is only valid for managed-worktree-backed workspaces.");
+                }
+                if (processSessions.activeWorkspaceIds().has(workspaceId)) {
+                    throw new Error(`Workspace ${workspaceId} still owns a running process or an unconsumed process completion. Poll or consume it before closing this workspace.`);
+                }
+                workspaces.closeWorkspace(workspaceId);
+                const result = `Closed checkout-backed workspace ${workspaceId}. Physical project files were not removed.`;
+                return {
+                    content: [textBlock(result)],
+                    structuredContent: { result, workspaceId, mode: "checkout" },
+                };
             },
         });
     });
@@ -1721,255 +1716,6 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             });
         });
     }
-    if (config.widgets === "changes") {
-        registerAppTool(server, "show_changes", {
-            title: "Show changes",
-            description: "Show the changes made in this turn for an open workspace. Call this once after the final related file change and before your final response so the user can review the combined diff. Do not call it after each individual file change.",
-            inputSchema: {
-                workspaceId: z
-                    .string()
-                    .describe("Workspace identifier returned by open_workspace."),
-            },
-            outputSchema: resultOutputSchema(),
-            ...toolWidgetDescriptorMeta(config, "show_changes"),
-            annotations: { readOnlyHint: true },
-        }, async ({ workspaceId }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            return runToolWithHooks(hooks, {
-                tool: "show_changes",
-                invocation: workspaceHookInvocation(workspace),
-                operation: async () => {
-                    const startedAt = performance.now();
-                    const review = await reviewWorkspaceChanges(reviewCheckpoints, workspace);
-                    const content = [textBlock(review.result)];
-                    logToolCall(config, {
-                        tool: "show_changes",
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        content,
-                        _meta: {
-                            tool: "show_changes",
-                            card: {
-                                workspaceId,
-                                summary: review.summary,
-                                files: review.files,
-                                payload: {
-                                    patch: review.patch,
-                                },
-                            },
-                        },
-                        structuredContent: {
-                            result: contentText(content),
-                        },
-                    };
-                },
-            });
-        });
-    }
-    if (config.toolMode === "full") {
-        registerAppTool(server, toolNames.grep, {
-            title: "Grep",
-            description: "Search file contents inside an open workspace or the OS temp directory. Use this before broad reads when looking for symbols, text, or usage sites. Respects project ignore rules. Call open_workspace first and pass workspaceId.",
-            inputSchema: {
-                workspaceId: z
-                    .string()
-                    .describe("Workspace identifier returned by open_workspace."),
-                pattern: z.string().describe("Search pattern."),
-                path: z
-                    .string()
-                    .optional()
-                    .describe("Optional path or glob scope relative to the workspace root, or an absolute path inside the OS temp directory."),
-                include: z.string().optional().describe("Optional include glob."),
-            },
-            outputSchema: resultOutputSchema(),
-            ...toolWidgetDescriptorMeta(config, "search"),
-            annotations: { readOnlyHint: true },
-        }, async ({ workspaceId, ...input }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            return runToolWithHooks(hooks, {
-                tool: toolNames.grep,
-                invocation: workspaceHookInvocation(workspace),
-                payload: { pattern: input.pattern, path: input.path, include: input.include },
-                isFailure: toolResultIsError,
-                operation: async () => {
-                    const startedAt = performance.now();
-                    const response = await grepFilesTool(input, {
-                        cwd: workspace.root,
-                        root: workspace.root,
-                        fileRoots: workspaces.fileToolRoots(workspace),
-                    });
-                    if (response.isError) {
-                        logFailedToolResponse(config, {
-                            tool: toolNames.grep,
-                            ...workspaceLogContext(workspace, extra.sessionId),
-                            path: input.path,
-                        }, response.content, startedAt);
-                        return response;
-                    }
-                    const summary = {
-                        pattern: input.pattern,
-                        scope: input.path ?? ".",
-                        ...textSummary(response.content),
-                    };
-                    logToolCall(config, {
-                        tool: toolNames.grep,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: input.path,
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        ...response,
-                        _meta: {
-                            tool: toolNames.grep,
-                            card: {
-                                workspaceId,
-                                path: input.path,
-                                summary,
-                                payload: { content: response.content },
-                            },
-                        },
-                        structuredContent: {
-                            result: contentText(response.content),
-                        },
-                    };
-                },
-            });
-        });
-        registerAppTool(server, toolNames.glob, {
-            title: "Glob",
-            description: "Find files by glob pattern inside an open workspace or the OS temp directory. Use this to discover filenames or narrow file sets before reading. Respects project ignore rules. Call open_workspace first and pass workspaceId.",
-            inputSchema: {
-                workspaceId: z
-                    .string()
-                    .describe("Workspace identifier returned by open_workspace."),
-                pattern: z.string().describe("File glob pattern."),
-                path: z
-                    .string()
-                    .optional()
-                    .describe("Optional path scope relative to the workspace root, or an absolute path inside the OS temp directory."),
-            },
-            outputSchema: resultOutputSchema(),
-            ...toolWidgetDescriptorMeta(config, "search"),
-            annotations: { readOnlyHint: true },
-        }, async ({ workspaceId, ...input }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            return runToolWithHooks(hooks, {
-                tool: toolNames.glob,
-                invocation: workspaceHookInvocation(workspace),
-                payload: { pattern: input.pattern, path: input.path },
-                isFailure: toolResultIsError,
-                operation: async () => {
-                    const startedAt = performance.now();
-                    const response = await findFilesTool(input, {
-                        cwd: workspace.root,
-                        root: workspace.root,
-                        fileRoots: workspaces.fileToolRoots(workspace),
-                    });
-                    if (response.isError) {
-                        logFailedToolResponse(config, {
-                            tool: toolNames.glob,
-                            ...workspaceLogContext(workspace, extra.sessionId),
-                            path: input.path,
-                        }, response.content, startedAt);
-                        return response;
-                    }
-                    const summary = {
-                        pattern: input.pattern,
-                        scope: input.path ?? ".",
-                        ...textSummary(response.content),
-                    };
-                    logToolCall(config, {
-                        tool: toolNames.glob,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: input.path,
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        ...response,
-                        _meta: {
-                            tool: toolNames.glob,
-                            card: {
-                                workspaceId,
-                                path: input.path,
-                                summary,
-                                payload: { content: response.content },
-                            },
-                        },
-                        structuredContent: {
-                            result: contentText(response.content),
-                        },
-                    };
-                },
-            });
-        });
-        registerAppTool(server, toolNames.ls, {
-            title: "Ls",
-            description: "List a directory inside an open workspace or the OS temp directory. Use this for directory inspection before reading files. Call open_workspace first and pass workspaceId.",
-            inputSchema: {
-                workspaceId: z
-                    .string()
-                    .describe("Workspace identifier returned by open_workspace."),
-                path: z
-                    .string()
-                    .describe("Directory path to list, relative to the workspace root or absolute inside the OS temp directory."),
-            },
-            outputSchema: resultOutputSchema(),
-            ...toolWidgetDescriptorMeta(config, "directory"),
-            annotations: { readOnlyHint: true },
-        }, async ({ workspaceId, ...input }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            return runToolWithHooks(hooks, {
-                tool: toolNames.ls,
-                invocation: workspaceHookInvocation(workspace),
-                payload: { path: input.path },
-                isFailure: toolResultIsError,
-                operation: async () => {
-                    const startedAt = performance.now();
-                    const response = await listDirectoryTool(input, {
-                        cwd: workspace.root,
-                        root: workspace.root,
-                        fileRoots: workspaces.fileToolRoots(workspace),
-                    });
-                    if (response.isError) {
-                        logFailedToolResponse(config, {
-                            tool: toolNames.ls,
-                            ...workspaceLogContext(workspace, extra.sessionId),
-                            path: input.path,
-                        }, response.content, startedAt);
-                        return response;
-                    }
-                    const summary = textSummary(response.content);
-                    logToolCall(config, {
-                        tool: toolNames.ls,
-                        ...workspaceLogContext(workspace, extra.sessionId),
-                        path: input.path,
-                        success: true,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    });
-                    return {
-                        ...response,
-                        _meta: {
-                            tool: toolNames.ls,
-                            card: {
-                                workspaceId,
-                                path: input.path,
-                                summary,
-                                payload: { content: response.content },
-                            },
-                        },
-                        structuredContent: {
-                            result: contentText(response.content),
-                        },
-                    };
-                },
-            });
-        });
-    }
     if (config.toolMode !== "codex") {
         registerAppTool(server, toolNames.shell, {
             title: "Bash",
@@ -1978,73 +1724,179 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 workspaceId: z
                     .string()
                     .describe("Workspace identifier returned by open_workspace."),
+                action: z
+                    .enum(["run", "process"])
+                    .optional()
+                    .describe("Defaults to run. Use process with a returned processId to poll, interact, resize, or interrupt a running command."),
                 command: z
                     .string()
-                    .describe(toolDescriptions.shellCommand),
+                    .optional()
+                    .describe(`${toolDescriptions.shellCommand} Required for action=run.`),
+                processId: z
+                    .number()
+                    .int()
+                    .positive()
+                    .optional()
+                    .describe("Process identifier returned by a previous bash action=run call. Required for action=process."),
+                input: z
+                    .string()
+                    .optional()
+                    .describe("Characters to write for action=process. Omit to poll/wait without input."),
+                interrupt: z
+                    .boolean()
+                    .optional()
+                    .describe("For action=process, send SIGINT to the process. Cannot be combined with input."),
+                tty: z
+                    .boolean()
+                    .optional()
+                    .describe("For action=run, allocate a pseudo-terminal for interactive commands. Defaults to false."),
+                columns: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(1_000)
+                    .optional()
+                    .describe("Initial PTY width for action=run, or resize width for action=process."),
+                rows: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(1_000)
+                    .optional()
+                    .describe("Initial PTY height for action=run, or resize height for action=process."),
                 workingDirectory: z
                     .string()
                     .optional()
-                    .describe("Optional working directory relative to the workspace root. Defaults to the workspace root."),
+                    .describe("For action=run, working directory relative to the workspace root. Defaults to the workspace root."),
+                yieldTimeMs: z
+                    .number()
+                    .int()
+                    .min(0)
+                    .max(300_000)
+                    .optional()
+                    .describe("Milliseconds to wait before returning. Run preserves the existing 300000ms default; process polling defaults to 5000ms and interaction to 250ms."),
+                maxOutputTokens: z
+                    .number()
+                    .int()
+                    .positive()
+                    .max(100_000)
+                    .optional()
+                    .describe("Approximate output token budget. Defaults to 10000."),
             },
             outputSchema: processOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "shell"),
             annotations: SHELL_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, command, workingDirectory }, extra) => {
+        }, async ({ workspaceId, action = "run", command, processId, input, interrupt, tty, columns, rows, workingDirectory, yieldTimeMs, maxOutputTokens, }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
+            if (action === "run") {
+                if (!command)
+                    throw new Error("bash action=run requires command.");
+                if (processId !== undefined || input !== undefined || interrupt !== undefined) {
+                    throw new Error("bash action=run does not accept processId, input, or interrupt.");
+                }
+                return runToolWithHooks(hooks, {
+                    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);
+                        const snapshot = await processSessions.start({
+                            workspaceId,
+                            command,
+                            cwd,
+                            workspaceRoot: workspace.root,
+                            tty,
+                            columns,
+                            rows,
+                            yieldTimeMs: yieldTimeMs ?? 300_000,
+                            maxOutputTokens,
+                        });
+                        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;
+                    },
+                });
+            }
+            if (command !== undefined || workingDirectory !== undefined || tty !== undefined) {
+                throw new Error("bash action=process does not accept command, workingDirectory, or tty.");
+            }
+            if (processId === undefined)
+                throw new Error("bash action=process requires processId.");
+            if (interrupt && input !== undefined) {
+                throw new Error("bash action=process cannot combine interrupt with input.");
+            }
             return runToolWithHooks(hooks, {
                 tool: toolNames.shell,
                 invocation: workspaceHookInvocation(workspace),
                 payload: {
-                    command,
-                    workingDirectory: workingDirectory ?? ".",
+                    action,
+                    processId,
+                    inputLength: input?.length ?? 0,
+                    interrupt: interrupt ?? false,
+                    columns,
+                    rows,
                 },
                 isFailure: toolResultIsError,
                 operation: async () => {
                     const startedAt = performance.now();
-                    const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
-                    const snapshot = await processSessions.start({
+                    const snapshot = await processSessions.write({
                         workspaceId,
-                        command,
-                        cwd,
-                        workspaceRoot: workspace.root,
-                        yieldTimeMs: 300_000,
+                        processId,
+                        chars: interrupt ? "\u0003" : input,
+                        columns,
+                        rows,
+                        yieldTimeMs,
+                        maxOutputTokens,
                     });
                     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),
+                        success: snapshot.running || snapshot.exitCode === 0,
                         durationMs: Math.round(performance.now() - startedAt),
                     });
-                    const response = processToolResponse(toolNames.shell, workspaceId, snapshot, {
-                        command,
-                        workingDirectory: workingDirectory ?? ".",
+                    return processToolResponse(toolNames.shell, workspaceId, snapshot, {
+                        action,
+                        processId,
+                        inputLength: input?.length ?? 0,
+                        interrupt: interrupt ?? false,
                         running: snapshot.running,
                         exitCode: snapshot.exitCode,
                         wallTimeMs: snapshot.wallTimeMs,
                     });
-                    return !snapshot.running && (snapshot.signal || snapshot.exitCode !== 0)
-                        ? { ...response, isError: true }
-                        : response;
                 },
             });
         });
     }
     registerProcessTools(server, config, workspaces, processSessions, hooks);
-    if (config.artifactsEnabled && isArtifactDownloadSupportedPlatform()) {
-        registerArtifactTools(server, {
-            config,
-            workspaces,
-            hooks,
-            incomingArtifactAdapters,
-            incomingArtifactRegistry,
-        });
-    }
     return server;
 }
 export function createServer(config = loadConfig(), options = {}) {