@j0hanz/filesystem-mcp 1.17.1 → 1.19.0

package/dist/lib/constants.d.ts

@@ -7,7 +7,9 @@ export declare const MAX_CONCURRENT_TASKS: number;
 export declare const TASK_CANCEL_POLL_MS = 2000;
 export declare function getInitHandshakeTimeoutMs(): number;
 export declare const INIT_TIMEOUT_CLOSE: boolean;
-export declare const TASK_POLL_INTERVAL_MS = 100;
+export declare const TASK_POLL_INTERVAL_MS = 500;
+/** How long cancelled-task results are retained before lazy eviction. */
+export declare const CANCELLED_RESULT_TTL_MS: number;
 export declare const PARALLEL_CONCURRENCY: number;
 export declare const MAX_SEARCHABLE_FILE_SIZE: number;
 export declare const MAX_TEXT_FILE_SIZE: number;

package/dist/lib/constants.js

@@ -80,7 +80,9 @@ export function getInitHandshakeTimeoutMs() {
     return parseEnvInt('FS_INIT_HANDSHAKE_TIMEOUT_MS', 30_000, 1_000, 300_000);
 }
 export const INIT_TIMEOUT_CLOSE = parseTrueEnvFlag(process.env['FS_INIT_TIMEOUT_CLOSE']);
-export const TASK_POLL_INTERVAL_MS = 100;
+export const TASK_POLL_INTERVAL_MS = 500;
+/** How long cancelled-task results are retained before lazy eviction. */
+export const CANCELLED_RESULT_TTL_MS = 2 * 60 * 1_000; // 2 minutes
 // Auto-tuned parallelism based on CPU cores (no env override)
 const BYTES_PER_PARALLEL_TASK = 64 * MIB;
 const BYTES_PER_SEARCH_WORKER = 128 * MIB;

package/dist/lib/errors.d.ts

@@ -22,6 +22,7 @@ export declare class McpError extends Error {
     static accessDenied(message: string, path?: string, details?: Record<string, unknown>, cause?: unknown): McpError;
     static timeout(message: string, path?: string, details?: Record<string, unknown>, cause?: unknown): McpError;
 }
+export declare function classifyError(error: unknown): ErrorCode;
 export declare function createDetailedError(error: unknown, path?: string, additionalDetails?: Record<string, unknown>): DetailedError;
 export declare function formatDetailedError(error: DetailedError): string;
 export declare function getSuggestion(code: ErrorCode): string | undefined;

package/dist/lib/errors.js

@@ -236,7 +236,7 @@ function classifyMessageError(error) {
     }
     return undefined;
 }
-function classifyError(error) {
+export function classifyError(error) {
     let timeoutCode;
     let fallbackCode;
     const terminalCode = walkErrorChain(error, (candidate) => {

package/dist/prompts.js

@@ -57,6 +57,10 @@ export function registerGetHelpPrompt(server, instructions, iconInfo) {
                     content: {
                         type: 'text',
                         text,
+                        annotations: {
+                            audience: ['assistant'],
+                            priority: 1,
+                        },
                     },
                 },
             ],
@@ -81,6 +85,10 @@ export function registerCompareFilesPrompt(server, iconInfo) {
                 content: {
                     type: 'text',
                     text: `Compare files and explain differences.\n\n1. Call \`diff_files\` with:\n   - original: ${original}\n   - modified: ${modified}\n2. Summarize: additions, deletions, and semantic changes.\n3. Flag any potential issues (conflicts, regressions, breaking changes).`,
+                    annotations: {
+                        audience: ['assistant'],
+                        priority: 1,
+                    },
                 },
             },
         ],
@@ -103,6 +111,10 @@ export function registerAnalyzePathPrompt(server, iconInfo) {
                 content: {
                     type: 'text',
                     text: `Analyze the path: ${targetPath}\n\n1. Call \`stat\` to determine if it is a file or directory.\n2. If file: call \`read\` with \`includeHash: true\` and summarize contents.\n3. If directory: call \`tree\` (maxDepth: 3) and \`ls\` to summarize structure.\n4. Report: type, size, permissions, key observations.`,
+                    annotations: {
+                        audience: ['assistant'],
+                        priority: 1,
+                    },
                 },
             },
         ],
@@ -138,6 +150,10 @@ export function registerGetToolHelpPrompt(server, iconInfo) {
                         type: 'text',
                         text: `Use the embedded contract for \`${toolName}\` as the authoritative reference. ` +
                             'Summarize when to use it, its key constraints, and the safest next action.',
+                        annotations: {
+                            audience: ['assistant'],
+                            priority: 1,
+                        },
                     },
                 },
                 {
@@ -149,6 +165,10 @@ export function registerGetToolHelpPrompt(server, iconInfo) {
                             mimeType: 'text/markdown',
                             text: toolInfo,
                         },
+                        annotations: {
+                            audience: ['assistant'],
+                            priority: 1,
+                        },
                     },
                 },
             ],

package/dist/resources.js

@@ -1,5 +1,4 @@
-import { ResourceTemplate, } from '@modelcontextprotocol/server';
-import { ErrorCode, McpError } from './lib/errors.js';
+import { ProtocolError, ProtocolErrorCode, ResourceTemplate, } from '@modelcontextprotocol/server';
 import { globalMetrics } from './lib/observability.js';
 import { buildToolCatalog } from './resources/tool-catalog.js';
 import { buildToolInfo, getToolContracts } from './resources/tool-info.js';
@@ -104,7 +103,7 @@ export function registerResultResources(server, store, iconInfo) {
     }, iconInfo), (uri, variables) => {
         const { id } = variables;
         if (typeof id !== 'string' || id.length === 0) {
-            throw new McpError(ErrorCode.NOT_FOUND, 'Cached result expired. Re-run the tool to regenerate.');
+            throw new ProtocolError(ProtocolErrorCode.ResourceNotFound, 'Cached result expired. Re-run the tool to regenerate.');
         }
         const entry = store.getText(uri.toString());
         return {
@@ -130,11 +129,11 @@ export function registerToolInfoResource(server, iconInfo) {
     }, iconInfo), (uri, variables) => {
         const { name } = variables;
         if (typeof name !== 'string' || name.length === 0) {
-            throw new McpError(ErrorCode.INVALID_INPUT, 'Tool name is required');
+            throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Tool name is required');
         }
         const content = buildToolInfo(name);
         if (content === undefined) {
-            throw new McpError(ErrorCode.INVALID_INPUT, `Tool not found: ${name}`);
+            throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool not found: ${name}`);
         }
         return {
             contents: [

package/dist/server/bootstrap.js

@@ -1,5 +1,5 @@
 import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
-import { InMemoryTaskMessageQueue, isInitializeRequest, LATEST_PROTOCOL_VERSION, localhostAllowedHostnames, McpServer, StdioServerTransport, SUPPORTED_PROTOCOL_VERSIONS, validateHostHeader, } from '@modelcontextprotocol/server';
+import { InMemoryTaskMessageQueue, isInitializeRequest, localhostAllowedHostnames, McpServer, ProtocolErrorCode, StdioServerTransport, validateHostHeader, } from '@modelcontextprotocol/server';
 import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
 import { channel } from 'node:diagnostics_channel';
 import { readFile } from 'node:fs/promises';
@@ -17,6 +17,7 @@ import { registerInstructionResource, registerMetricsResource, registerResultRes
 import { buildServerInstructions } from '../resources/generated-instructions.js';
 import { registerAllTools } from '../tools.js';
 import { withDefaultIcons } from '../tools/shared.js';
+import { InMemoryEventStore } from './event-store.js';
 import { RootsManager } from './roots-manager.js';
 import { createTaskStore } from './task-store.js';
 function buildServerCapabilities(options = {}) {
@@ -221,7 +222,7 @@ async function readRequestBody(req) {
         req.on('error', reject);
     });
 }
-async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
+async function createHttpSession(options, sessions, eventStore) {
     const mcpServer = await createServer(options);
     const rootsManager = getRootsManager(mcpServer);
     rootsManager.registerHandlers(mcpServer);
@@ -235,6 +236,7 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
         if (sessionId) {
             sessions.delete(sessionId);
             activeServers.delete(sessionId);
+            eventStore.delete(sessionId);
         }
         rootsManager.destroy();
     };
@@ -244,12 +246,12 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
     };
     const transport = new NodeStreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
+        eventStore,
         onsessioninitialized: (sessionId) => {
             sessions.set(sessionId, {
                 server: mcpServer,
                 rootsManager,
                 transport,
-                negotiatedProtocolVersion,
                 createdAt: Date.now(),
                 cleanup,
                 close,
@@ -267,7 +269,6 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
         server: mcpServer,
         rootsManager,
         transport,
-        negotiatedProtocolVersion,
         createdAt: Date.now(),
         cleanup,
         close,
@@ -285,9 +286,9 @@ const LOCALHOST_ORIGIN_RE = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?
 const MAX_SESSION_ID_LENGTH = 256;
 const MAX_BEARER_TOKEN_LENGTH = 4096;
 const JSON_RPC_SERVER_ERROR = -32000;
-const JSON_RPC_INVALID_REQUEST = -32600;
-const JSON_RPC_PARSE_ERROR = -32700;
-const JSON_RPC_INTERNAL_ERROR = -32603;
+const JSON_RPC_INVALID_REQUEST = ProtocolErrorCode.InvalidRequest;
+const JSON_RPC_PARSE_ERROR = ProtocolErrorCode.ParseError;
+const JSON_RPC_INTERNAL_ERROR = ProtocolErrorCode.InternalError;
 function isAllowedOrigin(origin) {
     if (origin === undefined)
         return true; // Non-browser clients omit Origin.
@@ -318,29 +319,6 @@ function getSessionId(req) {
         ? rawSessionId
         : undefined;
 }
-function getProtocolVersionHeader(req) {
-    const rawProtocolVersion = req.headers['mcp-protocol-version'];
-    return typeof rawProtocolVersion === 'string'
-        ? rawProtocolVersion
-        : undefined;
-}
-function resolveNegotiatedProtocolVersion(requestedVersion) {
-    return SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion)
-        ? requestedVersion
-        : LATEST_PROTOCOL_VERSION;
-}
-function ensureSessionProtocolVersion(req, res, session) {
-    const protocolVersion = getProtocolVersionHeader(req);
-    if (!protocolVersion) {
-        sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: Missing MCP-Protocol-Version header');
-        return false;
-    }
-    if (protocolVersion !== session.negotiatedProtocolVersion) {
-        sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, `Bad Request: MCP-Protocol-Version must match negotiated version ${session.negotiatedProtocolVersion}`);
-        return false;
-    }
-    return true;
-}
 function isAuthorizedBearer(apiKey, authHeader) {
     const bearerPrefix = 'Bearer ';
     if (typeof authHeader !== 'string' || !authHeader.startsWith(bearerPrefix)) {
@@ -460,6 +438,7 @@ function handleHttpRequestError(error, res) {
 }
 export async function startHttpServer(port, options) {
     const sessions = new Map();
+    const eventStore = new InMemoryEventStore();
     const httpHost = process.env['FILESYSTEM_MCP_HTTP_HOST'] ?? '127.0.0.1';
     assertHttpBindingSecurity(httpHost);
     let closingSessions;
@@ -469,6 +448,7 @@ export async function startHttpServer(port, options) {
         closingSessions = (async () => {
             const activeSessions = [...sessions.values()];
             sessions.clear();
+            eventStore.clear();
             await Promise.allSettled(activeSessions.map((session) => session.close()));
         })();
         await closingSessions;
@@ -480,10 +460,6 @@ export async function startHttpServer(port, options) {
                 discardRequestBody(req);
                 return;
             }
-            if (!ensureSessionProtocolVersion(req, res, session)) {
-                discardRequestBody(req);
-                return;
-            }
             const body = await readRequestBody(req);
             await handleSessionTransportRequest(session, req, res, body);
             return;
@@ -495,7 +471,7 @@ export async function startHttpServer(port, options) {
                 sendJsonRpcError(res, 503, JSON_RPC_SERVER_ERROR, 'Too many sessions');
                 return;
             }
-            const session = await createHttpSession(options, sessions, resolveNegotiatedProtocolVersion(body.params.protocolVersion));
+            const session = await createHttpSession(options, sessions, eventStore);
             await handleSessionTransportRequest(session, req, res, body);
             return;
         }
@@ -510,8 +486,6 @@ export async function startHttpServer(port, options) {
         const session = getSessionOrRespondNotFound(sessions, sessionId, res);
         if (!session)
             return;
-        if (!ensureSessionProtocolVersion(req, res, session))
-            return;
         await handleSessionTransportRequest(session, req, res);
     }
     async function dispatchMcpMethod(method, req, res, sessionId) {

package/dist/server/event-store.d.ts

@@ -0,0 +1,18 @@
+import type { JSONRPCMessage } from '@modelcontextprotocol/server';
+export declare class InMemoryEventStore {
+    private streams;
+    private eventIdToStreamId;
+    storeEvent(streamId: string, message: JSONRPCMessage): Promise<string>;
+    getStreamIdForEventId(eventId: string): Promise<string | undefined>;
+    replayEventsAfter(lastEventId: string, callbacks: {
+        send: (eventId: string, message: JSONRPCMessage) => Promise<void>;
+    }): Promise<string>;
+    /**
+     * Cleans up all events for a given streamId.
+     */
+    delete(streamId: string): void;
+    /**
+     * Cleans up all streams.
+     */
+    clear(): void;
+}

package/dist/server/event-store.js

@@ -0,0 +1,71 @@
+import { randomUUID } from 'node:crypto';
+const MAX_EVENTS_PER_STREAM = 1000;
+export class InMemoryEventStore {
+    // Map of streamId -> StoredEvent[]
+    streams = new Map();
+    // Map of eventId -> streamId for fast lookup
+    eventIdToStreamId = new Map();
+    storeEvent(streamId, message) {
+        const eventId = randomUUID();
+        let stream = this.streams.get(streamId);
+        if (!stream) {
+            stream = [];
+            this.streams.set(streamId, stream);
+        }
+        // Add new event
+        stream.push({ id: eventId, message });
+        this.eventIdToStreamId.set(eventId, streamId);
+        // Enforce limits
+        if (stream.length > MAX_EVENTS_PER_STREAM) {
+            const removed = stream.shift();
+            if (removed) {
+                this.eventIdToStreamId.delete(removed.id);
+            }
+        }
+        return Promise.resolve(eventId);
+    }
+    getStreamIdForEventId(eventId) {
+        return Promise.resolve(this.eventIdToStreamId.get(eventId));
+    }
+    async replayEventsAfter(lastEventId, callbacks) {
+        const streamId = this.eventIdToStreamId.get(lastEventId);
+        if (!streamId) {
+            throw new Error(`Event ID ${lastEventId} not found or expired`);
+        }
+        const stream = this.streams.get(streamId);
+        if (!stream) {
+            throw new Error(`Stream ${streamId} not found`);
+        }
+        const eventIndex = stream.findIndex((e) => e.id === lastEventId);
+        if (eventIndex === -1) {
+            throw new Error(`Event ID ${lastEventId} not found in stream ${streamId}`);
+        }
+        // Replay all events after the found index
+        for (let i = eventIndex + 1; i < stream.length; i++) {
+            const event = stream[i];
+            if (event) {
+                await callbacks.send(event.id, event.message);
+            }
+        }
+        return streamId;
+    }
+    /**
+     * Cleans up all events for a given streamId.
+     */
+    delete(streamId) {
+        const stream = this.streams.get(streamId);
+        if (stream) {
+            for (const event of stream) {
+                this.eventIdToStreamId.delete(event.id);
+            }
+            this.streams.delete(streamId);
+        }
+    }
+    /**
+     * Cleans up all streams.
+     */
+    clear() {
+        this.streams.clear();
+        this.eventIdToStreamId.clear();
+    }
+}

package/dist/server/task-store.d.ts

@@ -1,6 +1,7 @@
 import { InMemoryTaskStore, type Result, type Task } from '@modelcontextprotocol/server';
 export declare class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
     private readonly cancelledResults;
+    private evictExpired;
     getTaskResult(taskId: string, sessionId?: string): Promise<Result>;
     storeTaskResult(taskId: string, status: 'completed' | 'failed', result: Result, sessionId?: string): Promise<void>;
     updateTaskStatus(taskId: string, status: Task['status'], statusMessage?: string, sessionId?: string): Promise<void>;

package/dist/server/task-store.js

@@ -1,4 +1,5 @@
 import { InMemoryTaskStore, } from '@modelcontextprotocol/server';
+import { CANCELLED_RESULT_TTL_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 const DEFAULT_CANCELLED_STATUS_MESSAGE = 'Client cancelled task execution.';
 function getTaskKey(taskId, sessionId) {
@@ -18,7 +19,16 @@ function buildCancelledTaskResult(statusMessage) {
 }
 export class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
     cancelledResults = new Map();
+    evictExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cancelledResults) {
+            if (now - entry.createdAt > CANCELLED_RESULT_TTL_MS) {
+                this.cancelledResults.delete(key);
+            }
+        }
+    }
     async getTaskResult(taskId, sessionId) {
+        this.evictExpired();
         try {
             return await super.getTaskResult(taskId, sessionId);
         }
@@ -30,9 +40,9 @@ export class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
             const key = getTaskKey(taskId, sessionId);
             const existing = this.cancelledResults.get(key);
             if (existing)
-                return existing;
+                return existing.result;
             const result = buildCancelledTaskResult(task.statusMessage);
-            this.cancelledResults.set(key, result);
+            this.cancelledResults.set(key, { result, createdAt: Date.now() });
             return result;
         }
     }
@@ -48,15 +58,23 @@ export class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
             if (task?.status !== 'cancelled') {
                 throw error;
             }
-            this.cancelledResults.set(getTaskKey(taskId, sessionId), this.cancelledResults.get(getTaskKey(taskId, sessionId)) ?? result);
+            const key = getTaskKey(taskId, sessionId);
+            const existing = this.cancelledResults.get(key);
+            this.cancelledResults.set(key, {
+                result: existing?.result ?? result,
+                createdAt: existing?.createdAt ?? Date.now(),
+            });
         }
     }
     async updateTaskStatus(taskId, status, statusMessage, sessionId) {
         await super.updateTaskStatus(taskId, status, statusMessage, sessionId);
         const key = getTaskKey(taskId, sessionId);
         if (status === 'cancelled') {
-            this.cancelledResults.set(key, this.cancelledResults.get(key) ??
-                buildCancelledTaskResult(statusMessage));
+            const existing = this.cancelledResults.get(key);
+            this.cancelledResults.set(key, {
+                result: existing?.result ?? buildCancelledTaskResult(statusMessage),
+                createdAt: existing?.createdAt ?? Date.now(),
+            });
             return;
         }
         if (status === 'completed' || status === 'failed') {

package/dist/tools/apply-patch.js

@@ -213,21 +213,23 @@ export function registerApplyPatchTool(server, options = {}) {
     registerStandardTool(server, APPLY_PATCH_TOOL, handler, options, {
         progressMessage: (args) => {
             const name = basename(args.path);
-            return args.dryRun ? `🛠 patch: ${name} [dry run]` : `🛠 patch: ${name}`;
+            return args.dryRun
+                ? `${APPLY_PATCH_TOOL.title}: ${name} [dry run]`
+                : `${APPLY_PATCH_TOOL.title}: ${name}`;
         },
         completionMessage: (args, result) => {
             const name = basename(args.path);
             if (result.isError)
-                return `🛠 patch: ${name} • failed`;
+                return `${APPLY_PATCH_TOOL.title}: ${name} • ${result.errorCode}`;
             const sc = result.structuredContent;
             if (!sc.ok)
-                return `🛠 patch: ${name} • failed`;
+                return `${APPLY_PATCH_TOOL.title}: ${name} • failed`;
             const added = sc.linesAdded ?? 0;
             const removed = sc.linesRemoved ?? 0;
             const dry = args.dryRun ? 'dry run ' : '';
             if (added > 0 || removed > 0)
-                return `🛠 patch: ${name} • ${dry} +${added} -${removed}`;
-            return `🛠 patch: ${name} • ${dry}no changes`;
+                return `${APPLY_PATCH_TOOL.title}: ${name} • ${dry} +${added} -${removed}`;
+            return `${APPLY_PATCH_TOOL.title}: ${name} • ${dry}no changes`;
         },
     });
 }

package/dist/tools/calculate-hash.js

@@ -5,7 +5,7 @@ import { basename, relative, win32 } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { assertNotAborted, withAbort } from '../lib/abort.js';
 import { PARALLEL_CONCURRENCY } from '../lib/constants.js';
-import { ErrorCode } from '../lib/errors.js';
+import { classifyError, ErrorCode } from '../lib/errors.js';
 import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/core.js';
 import { globEntries } from '../lib/file-operations/traversal.js';
 import { validateExistingPath } from '../lib/paths.js';
@@ -153,12 +153,12 @@ export function registerCalculateHashTool(server, options = {}) {
         context: { path: args.path },
         run: async (signal) => {
             const baseName = basename(args.path);
-            const progress = createToolProgressSession(ctx, `🕮 hash: ${baseName}`);
+            const progress = createToolProgressSession(ctx, `${CALCULATE_HASH_TOOL.title}: ${baseName}`);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🕮 hash: ${baseName} [${current} files]`,
+                    message: `${CALCULATE_HASH_TOOL.title}: ${baseName} [${current} files]`,
                 });
             };
             try {
@@ -173,11 +173,11 @@ export function registerCalculateHashTool(server, options = {}) {
                 else {
                     suffix = `${(sc.hash ?? '').slice(0, 8)}…`;
                 }
-                progress.complete(`🕮 hash: ${baseName} • ${suffix}`, finalCurrent);
+                progress.complete(`${CALCULATE_HASH_TOOL.title}: ${baseName} • ${suffix}`, finalCurrent);
                 return result;
             }
             catch (error) {
-                progress.fail(`🕮 hash: ${baseName} • failed`);
+                progress.fail(`${CALCULATE_HASH_TOOL.title}: ${baseName} • ${classifyError(error)}`);
                 throw error;
             }
         },

package/dist/tools/create-directory.js

@@ -48,22 +48,21 @@ export function registerCreateDirectoryTool(server, options = {}) {
     registerStandardTool(server, CREATE_DIRECTORY_TOOL, handler, options, {
         progressMessage: (args) => {
             if (args.path && !args.paths?.length) {
-                return `🛠 mkdir: ${basename(args.path)}`;
+                return `${CREATE_DIRECTORY_TOOL.title}: ${basename(args.path)}`;
             }
             const count = (args.path ? 1 : 0) + (args.paths?.length ?? 0);
-            return `🛠 mkdir: ${count} directories`;
+            return `${CREATE_DIRECTORY_TOOL.title}: ${count} directories`;
         },
         completionMessage: (args, result) => {
             if (args.path && !args.paths?.length) {
                 const name = basename(args.path);
                 if (result.isError)
-                    return `🛠 mkdir: ${name} • failed`;
-                return `🛠 mkdir: ${name}`;
+                    return `${CREATE_DIRECTORY_TOOL.title}: ${name} • ${result.errorCode}`;
             }
             const count = (args.path ? 1 : 0) + (args.paths?.length ?? 0);
             if (result.isError)
-                return `🛠 mkdir: ${count} directories • failed`;
-            return `🛠 mkdir: ${count} directories`;
+                return `${CREATE_DIRECTORY_TOOL.title}: ${count} directories • ${result.errorCode}`;
+            return `${CREATE_DIRECTORY_TOOL.title}: ${count} directories`;
         },
     });
 }

package/dist/tools/delete-file.js

@@ -90,12 +90,12 @@ export function registerDeleteFileTool(server, options = {}) {
         },
     });
     registerStandardTool(server, DELETE_FILE_TOOL, handler, options, {
-        progressMessage: (args) => `🛠 rm: ${basename(args.path)}`,
+        progressMessage: (args) => `${DELETE_FILE_TOOL.title}: ${basename(args.path)}`,
         completionMessage: (args, result) => {
             const name = basename(args.path);
             if (result.isError)
-                return `🛠 rm: ${name} • failed`;
-            return `🛠 rm: ${name}`;
+                return `${DELETE_FILE_TOOL.title}: ${name} • ${result.errorCode}`;
+            return `${DELETE_FILE_TOOL.title}: ${name}`;
         },
     });
 }

package/dist/tools/diff-files.js

@@ -116,21 +116,21 @@ export function registerDiffFilesTool(server, options = {}) {
         progressMessage: (args) => {
             const n1 = basename(args.original);
             const n2 = basename(args.modified);
-            return `🕮 diff: ${n1} ⟷ ${n2}`;
+            return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2}`;
         },
         completionMessage: (args, result) => {
             const n1 = basename(args.original);
             const n2 = basename(args.modified);
             if (result.isError)
-                return `🕮 diff: ${n1} ⟷ ${n2} • failed`;
+                return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2} • ${result.errorCode}`;
             const sc = result.structuredContent;
             if (sc.isIdentical)
-                return `🕮 diff: ${n1} ⟷ ${n2} • identical`;
+                return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2} • identical`;
             const added = sc.linesAdded ?? 0;
             const removed = sc.linesRemoved ?? 0;
             if (added > 0 || removed > 0)
-                return `🕮 diff: ${n1} ⟷ ${n2} • +${added} -${removed}`;
-            return `🕮 diff: ${n1} ⟷ ${n2}`;
+                return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2} • +${added} -${removed}`;
+            return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2}`;
         },
     });
 }

package/dist/tools/edit-file.js

@@ -178,22 +178,22 @@ async function loadEditableFile(requestedPath, signal) {
 function buildEditProgressMessage(args) {
     const name = basename(args.path);
     const tag = args.dryRun ? ' [dry run]' : '';
-    return `🛠 edit: ${name}${tag}`;
+    return `${EDIT_FILE_TOOL.title}: ${name}${tag}`;
 }
 function buildEditCompletionMessage(args, result) {
     const name = basename(args.path);
     if (result.isError)
-        return `🛠 edit: ${name} • failed`;
+        return `${EDIT_FILE_TOOL.title}: ${name} • ${result.errorCode}`;
     const { structuredContent } = result;
     if (!structuredContent.ok)
-        return `🛠 edit: ${name} • failed`;
+        return `${EDIT_FILE_TOOL.title}: ${name} • failed`;
     const applied = structuredContent.appliedEdits ?? 0;
     if (applied === 0)
-        return `🛠 edit: ${name} • no changes`;
+        return `${EDIT_FILE_TOOL.title}: ${name} • no changes`;
     const added = structuredContent.linesAdded ?? 0;
     const removed = structuredContent.linesRemoved ?? 0;
     const dry = args.dryRun ? 'dry run ' : '';
-    return `🛠 edit: ${name} • ${dry} +${added} -${removed}`;
+    return `${EDIT_FILE_TOOL.title}: ${name} • ${dry} +${added} -${removed}`;
 }
 async function applyEdits(content, edits, ignoreWhitespace) {
     let newContent = content;

package/dist/tools/list-directory.js

@@ -205,14 +205,14 @@ export function registerListDirectoryTool(server, options = {}) {
         onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_DIRECTORY, args.path ?? '.'),
     });
     registerStandardTool(server, LIST_DIRECTORY_TOOL, handler, options, {
-        progressMessage: (args) => `≣ ls: ${args.path ? basename(args.path) : '.'}`,
+        progressMessage: (args) => `${LIST_DIRECTORY_TOOL.title}: ${args.path ? basename(args.path) : '.'}`,
         completionMessage: (args, result) => {
             const base = args.path ? basename(args.path) : '.';
             if (result.isError)
-                return `≣ ls: ${base} • failed`;
+                return `${LIST_DIRECTORY_TOOL.title}: ${base} • ${result.errorCode}`;
             const sc = result.structuredContent;
             const count = sc.totalEntries ?? 0;
-            return `≣ ls: ${base} • ${count} ${count === 1 ? 'entry' : 'entries'}`;
+            return `${LIST_DIRECTORY_TOOL.title}: ${base} • ${count} ${count === 1 ? 'entry' : 'entries'}`;
         },
     });
 }

package/dist/tools/move-file.js

@@ -157,23 +157,22 @@ export function registerMoveFileTool(server, options = {}) {
         progressMessage: (args) => {
             const dest = basename(args.destination);
             if (args.source && !args.sources?.length) {
-                return `🛠 mv: ${basename(args.source)} → ${dest}`;
+                return `${MOVE_FILE_TOOL.title}: ${basename(args.source)} → ${dest}`;
             }
             const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
-            return `🛠 mv: ${count} items → ${dest}`;
+            return `${MOVE_FILE_TOOL.title}: ${count} items → ${dest}`;
         },
         completionMessage: (args, result) => {
             const dest = basename(args.destination);
             if (args.source && !args.sources?.length) {
                 const src = basename(args.source);
                 if (result.isError)
-                    return `🛠 mv: ${src} → ${dest} • failed`;
-                return `🛠 mv: ${src} → ${dest}`;
+                    return `${MOVE_FILE_TOOL.title}: ${src} → ${dest} • ${result.errorCode}`;
             }
             const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
             if (result.isError)
-                return `🛠 mv: ${count} items → ${dest} • failed`;
-            return `🛠 mv: ${count} items → ${dest}`;
+                return `${MOVE_FILE_TOOL.title}: ${count} items → ${dest} • ${result.errorCode}`;
+            return `${MOVE_FILE_TOOL.title}: ${count} items → ${dest}`;
         },
     });
 }