@j0hanz/filesystem-mcp 1.17.0 → 1.18.0

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

@@ -1,10 +1,10 @@
-import { readFile, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import { basename, resolve } from 'node:path';
 import { applyPatch, parsePatch } from 'diff';
 import { withAbort } from '../lib/abort.js';
 import { MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { atomicWriteFile, processInParallel } from '../lib/fs-helpers.js';
+import { atomicWriteFile, processInParallel, readFileWithStats, } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
@@ -62,7 +62,12 @@ async function applyDiff(filePath, diff, options, signal) {
     assertAllowedFileAccess(filePath, validPath);
     const stats = await withAbort(stat(validPath), signal);
     assertPatchTargetSizeWithinLimit(validPath, stats.size, MAX_TEXT_FILE_SIZE);
-    const content = await readFile(validPath, { encoding: 'utf-8', signal });
+    const { content } = await readFileWithStats(filePath, validPath, stats, {
+        encoding: 'utf-8',
+        maxSize: MAX_TEXT_FILE_SIZE,
+        skipBinary: true,
+        ...(signal ? { signal } : {}),
+    });
     const patched = applyPatch(content, diff, {
         fuzzFactor: options.fuzzFactor,
         autoConvertLineEndings: options.autoConvertLineEndings,
@@ -208,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

@@ -1,11 +1,11 @@
-import { readFile, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { createTwoFilesPatch, diffLines } from 'diff';
 import RE2 from 're2';
 import { withAbort } from '../lib/abort.js';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { atomicWriteFile } from '../lib/fs-helpers.js';
+import { atomicWriteFile, readFileWithStats } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
@@ -167,28 +167,33 @@ async function loadEditableFile(requestedPath, signal) {
     if (stats.size > MAX_TEXT_FILE_SIZE) {
         throw new McpError(ErrorCode.TOO_LARGE, `File too large for edit (${stats.size} bytes > ${MAX_TEXT_FILE_SIZE} bytes)`, requestedPath, { size: stats.size, maxFileSize: MAX_TEXT_FILE_SIZE });
     }
-    const content = await readFile(validPath, { encoding: 'utf-8', signal });
+    const { content } = await readFileWithStats(requestedPath, validPath, stats, {
+        encoding: 'utf-8',
+        maxSize: MAX_TEXT_FILE_SIZE,
+        skipBinary: true,
+        ...(signal ? { signal } : {}),
+    });
     return { validPath, content };
 }
 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}`;
         },
     });
 }

package/dist/tools/read-multiple.js

@@ -1,13 +1,12 @@
 import { basename } from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
-import { ErrorCode } from '../lib/errors.js';
+import { classifyError, ErrorCode } from '../lib/errors.js';
 import { readMultipleFiles } from '../lib/file-operations/metadata.js';
 import { ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, } from '../schemas.js';
 import { FILE_READ_ICONS } from './icons.js';
-import { buildBatchCompletionSuffix, buildBatchPathContext, buildResourceLink, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
+import { buildBatchPathContext, buildResourceLink, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
+import { registerStandardTool, reportTaskStatus } from './task-support.js';
 const READ_MANY_TOOL_NAME = 'read_many';
-const READ_MANY_TOOL_LABEL = '🕮 read_many';
 const FULL_FILE_CONTENTS_DESCRIPTION = 'Full file contents';
 export const READ_MANY_TOOL = {
     name: READ_MANY_TOOL_NAME,
@@ -20,6 +19,7 @@ export const READ_MANY_TOOL = {
     icons: FILE_READ_ICONS,
     taskSupport: 'optional',
 };
+const READ_MANY_TOOL_LABEL = READ_MANY_TOOL.title;
 function buildReadManyResourceName(filePath) {
     return `read:${basename(filePath)}`;
 }
@@ -173,23 +173,30 @@ export function registerReadMultipleFilesTool(server, options = {}) {
             context: { path: primaryPath },
             run: async (signal) => {
                 const context = buildBatchPathContext(args.paths, 'files');
-                const { progress, onItemComplete } = createBatchProgressCallbacks(ctx, {
+                const { progress, onItemComplete: rawOnItemComplete } = createBatchProgressCallbacks(ctx, {
                     toolLabel: READ_MANY_TOOL_LABEL,
                     context,
                     totalItems: args.paths.length,
                     itemVerb: 'read',
                 });
+                let itemsDone = 0;
+                const onItemComplete = () => {
+                    rawOnItemComplete();
+                    itemsDone++;
+                    void reportTaskStatus(`${READ_MANY_TOOL_LABEL}: ${context} [${itemsDone}/${args.paths.length} read]`);
+                };
                 try {
                     const result = await handleReadMultipleFiles(args, signal, options.resourceStore, onItemComplete);
                     const sc = result.structuredContent;
-                    const suffix = buildBatchCompletionSuffix(sc.summary, 'files read', 'file read');
                     const total = sc.summary?.total ?? 0;
+                    const failed = sc.summary?.failed ?? 0;
+                    const suffix = failed ? `${failed} failed` : 'done';
                     const finalCurrent = resolveFinalProgressCurrent(progress, total);
                     progress.complete(`${READ_MANY_TOOL_LABEL}: ${context} • ${suffix}`, finalCurrent);
                     return result;
                 }
                 catch (error) {
-                    progress.fail(`${READ_MANY_TOOL_LABEL}: ${context} • failed`);
+                    progress.fail(`${READ_MANY_TOOL_LABEL}: ${context} • ${classifyError(error)}`);
                     throw error;
                 }
             },

package/dist/tools/read.js

@@ -1,8 +1,7 @@
-import { createHash } from 'node:crypto';
 import { basename } from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS, MAX_TEXT_FILE_SIZE, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
-import { readFile } from '../lib/fs-helpers.js';
+import { calculateFileContentHash, readFile } from '../lib/fs-helpers.js';
 import { ReadFileInputSchema, ReadFileOutputSchema } from '../schemas.js';
 import { FILE_READ_ICONS } from './icons.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
@@ -23,7 +22,7 @@ export const READ_FILE_TOOL = {
     taskSupport: 'forbidden',
 };
 const READ_TOOL_NAME = 'read';
-const READ_TOOL_LABEL = '🕮 read';
+const READ_TOOL_LABEL = READ_FILE_TOOL.title;
 const FULL_FILE_CONTENTS_DESCRIPTION = 'Full file contents';
 function buildReadResourceName(filePath) {
     return `read:${basename(filePath)}`;
@@ -115,7 +114,7 @@ function buildReadProgressMessage(args) {
 function buildReadCompletionMessage(args, result) {
     const name = basename(args.path);
     if (result.isError)
-        return `${READ_TOOL_LABEL}: ${name} • failed`;
+        return `${READ_TOOL_LABEL}: ${name} • ${result.errorCode}`;
     const structured = result.structuredContent;
     const lines = structured.linesRead ?? structured.totalLines;
     if (structured.startLine !== undefined) {
@@ -144,9 +143,7 @@ async function handleReadFile(args, signal, resourceStore) {
     const result = await readFile(args.path, options);
     const structured = toStructuredReadFileResult(args, result);
     if (args.includeHash) {
-        structured.contentHash = createHash('sha256')
-            .update(result.content, 'utf-8')
-            .digest('hex');
+        structured.contentHash = await calculateFileContentHash(result.path, signal);
     }
     const externalizedResponse = maybeBuildExternalizedReadResponse(args.path, result.content, structured, resourceStore);
     if (externalizedResponse) {

package/dist/tools/replace-in-files.js

@@ -4,7 +4,7 @@ import { basename, relative } from 'node:path';
 import { createTwoFilesPatch } from 'diff';
 import RE2 from 're2';
 import { DEFAULT_EXCLUDE_PATTERNS, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../lib/constants.js';
-import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
+import { classifyError, ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
 import { globEntries } from '../lib/file-operations/traversal.js';
 import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
@@ -340,12 +340,12 @@ export function registerSearchAndReplaceTool(server, options = {}) {
             const dryLabel = args.dryRun ? ' [dry run]' : '';
             const truncatedPattern = truncateProgressPattern(args.searchPattern);
             const context = `"${truncatedPattern}" in ${args.filePattern}${dryLabel}`;
-            const progress = createToolProgressSession(ctx, `🛠 replace: ${context}`);
+            const progress = createToolProgressSession(ctx, `${SEARCH_AND_REPLACE_TOOL.title}: ${context}`);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🛠 replace: ${truncatedPattern} [${current} files]`,
+                    message: `${SEARCH_AND_REPLACE_TOOL.title}: ${truncatedPattern} [${current} files]`,
                 });
             };
             try {
@@ -357,14 +357,14 @@ export function registerSearchAndReplaceTool(server, options = {}) {
                 let endSuffix = `${sc.matches ?? 0} ${matchWord} in ${sc.filesChanged ?? 0} ${fileWord}`;
                 if (sc.failedFiles)
                     endSuffix += `, ${sc.failedFiles} failed`;
-                progress.complete(`🛠 replace: ${context} • ${endSuffix}`, finalCurrent);
+                progress.complete(`${SEARCH_AND_REPLACE_TOOL.title}: ${context} • ${endSuffix}`, finalCurrent);
                 if (!args.dryRun) {
                     void ctx.log?.('info', `search_and_replace: ${String(sc.matches ?? 0)} matches in ${String(sc.filesChanged ?? 0)} files`);
                 }
                 return result;
             }
             catch (error) {
-                progress.fail(`🛠 replace: ${context} • failed`);
+                progress.fail(`${SEARCH_AND_REPLACE_TOOL.title}: ${context} • ${classifyError(error)}`);
                 throw error;
             }
         },

package/dist/tools/roots.js

@@ -41,13 +41,13 @@ export function registerListAllowedDirectoriesTool(server, options = {}) {
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN),
     });
     registerStandardTool(server, LIST_ALLOWED_DIRECTORIES_TOOL, handler, options, {
-        progressMessage: () => '≣ roots',
+        progressMessage: () => LIST_ALLOWED_DIRECTORIES_TOOL.title,
         completionMessage: (_args, result) => {
             if (result.isError)
-                return `≣ roots • failed`;
+                return `${LIST_ALLOWED_DIRECTORIES_TOOL.title} • ${result.errorCode}`;
             const sc = result.structuredContent;
             const count = sc.directories?.length ?? 0;
-            return `≣ roots • ${count} ${count === 1 ? 'root' : 'roots'}`;
+            return `${LIST_ALLOWED_DIRECTORIES_TOOL.title} • ${count} ${count === 1 ? 'root' : 'roots'}`;
         },
     });
 }

package/dist/tools/search-content.js

@@ -1,13 +1,13 @@
 import { relative } from 'node:path';
 import RE2 from 're2';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
-import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
+import { classifyError, ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
 import { searchContent, } from '../lib/file-operations/search.js';
 import { formatOperationSummary } from '../config.js';
 import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
 import { SEARCH_ICONS } from './icons.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
+import { registerStandardTool, reportTaskStatus } from './task-support.js';
 /**
  * Configuration constants for the Search Content tool.
  */
@@ -268,7 +268,7 @@ export function registerSearchContentTool(server, options = {}) {
         context: { path: args.path ?? '.' },
         run: async (signal) => {
             const { pattern, filePattern: scope } = args;
-            const progressLabel = `🔎︎ grep: ${truncateProgressPattern(pattern)}`;
+            const progressLabel = `${SEARCH_CONTENT_TOOL.title}: ${truncateProgressPattern(pattern)}`;
             const progress = createToolProgressSession(ctx, progressLabel);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
@@ -276,6 +276,7 @@ export function registerSearchContentTool(server, options = {}) {
                     ...(total !== undefined ? { total } : {}),
                     message: `${progressLabel} [${current} files]`,
                 });
+                void reportTaskStatus(`${progressLabel} ${current} files`);
             };
             try {
                 const result = await handleSearchContent(args, signal, options.resourceStore, progressWithMessage);
@@ -287,7 +288,7 @@ export function registerSearchContentTool(server, options = {}) {
                 return result;
             }
             catch (error) {
-                progress.fail(`${progressLabel} • failed`);
+                progress.fail(`${progressLabel} • ${classifyError(error)}`);
                 throw error;
             }
         },

package/dist/tools/search-files.js

@@ -1,6 +1,6 @@
 import { basename, relative } from 'node:path';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../lib/constants.js';
-import { ErrorCode } from '../lib/errors.js';
+import { classifyError, ErrorCode } from '../lib/errors.js';
 import { searchFiles } from '../lib/file-operations/search.js';
 import { formatOperationSummary, joinLines } from '../config.js';
 import { SearchFilesInputSchema, SearchFilesOutputSchema } from '../schemas.js';
@@ -126,7 +126,7 @@ export function registerSearchFilesTool(server, options = {}) {
             let progressCursor = 0;
             notifyProgress(ctx, {
                 current: 0,
-                message: `🔎︎ find: ${truncatedPattern}`,
+                message: `${SEARCH_FILES_TOOL.title}: ${truncatedPattern}`,
             });
             const baseReporter = createProgressReporter(ctx);
             const progressWithMessage = ({ current, total, }) => {
@@ -135,7 +135,7 @@ export function registerSearchFilesTool(server, options = {}) {
                 baseReporter({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ find: ${truncatedPattern} [${current} files]`,
+                    message: `${SEARCH_FILES_TOOL.title}: ${truncatedPattern} [${current} files]`,
                 });
             };
             try {
@@ -162,7 +162,7 @@ export function registerSearchFilesTool(server, options = {}) {
                 notifyProgress(ctx, {
                     current: finalCurrent,
                     total: finalCurrent,
-                    message: `🔎︎ find: ${context} • ${suffix}`,
+                    message: `${SEARCH_FILES_TOOL.title}: ${context} • ${suffix}`,
                 });
                 return result;
             }
@@ -171,7 +171,7 @@ export function registerSearchFilesTool(server, options = {}) {
                 notifyProgress(ctx, {
                     current: finalCurrent,
                     total: finalCurrent,
-                    message: `🔎︎ find: ${context} • failed`,
+                    message: `${SEARCH_FILES_TOOL.title}: ${context} • ${classifyError(error)}`,
                 });
                 throw error;
             }

package/dist/tools/shared.d.ts

@@ -1,4 +1,4 @@
-import type { ContentBlock, Icon, LoggingLevel, ProgressNotificationParams, ServerContext } from '@modelcontextprotocol/server';
+import type { ContentBlock, Icon, LoggingLevel, Notification, RequestMeta, ServerContext } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { ErrorCode } from '../lib/errors.js';
 import type { ResourceStore } from '../lib/resource-store.js';
@@ -56,25 +56,27 @@ export type ToolResponse<T> = ReturnType<typeof buildToolResponse<T>> & {
 interface ToolErrorResponse extends Record<string, unknown> {
     content: ContentBlock[];
     isError: true;
-    errorCode?: ErrorCode;
+    errorCode: ErrorCode;
 }
 export type ToolResult<T> = ToolResponse<T> | ToolErrorResponse;
 export declare function withValidatedArgs<Args, Result>(schema: z.ZodType<Args>, handler: (args: Args, ctx: ToolContext) => Promise<ToolResult<Result>>): (args: unknown, ctx: ToolContext | ServerContext) => Promise<ToolResult<Result>>;
-type ProgressToken = string | number;
+/**
+ * App-level tracing metadata passed through {@linkcode RequestMeta}.
+ * These fields are preserved by the SDK's loose `RequestMeta` type.
+ */
+interface TracingMeta {
+    traceparent?: string | undefined;
+    tracestate?: string | undefined;
+    baggage?: string | undefined;
+}
 export interface ToolContext {
     signal?: AbortSignal;
-    _meta?: {
-        progressToken?: ProgressToken | undefined;
-        traceparent?: string | undefined;
-        tracestate?: string | undefined;
-        baggage?: string | undefined;
-    } | undefined;
-    sendNotification?: (notification: {
-        method: 'notifications/progress';
-        params: ProgressNotificationParams;
-    }) => Promise<void>;
+    sessionId?: string;
+    _meta?: (RequestMeta & TracingMeta) | undefined;
+    sendNotification?: (notification: Notification) => Promise<void>;
     log?: (level: LoggingLevel, data: unknown, logger?: string) => Promise<void>;
 }
+export declare function toToolContext(ctx?: ToolContext | ServerContext): ToolContext;
 export interface IconInfo {
     src: string;
     mimeType: string;
@@ -168,8 +170,3 @@ export declare function encodeOffsetCursor(offset: number): string;
 export declare function decodeOffsetCursor(cursor: string): number;
 export declare function buildBatchPathContext(paths: readonly string[], unitLabel?: string): string;
 export declare function truncateProgressPattern(pattern: string, maxLength?: number): string;
-export declare function buildBatchCompletionSuffix(summary: {
-    total?: number;
-    failed?: number;
-    succeeded?: number;
-} | undefined, successWord: string, singularWord?: string): string;