@akira-tl/forgerelay 0.3.4 → 0.3.6

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;
     }
@@ -164,6 +164,36 @@ const workspaceLocalAgentProviderOutputSchema = z.object({
 const workspaceAvailableAgentsFileOutputSchema = z.object({
     path: z.string(),
 });
+const workspaceInventoryEntryOutputSchema = z.object({
+    label: z.string(),
+    workspaceId: z.string(),
+    root: z.string(),
+    status: z.string(),
+    state: z.enum(["active", "stale", "invalid", "closed"]),
+    mode: z.enum(["checkout", "worktree"]),
+    sourceRoot: z.string().optional(),
+    branch: z.string().optional(),
+    targetBranch: z.string().optional(),
+    managed: z.boolean(),
+    createdAt: z.string(),
+    lastUsedAt: z.string(),
+    idleMs: z.number().nonnegative(),
+    rootValid: z.boolean(),
+    current: z.boolean(),
+});
+const workspaceInventorySummaryOutputSchema = z.object({
+    total: z.number().int().nonnegative(),
+    matching: z.number().int().nonnegative(),
+    active: z.number().int().nonnegative(),
+    stale: z.number().int().nonnegative(),
+    invalid: z.number().int().nonnegative(),
+    closed: z.number().int().nonnegative(),
+});
+const workspaceInventoryPageOutputSchema = z.object({
+    offset: z.number().int().nonnegative(),
+    limit: z.number().int().positive(),
+    hasMore: z.boolean(),
+});
 const reviewFileOutputSchema = z.object({
     path: z.string(),
     previousPath: z.string().optional(),
@@ -711,7 +741,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 },
@@ -776,20 +805,24 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     }, async (uri, _variables, extra) => readWorkspaceAppResource(config, uri.toString(), extra.sessionId));
     registerAppTool(server, "open_workspace", {
         title: "Open workspace",
-        description: "Open or resume a local coding workspace. Reuse the returned workspaceId for later calls. Default to checkout; use mode=\"worktree\" only when the user explicitly requests isolated or parallel Git work. Every call returns a capability fingerprint; bootstrap calls also expose project context, skills, and capability guides when needed.",
+        description: "Open or resume a local coding workspace. Reuse the returned workspaceId for later calls. Default to checkout; use mode=\"worktree\" only when the user explicitly requests isolated or parallel Git work. Every call returns lightweight workspace metadata; bootstrap context is delivered automatically only when needed and can be explicitly suppressed or refreshed.",
         inputSchema: {
+            action: z
+                .enum(["open", "list"])
+                .optional()
+                .describe("Defaults to open. Use list only when you need to inspect or choose logical workspaces before resuming or cleaning them up."),
             path: z
                 .string()
                 .optional()
-                .describe("Project path to open. Required unless workspaceId is supplied. With mode=\"worktree\", this may also be a managed worktree path previously returned by ForgeRelay."),
+                .describe("Project path to open. Required for action=open unless workspaceId is supplied. With mode=\"worktree\", this may also be a managed worktree path previously returned by ForgeRelay."),
             workspaceId: z
                 .string()
                 .optional()
-                .describe("Existing logical workspace ID to resume in this conversation. When supplied, ForgeRelay resumes that workspace rather than allocating another ID."),
+                .describe("For action=open, an existing logical workspace ID to resume in this conversation. For action=list, filters inventory to one workspace ID."),
             mode: z
                 .enum(["checkout", "worktree"])
                 .optional()
-                .describe("Defaults to checkout, which works in the actual directory. Use worktree only when the user explicitly requests isolated or parallel Git work."),
+                .describe("For action=open, defaults to checkout and uses the actual directory unless worktree isolation is explicitly requested. For action=list, filters by workspace mode."),
             baseRef: z
                 .string()
                 .optional()
@@ -802,11 +835,45 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 .boolean()
                 .optional()
                 .describe("When true, allocate a fresh logical workspaceId for the same physical checkout or worktree and bind this conversation to it. Use only after the user explicitly requests a new logical workspace."),
+            context: z
+                .enum(["auto", "full", "none"])
+                .optional()
+                .describe("Bootstrap context policy for action=open. auto (default) sends full project context only when this conversation has not received the current context fingerprint; full forces a refresh; none opens/resumes without returning the full bootstrap context."),
+            root: z
+                .string()
+                .optional()
+                .describe("For action=list, filter by canonical workspace root or source root."),
+            status: z
+                .string()
+                .optional()
+                .describe("For action=list, filter by persisted workspace status such as active or closed."),
+            state: z
+                .enum(["active", "stale", "invalid", "closed"])
+                .optional()
+                .describe("For action=list, filter by derived lifecycle state."),
+            staleOnly: z
+                .boolean()
+                .optional()
+                .describe("For action=list, return only active logical workspaces idle for more than two days."),
+            offset: z
+                .number()
+                .int()
+                .nonnegative()
+                .optional()
+                .describe("For action=list, zero-based inventory offset. Defaults to 0."),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("For action=list, maximum records to return. Defaults to 50; maximum 100."),
         },
         outputSchema: {
-            workspaceId: z.string(),
-            root: z.string(),
-            mode: z.enum(["checkout", "worktree"]),
+            action: z.enum(["open", "list"]),
+            workspaceId: z.string().optional(),
+            root: z.string().optional(),
+            mode: z.enum(["checkout", "worktree"]).optional(),
             sourceRoot: z.string().optional(),
             worktree: z
                 .object({
@@ -829,7 +896,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 targetBranch: z.string().optional(),
                 managed: z.boolean(),
                 current: z.boolean(),
-            })),
+            })).optional(),
             staleWorkspaces: z.array(z.object({
                 workspaceId: z.string(),
                 root: z.string(),
@@ -839,9 +906,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 branch: z.string().optional(),
                 targetBranch: z.string().optional(),
                 managed: z.boolean(),
-            })),
-            capabilityFingerprint: capabilityFingerprintOutputSchema,
-            capabilityCatalog: z.array(capabilityCatalogOutputSchema),
+            })).optional(),
+            capabilityFingerprint: capabilityFingerprintOutputSchema.optional(),
+            contextFingerprint: z.string().optional(),
+            capabilityCatalog: z.array(capabilityCatalogOutputSchema).optional(),
             capabilityGuides: z.array(capabilityGuideOutputSchema).optional(),
             agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
             availableAgentsFiles: z.array(workspaceAvailableAgentsFileOutputSchema).optional(),
@@ -849,6 +917,9 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             agentProviders: z.array(workspaceLocalAgentProviderOutputSchema).optional(),
             agents: z.array(workspaceLocalAgentOutputSchema).optional(),
             skillDiagnostics: z.array(z.unknown()).optional(),
+            workspaces: z.array(workspaceInventoryEntryOutputSchema).optional(),
+            summary: workspaceInventorySummaryOutputSchema.optional(),
+            page: workspaceInventoryPageOutputSchema.optional(),
             instruction: z.string(),
         },
         ...toolWidgetDescriptorMeta(config, "workspace"),
@@ -858,11 +929,62 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             idempotentHint: false,
             openWorldHint: false,
         },
-    }, async ({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace }, { _meta, sessionId }) => {
+    }, async ({ action = "open", path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context, root, status, state, staleOnly, offset, limit, }, { _meta, sessionId }) => {
         const startedAt = performance.now();
-        const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace }, {
-            conversationScopeId: openAiConversationScopeId(_meta),
-            protectedWorkspaceIds: processSessions.activeWorkspaceIds(),
+        const conversationScopeId = openAiConversationScopeId(_meta);
+        const protectedWorkspaceIds = processSessions.activeWorkspaceIds();
+        if (action === "list") {
+            if (path !== undefined || baseRef !== undefined || newWorktree !== undefined ||
+                newWorkspace !== undefined || context !== undefined) {
+                throw new Error("open_workspace action=list does not accept path, baseRef, newWorktree, newWorkspace, or context. Use root/workspaceId/mode/status/state/staleOnly for inventory filters.");
+            }
+            const inventory = await workspaces.listWorkspaces({ workspaceId, mode, root, status, state, staleOnly, offset, limit }, { conversationScopeId, protectedWorkspaceIds });
+            const nextOffset = inventory.page.offset + inventory.page.limit;
+            const instruction = [
+                "Resume a selected workspaceId with open_workspace(action=\"open\", workspaceId=...).",
+                "Use close_workspace only after the user chooses cleanup; never close inventory entries automatically.",
+                inventory.page.hasMore
+                    ? `More matching workspaces are available; continue with offset=${nextOffset}.`
+                    : undefined,
+            ].filter(Boolean).join(" ");
+            const result = [
+                `Logical workspace inventory: ${inventory.summary.matching} matching of ${inventory.summary.total} stored records.`,
+                `States: active=${inventory.summary.active}, stale=${inventory.summary.stale}, invalid=${inventory.summary.invalid}, closed=${inventory.summary.closed}.`,
+                ...inventory.workspaces.map((entry) => [
+                    entry.label,
+                    `state=${entry.state}`,
+                    `status=${entry.status}`,
+                    `mode=${entry.mode}`,
+                    entry.managed ? "managed" : undefined,
+                    entry.current ? "current" : undefined,
+                    `root=${entry.root}`,
+                    `last-used=${entry.lastUsedAt}`,
+                ].filter(Boolean).join(" ")),
+                instruction,
+            ].join("\n");
+            logToolCall(config, {
+                tool: "open_workspace",
+                action: "list",
+                path: root,
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                content: [textBlock(result)],
+                structuredContent: {
+                    action: "list",
+                    ...inventory,
+                    instruction,
+                },
+            };
+        }
+        if (root !== undefined || status !== undefined || state !== undefined ||
+            staleOnly !== undefined || offset !== undefined || limit !== undefined) {
+            throw new Error("open_workspace inventory filters root, status, state, staleOnly, offset, and limit are only valid with action=list.");
+        }
+        const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, contextFingerprint, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context }, {
+            conversationScopeId,
+            protectedWorkspaceIds,
         });
         const knownWorktrees = await workspaces.listKnownWorktrees(workspace);
         const staleWorkspaces = await workspaces.listStaleWorkspaces(workspace);
@@ -912,20 +1034,26 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         const visibleAgents = includeBootstrapContext ? cardAgents : [];
         const loadedAgentsFiles = includeBootstrapContext ? cardAgentsFiles : [];
         const availableAgentsFileOutputs = includeBootstrapContext ? cardAvailableAgentsFiles : [];
+        const workspaceContextInstruction = "For later open_workspace calls, context=\"auto\" avoids repeating unchanged bootstrap context; use context=\"none\" when only the workspace handle/metadata is needed, or context=\"full\" to force a refresh.";
+        const workspaceManagementInstruction = "When you need to continue an earlier logical workspace or organize workspace state, use open_workspace(action=\"list\") to inspect candidates, then resume a selected workspaceId or ask the user before close_workspace cleanup.";
         const cardInstruction = config.skillsEnabled
-            ? "Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches an available skill or capability guide, read its advertised path before proceeding."
-            : "Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches a capability guide, read its advertised path before proceeding.";
+            ? `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches an available skill or capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`
+            : `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches a capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`;
         const instruction = workspaceReused
             ? includeBootstrapContext
                 ? [
                     `Workspace already exists as ${workspace.id} for this directory.`,
                     "Reuse this workspaceId for subsequent tool calls.",
                     "The complete project context is included because it has not yet been provided in this conversation or host context.",
+                    workspaceContextInstruction,
+                    workspaceManagementInstruction,
                 ].join("\n\n")
                 : [
                     `Workspace already open as ${workspace.id}.`,
                     "Reuse this workspaceId for subsequent tool calls. This is the same directory previously opened in this conversation.",
                     "Continue following the project instructions, nested instruction files, skills, capability guides, agent profiles, and diagnostics previously provided for this workspace. They remain active and are not repeated here.",
+                    workspaceContextInstruction,
+                    workspaceManagementInstruction,
                 ].join("\n\n")
             : workspace.mode === "worktree"
                 ? "Use this workspaceId for subsequent tool calls. Follow the project instructions, nested instruction files, skills, agent profiles, and diagnostics returned for this isolated worktree."
@@ -999,6 +1127,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     worktrees: knownWorktrees,
                     staleWorkspaces,
                     capabilityFingerprint,
+                    contextFingerprint,
                     capabilityCatalog,
                     agentsFiles: cardAgentsFiles,
                     availableAgentsFiles: cardAvailableAgentsFiles,
@@ -1018,6 +1147,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 },
             },
             structuredContent: {
+                action: "open",
                 workspaceId: workspace.id,
                 root: workspace.root,
                 mode: workspace.mode,
@@ -1026,6 +1156,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 worktrees: knownWorktrees,
                 staleWorkspaces,
                 capabilityFingerprint,
+                contextFingerprint,
                 capabilityCatalog,
                 ...(includeBootstrapContext
                     ? {
@@ -1120,9 +1251,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 ?? {},
@@ -1716,255 +1848,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",
@@ -2146,15 +2029,6 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         });
     }
     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 = {}) {