@j0hanz/filesystem-mcp 1.11.0 → 1.12.0

package/dist/resources/tool-info.js

@@ -1,5 +1,16 @@
+import { z } from 'zod';
 import { DEFAULT_SEARCH_CONTENT_RESULTS, MAX_SEARCH_RESULTS, MAX_TEXT_FILE_SIZE, } from '../lib/constants.js';
 import { ALL_TOOLS } from '../tools.js';
+function getTaskSupportLabel(taskSupport) {
+    switch (taskSupport) {
+        case 'optional':
+            return '[Task: Optional]';
+        case 'required':
+            return '[Task: Required]';
+        default:
+            return undefined;
+    }
+}
 function toEntry(contract) {
     const annotations = [];
     if (contract.annotations?.destructiveHint)
@@ -8,11 +19,12 @@ function toEntry(contract) {
         annotations.push('[Idempotent]');
     if (contract.annotations?.readOnlyHint)
         annotations.push('[Read-Only]');
-    if (contract.taskSupport === 'optional' ||
-        contract.taskSupport === 'required')
-        annotations.push('[Task]');
+    const taskLabel = getTaskSupportLabel(contract.taskSupport);
+    if (taskLabel)
+        annotations.push(taskLabel);
     return {
         name: contract.name,
+        title: contract.title,
         description: contract.description,
         ...(annotations.length > 0 ? { annotations } : {}),
         ...(contract.nuances && contract.nuances.length > 0
@@ -43,6 +55,11 @@ export function getTaskCapableToolNames() {
         contract.taskSupport === 'required')
         .map((contract) => contract.name);
 }
+export function getTaskToolNamesBySupport(taskSupport) {
+    return getSortedToolContracts()
+        .filter((contract) => contract.taskSupport === taskSupport)
+        .map((contract) => contract.name);
+}
 export function buildCoreContextPack() {
     const rows = getSortedToolContracts().map((contract) => {
         const e = ENTRIES[contract.name];
@@ -61,25 +78,139 @@ export function getSharedConstraints() {
         'If response includes `resourceUri`, call `resources/read` immediately — cached results expire on restart.',
     ];
 }
+function formatTaskSupportLabel(taskSupport) {
+    switch (taskSupport) {
+        case 'optional':
+            return 'optional';
+        case 'required':
+            return 'required';
+        default:
+            return 'forbidden';
+    }
+}
+function formatAnnotationValue(value) {
+    return value ? 'true' : 'false';
+}
+function toJsonSchemaObject(schema, io = 'output') {
+    return z.toJSONSchema(schema, { io });
+}
+function summarizeSchemaType(schema) {
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return `enum(${schema.enum.map((value) => JSON.stringify(value)).join(', ')})`;
+    }
+    if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+        return schema.anyOf.map(summarizeSchemaType).join(' | ');
+    }
+    if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+        return schema.oneOf.map(summarizeSchemaType).join(' | ');
+    }
+    if (schema.type === 'array') {
+        const itemType = schema.items
+            ? summarizeSchemaType(schema.items)
+            : 'unknown';
+        return `array<${itemType}>`;
+    }
+    if (typeof schema.type === 'string' && schema.type.length > 0) {
+        return schema.type;
+    }
+    return 'unknown';
+}
+function buildSchemaFieldLines(label, schema) {
+    if (!schema) {
+        return [`<${label}>`, '- none', `</${label}>`];
+    }
+    const io = label === 'input_fields' ? 'input' : 'output';
+    const jsonSchema = toJsonSchemaObject(schema, io);
+    const properties = jsonSchema.properties ?? {};
+    const required = new Set(jsonSchema.required ?? []);
+    const fieldNames = Object.keys(properties);
+    const lines = [`<${label}>`];
+    if (typeof jsonSchema.description === 'string' &&
+        jsonSchema.description.length > 0) {
+        lines.push(`- Schema constraints: ${jsonSchema.description}`);
+    }
+    if (fieldNames.length === 0) {
+        lines.push('- object with no fields', `</${label}>`);
+        return lines;
+    }
+    lines.push(...fieldNames.map((fieldName) => {
+        const fieldSchema = properties[fieldName] ?? {};
+        const type = summarizeSchemaType(fieldSchema);
+        const requiredLabel = required.has(fieldName) ? 'required' : 'optional';
+        const description = typeof fieldSchema.description === 'string' &&
+            fieldSchema.description.length > 0
+            ? fieldSchema.description
+            : 'No description.';
+        return `- ${fieldName} (${type}, ${requiredLabel}): ${description}`;
+    }), `</${label}>`);
+    return lines;
+}
+function buildProtocolNotes(contract) {
+    const notes = [
+        '- Protocol failures use JSON-RPC `error`; execution failures use tool result `isError: true`.',
+    ];
+    if (contract.outputSchema) {
+        notes.push('- Successful responses include `structuredContent` that must match the declared output schema.');
+    }
+    if (contract.taskSupport === 'optional') {
+        notes.push('- Supports inline execution by default and task mode when durable polling or deferred results are needed.');
+    }
+    if (contract.taskSupport === 'required') {
+        notes.push('- Must run in task mode; callers should poll `tasks/get` and fetch the payload via `tasks/result`.');
+    }
+    if (contract.taskSupport === 'forbidden') {
+        notes.push('- Runs inline only; task augmentation is not supported for this tool.');
+    }
+    return notes;
+}
 export function buildToolInfo(name) {
+    const contract = CONTRACTS_BY_NAME.get(name);
     const entry = ENTRIES[name];
-    if (!entry)
+    if (!entry || !contract)
         return undefined;
-    const lines = [`## ${entry.name}`, '', entry.description];
+    const lines = [
+        `<tool_info name="${entry.name}">`,
+        `## ${entry.name}`,
+        '',
+        `Title: ${entry.title}`,
+        `Description: ${entry.description}`,
+        '',
+        '<execution>',
+        `- taskSupport: ${formatTaskSupportLabel(contract.taskSupport)}`,
+        '</execution>',
+        '',
+        '<annotations>',
+        `- readOnlyHint: ${formatAnnotationValue(contract.annotations?.readOnlyHint)}`,
+        `- idempotentHint: ${formatAnnotationValue(contract.annotations?.idempotentHint)}`,
+        `- destructiveHint: ${formatAnnotationValue(contract.annotations?.destructiveHint)}`,
+        `- openWorldHint: ${formatAnnotationValue(contract.annotations?.openWorldHint)}`,
+        '</annotations>',
+        '',
+        ...buildSchemaFieldLines('input_fields', contract.inputSchema),
+        '',
+        ...buildSchemaFieldLines('output_fields', contract.outputSchema),
+        '',
+        '<protocol_notes>',
+        ...buildProtocolNotes(contract),
+        '</protocol_notes>',
+    ];
     if (entry.annotations && entry.annotations.length > 0) {
-        lines.push('', `**Hints:** ${entry.annotations.join(', ')}`);
+        lines.push('', `<quick_hints>${entry.annotations.join(' ')}</quick_hints>`);
     }
     if (entry.nuances && entry.nuances.length > 0) {
-        lines.push('', '**Nuances:**');
+        lines.push('', '<nuances>');
         for (const nuance of entry.nuances) {
             lines.push(`- ${nuance}`);
         }
+        lines.push('</nuances>');
     }
     if (entry.gotchas && entry.gotchas.length > 0) {
-        lines.push('', '**Gotchas:**');
+        lines.push('', '<gotchas>');
         for (const gotcha of entry.gotchas) {
             lines.push(`- ${gotcha}`);
         }
+        lines.push('</gotchas>');
     }
+    lines.push('</tool_info>');
     return lines.join('\n');
 }

package/dist/resources.js

@@ -13,6 +13,8 @@ const TOOL_INFO_TEMPLATE = new ResourceTemplate('internal://tool-info/{name}', {
         resources: getToolContracts().map((contract) => ({
             uri: `internal://tool-info/${contract.name}`,
             name: contract.name,
+            title: contract.title,
+            description: contract.description,
             mimeType: 'text/markdown',
         })),
     }),

package/dist/schemas.d.ts

@@ -556,6 +556,8 @@ export declare const EditFileOutputSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     path: z.ZodOptional<z.ZodString>;
     appliedEdits: z.ZodOptional<z.ZodNumber>;
+    linesAdded: z.ZodOptional<z.ZodNumber>;
+    linesRemoved: z.ZodOptional<z.ZodNumber>;
     lineRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     unmatchedEdits: z.ZodOptional<z.ZodArray<z.ZodString>>;
     diff: z.ZodOptional<z.ZodString>;

package/dist/schemas.js

@@ -253,7 +253,8 @@ export const ReadFileInputSchema = z
     }),
     includeHash: defaultFalseBoolean('Include SHA-256 hash of full file content'),
 })
-    .superRefine(validateReadRange);
+    .superRefine(validateReadRange)
+    .describe("Use one read mode only: 'head', 'tail', or 'startLine'/'endLine'. 'endLine' requires 'startLine'.");
 export const ReadMultipleFilesInputSchema = z
     .strictObject({
     paths: z
@@ -268,7 +269,8 @@ export const ReadMultipleFilesInputSchema = z
         endLine: 'End line (1-based, inclusive) per file. Requires startLine.',
     }),
 })
-    .superRefine(validateReadRange);
+    .superRefine(validateReadRange)
+    .describe("Use one read mode only: 'head', 'tail', or 'startLine'/'endLine'. 'endLine' requires 'startLine'.");
 export const GetFileInfoInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
 });
@@ -451,7 +453,8 @@ export const CreateDirectoryInputSchema = z
     .refine((data) => data.path !== undefined || data.paths !== undefined, {
     error: "Either 'path' or 'paths' must be provided",
     path: ['path'],
-});
+})
+    .describe("Provide either 'path' or 'paths'.");
 export const CreateDirectoryOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
@@ -488,6 +491,8 @@ export const EditFileOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     appliedEdits: z.number().optional(),
+    linesAdded: z.number().optional().describe('Lines added'),
+    linesRemoved: z.number().optional().describe('Lines removed'),
     lineRange: z
         .tuple([z.number(), z.number()])
         .optional()
@@ -508,7 +513,8 @@ export const MoveFileInputSchema = z
     .refine((data) => (data.source ?? data.sources) !== undefined, {
     error: "Either 'source' or 'sources' must be provided",
     path: ['source'],
-});
+})
+    .describe("Provide either 'source' or 'sources'.");
 export const MoveFileOutputSchema = z.strictObject({
     ok: z.boolean(),
     source: z.string().optional(),

package/dist/server/bootstrap.js

@@ -5,7 +5,7 @@ import { InMemoryTaskMessageQueue, InMemoryTaskStore, } from '@modelcontextproto
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { isInitializeRequest, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { isInitializeRequest, LATEST_PROTOCOL_VERSION, SetLevelRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
 import { DEFAULT_LOG_LEVEL, parseEnvInt } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { withAllowedDirectoriesState } from '../lib/paths.js';
@@ -13,7 +13,7 @@ import { createInMemoryResourceStore } from '../lib/resource-store.js';
 import { isRecord } from '../lib/utils.js';
 import { registerCompletions } from '../completions.js';
 import { pkgInfo } from '../pkg-info.js';
-import { registerAnalyzePathPrompt, registerCompareFilesPrompt, registerGetHelpPrompt, } from '../prompts.js';
+import { registerAnalyzePathPrompt, registerCompareFilesPrompt, registerGetHelpPrompt, registerGetToolHelpPrompt, } from '../prompts.js';
 import { registerInstructionResource, registerMetricsResource, registerResultResources, registerToolCatalogResource, registerToolInfoResource, registerWorkflowGuideResource, } from '../resources.js';
 import { buildServerInstructions } from '../resources/generated-instructions.js';
 import { registerAllTools } from '../tools.js';
@@ -174,6 +174,7 @@ export async function createServer(options = {}) {
     registerGetHelpPrompt(server, serverInstructions, localIcon);
     registerCompareFilesPrompt(server, localIcon);
     registerAnalyzePathPrompt(server, localIcon);
+    registerGetToolHelpPrompt(server, localIcon);
     registerResultResources(server, resourceStore, localIcon);
     registerMetricsResource(server, localIcon);
     registerCompletions(server, serverInstructions);
@@ -242,7 +243,7 @@ async function readRequestBody(req) {
         req.on('error', reject);
     });
 }
-async function createHttpSession(options, sessions) {
+async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
     const mcpServer = await createServer(options);
     const rootsManager = getRootsManager(mcpServer);
     rootsManager.registerHandlers(mcpServer);
@@ -254,6 +255,7 @@ async function createHttpSession(options, sessions) {
                 server: mcpServer,
                 rootsManager,
                 transport,
+                negotiatedProtocolVersion,
             });
             rootsManager.logMissingDirectoriesIfNeeded(mcpServer);
         },
@@ -269,7 +271,12 @@ async function createHttpSession(options, sessions) {
         });
     };
     await mcpServer.connect(transport);
-    return { server: mcpServer, rootsManager, transport };
+    return {
+        server: mcpServer,
+        rootsManager,
+        transport,
+        negotiatedProtocolVersion,
+    };
 }
 function sendJsonRpcError(res, status, code, message) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
@@ -298,6 +305,29 @@ 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)) {
@@ -384,6 +414,10 @@ 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;
@@ -395,7 +429,7 @@ export async function startHttpServer(port, options) {
                         sendJsonRpcError(res, 503, JSON_RPC_SERVER_ERROR, 'Too many sessions');
                         return;
                     }
-                    const session = await createHttpSession(options, sessions);
+                    const session = await createHttpSession(options, sessions, resolveNegotiatedProtocolVersion(body.params.protocolVersion));
                     await handleSessionTransportRequest(session, req, res, body);
                     return;
                 }
@@ -410,6 +444,8 @@ 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);
             }
             else {

package/dist/tools/apply-patch.js

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { readFile, stat } from 'node:fs/promises';
 import { applyPatch, parsePatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
@@ -22,22 +22,13 @@ export const APPLY_PATCH_TOOL = {
         'Multi-file patches use `path` as base directory; per-file results in `results[]`.',
     ],
     gotchas: ['Patch must include valid hunk headers; use `dryRun=true` first.'],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
         return;
     throw new McpError(ErrorCode.E_TOO_LARGE, `File too large for patch: ${filePath} (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
 }
-function assertPatchHasHunks(patch) {
-    if (!patch.trim()) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch content is empty.');
-    }
-    const hasHunk = /@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(patch);
-    if (!hasHunk) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
-    }
-}
 function countStructuredPatchStats(diff) {
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -63,12 +54,12 @@ function extractPatchTargetPath(diff) {
         return stripGitPrefix(diff.oldFileName);
     return undefined;
 }
-async function applyPatchToFile(filePath, diff, options, signal) {
+async function applyDiff(filePath, diff, options, signal) {
     const validPath = await validateExistingPath(filePath, signal);
     assertAllowedFileAccess(filePath, validPath);
-    const stats = await withAbort(fs.stat(validPath), signal);
+    const stats = await withAbort(stat(validPath), signal);
     assertPatchTargetSizeWithinLimit(validPath, stats.size, MAX_TEXT_FILE_SIZE);
-    const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
+    const content = await readFile(validPath, { encoding: 'utf-8', signal });
     const patched = applyPatch(content, diff, {
         fuzzFactor: options.fuzzFactor,
         autoConvertLineEndings: options.autoConvertLineEndings,
@@ -89,32 +80,31 @@ async function applyPatchToFile(filePath, diff, options, signal) {
     }
     return { path: validPath, applied: true, ...patchStats };
 }
-async function handleMultiFilePatch(basePath, parsed, options, signal) {
+async function processMultiFilePatch(basePath, parsed, options, signal) {
     const validBase = await validateExistingPath(basePath, signal);
-    const results = [];
-    for (const diff of parsed) {
+    const promises = parsed.map(async (diff) => {
         const fileName = extractPatchTargetPath(diff);
         if (!fileName) {
-            results.push({
+            return {
                 path: '<unknown>',
                 applied: false,
                 error: 'Missing file name in patch header',
-            });
-            continue;
+            };
         }
         const filePath = path.resolve(validBase, fileName);
         try {
-            const result = await applyPatchToFile(filePath, diff, options, signal);
-            results.push({ ...result, path: fileName });
+            const result = await applyDiff(filePath, diff, options, signal);
+            return { ...result, path: fileName };
         }
         catch (error) {
-            results.push({
+            return {
                 path: fileName,
                 applied: false,
                 error: formatUnknownErrorMessage(error),
-            });
+            };
         }
-    }
+    });
+    const results = await Promise.all(promises);
     const totals = results.reduce((acc, r) => {
         if (r.applied) {
             acc.applied++;
@@ -137,24 +127,28 @@ async function handleMultiFilePatch(basePath, parsed, options, signal) {
     });
 }
 async function handleApplyPatch(args, signal) {
-    assertPatchHasHunks(args.patch);
+    if (!args.patch.trim()) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch content is empty.');
+    }
     const fuzzFactor = args.fuzzFactor ?? 0;
     const parsed = parsePatch(args.patch);
+    const hasHunks = parsed.some((p) => p.hunks.length > 0);
+    if (!hasHunks) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
+    }
     const options = {
         dryRun: args.dryRun,
         fuzzFactor,
         autoConvertLineEndings: args.autoConvertLineEndings,
     };
-    // Multi-file patch: best-effort per file
     if (parsed.length > 1) {
-        return handleMultiFilePatch(args.path, parsed, options, signal);
+        return processMultiFilePatch(args.path, parsed, options, signal);
     }
-    // Single-file patch: delegate to shared helper, then assert success
     const diff = parsed[0];
     if (!diff) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'No patch content found.');
     }
-    const result = await applyPatchToFile(args.path, diff, options, signal);
+    const result = await applyDiff(args.path, diff, options, signal);
     if (!result.applied) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, result.error === 'Patch had no effect'
             ? 'Patch had no effect \u2014 the file content is unchanged after applying. The patch may not match the current file content. Generate a fresh patch via diff_files and retry.'
@@ -194,9 +188,12 @@ export function registerApplyPatchTool(server, options = {}) {
             const sc = result.structuredContent;
             if (!sc.ok)
                 return `🛠 patch: ${name} • failed`;
-            if (args.dryRun)
-                return `🛠 patch: ${name} • dry run OK`;
-            return `🛠 patch: ${name} • applied`;
+            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`;
         },
     });
     const validatedHandler = withValidatedArgs(ApplyPatchInputSchema, wrappedHandler);

package/dist/tools/calculate-hash.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
 import { PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/core.js';
@@ -26,15 +27,9 @@ export const CALCULATE_HASH_TOOL = {
     taskSupport: 'optional',
 };
 async function hashFile(filePath, encoding, signal) {
-    assertNotAborted(signal);
-    const hashOp = createHash('sha256');
-    const stream = createReadStream(filePath, { signal });
-    for await (const chunk of stream) {
-        hashOp.update(chunk);
-        assertNotAborted(signal);
-    }
-    assertNotAborted(signal);
-    return encoding === undefined ? hashOp.digest() : hashOp.digest(encoding);
+    const hasher = createHash('sha256');
+    await pipeline(createReadStream(filePath, { signal, highWaterMark: 64 * 1024 }), hasher, { signal });
+    return encoding ? hasher.digest(encoding) : hasher.digest();
 }
 function toStableRelativePath(root, entryPath) {
     const relativePath = path.relative(root, entryPath);
@@ -84,25 +79,27 @@ async function hashDirectory(dirPath, options = {}) {
         });
     }
     assertNotAborted(signal);
-    // Phase 2: hash files concurrently with bounded pool.
     const concurrency = Math.min(PARALLEL_CONCURRENCY, 8);
     const entries = [];
     let filesHashed = 0;
     const totalFiles = filteredPaths.length;
-    for (let i = 0; i < filteredPaths.length; i += concurrency) {
-        assertNotAborted(signal);
-        const batch = filteredPaths.slice(i, i + concurrency);
-        const batchResults = await Promise.all(batch.map(async ({ filePath, relativePath }) => {
-            const fileHash = await hashFile(filePath, undefined, signal);
-            return { path: relativePath, hash: fileHash };
-        }));
-        entries.push(...batchResults);
-        filesHashed += batchResults.length;
-        reportPeriodicProgress(onProgress, filesHashed, {
-            throttleModulo: 25,
-            total: totalFiles,
-        });
-    }
+    const taskQueue = filteredPaths;
+    const worker = async () => {
+        while (taskQueue.length > 0) {
+            const task = taskQueue.pop();
+            if (!task)
+                break;
+            assertNotAborted(signal);
+            const fileHash = await hashFile(task.filePath, undefined, signal);
+            entries.push({ path: task.relativePath, hash: fileHash });
+            filesHashed++;
+            reportPeriodicProgress(onProgress, filesHashed, {
+                throttleModulo: 25,
+                total: totalFiles,
+            });
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, () => worker()));
     reportPeriodicProgress(onProgress, filesHashed, {
         throttleModulo: 25,
         total: totalFiles,

package/dist/tools/contract.d.ts

@@ -39,7 +39,7 @@ export interface ToolContract {
      */
     gotchas?: string[];
     /**
-     * Task support level for the tool. Defaults to 'optional'.
+     * Task support level for the tool. Defaults to 'forbidden'.
      */
     taskSupport?: 'optional' | 'required' | 'forbidden';
 }

package/dist/tools/create-directory.js

@@ -14,7 +14,7 @@ export const CREATE_DIRECTORY_TOOL = {
     outputSchema: CreateDirectoryOutputSchema,
     annotations: IDEMPOTENT_WRITE_TOOL_ANNOTATIONS,
     nuances: ['Succeeds silently if the directory already exists (idempotent).'],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 export async function handleCreateDirectory(args, signal) {
     const allPaths = [];
@@ -55,12 +55,12 @@ export function registerCreateDirectoryTool(server, options = {}) {
                 const name = path.basename(args.path);
                 if (result.isError)
                     return `🛠 mkdir: ${name} • failed`;
-                return `🛠 mkdir: ${name} • created`;
+                return `🛠 mkdir: ${name}`;
             }
             const count = (args.path ? 1 : 0) + (args.paths?.length ?? 0);
             if (result.isError)
                 return `🛠 mkdir: ${count} directories • failed`;
-            return `🛠 mkdir: ${count} directories • created`;
+            return `🛠 mkdir: ${count} directories`;
         },
     });
     const validatedHandler = withValidatedArgs(CreateDirectoryInputSchema, wrappedHandler);

package/dist/tools/delete-file.js

@@ -17,7 +17,7 @@ export const DELETE_FILE_TOOL = {
         'No undo — deletion is permanent.',
         'Non-empty directories require `recursive=true`.',
     ],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 async function handleDeleteFile(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);
@@ -90,7 +90,7 @@ export function registerDeleteFileTool(server, options = {}) {
             const name = path.basename(args.path);
             if (result.isError)
                 return `🛠 rm: ${name} • failed`;
-            return `🛠 rm: ${name} • deleted`;
+            return `🛠 rm: ${name}`;
         },
     });
     const validatedHandler = withValidatedArgs(DeleteFileInputSchema, wrappedHandler);