@j0hanz/filesystem-mcp 1.10.0 → 1.11.1

package/dist/completions.js

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import { CompleteRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getAllowedDirectories, isPathWithinDirectories, normalizePath, toPosixPath, } from './lib/paths.js';
 import { isRecord } from './lib/utils.js';
+import { getSortedToolContracts } from './resources/tool-info.js';
 const MAX_COMPLETION_ITEMS = 100;
 const COMPLETION_RATE_LIMIT_MS = 100;
 const MAX_COMPLETION_CACHE_KEYS = 128;
@@ -29,6 +30,9 @@ function extractTopicCompletions(instructions) {
     }
     return headers;
 }
+function extractToolNameCompletions() {
+    return getSortedToolContracts().map((contract) => contract.name);
+}
 const PATH_ARGUMENTS = new Set([
     'path',
     'source',
@@ -415,6 +419,7 @@ export async function getPathCompletions(currentValue, options = {}) {
 }
 export function registerCompletions(server, instructions = '') {
     const topicValues = extractTopicCompletions(instructions);
+    const toolNameValues = extractToolNameCompletions();
     server.server.setRequestHandler(CompleteRequestSchema, async (request) => {
         const { params } = request;
         const { argument, ref } = params;
@@ -427,6 +432,26 @@ export function registerCompletions(server, instructions = '') {
                 : topicValues;
             return buildCompletionResponse(buildCompletionResult(filtered));
         }
+        if (isRecord(ref) &&
+            ref['type'] === 'ref/prompt' &&
+            ref['name'] === 'get-tool-help' &&
+            argName === 'name') {
+            const currentValue = argument.value.toLowerCase();
+            const filtered = currentValue
+                ? toolNameValues.filter((value) => value.startsWith(currentValue))
+                : toolNameValues;
+            return buildCompletionResponse(buildCompletionResult(filtered));
+        }
+        if (isRecord(ref) &&
+            ref['type'] === 'ref/resource' &&
+            ref['uri'] === 'internal://tool-info/{name}' &&
+            argName === 'name') {
+            const currentValue = argument.value.toLowerCase();
+            const filtered = currentValue
+                ? toolNameValues.filter((value) => value.startsWith(currentValue))
+                : toolNameValues;
+            return buildCompletionResponse(buildCompletionResult(filtered));
+        }
         const isPathArg = isPathLikeArgumentName(argName) ||
             isPathArgumentFromReference(argName, ref);
         if (!isPathArg) {

package/dist/prompts.d.ts

@@ -3,3 +3,4 @@ import { type IconInfo } from './tools/shared.js';
 export declare function registerGetHelpPrompt(server: McpServer, instructions: string, iconInfo?: IconInfo): void;
 export declare function registerCompareFilesPrompt(server: McpServer, iconInfo?: IconInfo): void;
 export declare function registerAnalyzePathPrompt(server: McpServer, iconInfo?: IconInfo): void;
+export declare function registerGetToolHelpPrompt(server: McpServer, iconInfo?: IconInfo): void;

package/dist/prompts.js

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { ErrorCode, McpError } from './lib/errors.js';
+import { buildToolInfo, getSortedToolContracts, } from './resources/tool-info.js';
 import { withDefaultIcons } from './tools/shared.js';
 const HELP_PROMPT_NAME = 'get-help';
 const HELP_PROMPT_TITLE = 'Get Help';
@@ -9,6 +11,9 @@ const COMPARE_FILES_PROMPT_DESCRIPTION = 'Generate a workflow for comparing two
 const ANALYZE_PATH_PROMPT_NAME = 'analyze-path';
 const ANALYZE_PATH_PROMPT_TITLE = 'Analyze Path';
 const ANALYZE_PATH_PROMPT_DESCRIPTION = 'Generate a workflow for analyzing a file or directory using stat, read, and tree.';
+const GET_TOOL_HELP_PROMPT_NAME = 'get-tool-help';
+const GET_TOOL_HELP_PROMPT_TITLE = 'Get Tool Help';
+const GET_TOOL_HELP_PROMPT_DESCRIPTION = 'Return a prompt with the authoritative contract for a specific filesystem-mcp tool.';
 function filterInstructionsByTopic(instructions, topic) {
     const normalized = topic.trim().toLowerCase();
     if (!normalized)
@@ -24,6 +29,12 @@ function filterInstructionsByTopic(instructions, topic) {
         .join(', ');
     return `Section '${topic}' not found. Available: ${available}\n\n${instructions}`;
 }
+function findKnownToolName(rawName) {
+    const normalized = rawName.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    return getSortedToolContracts().find((contract) => contract.name.toLowerCase() === normalized)?.name;
+}
 export function registerGetHelpPrompt(server, instructions, iconInfo) {
     const baseConfig = withDefaultIcons({ title: HELP_PROMPT_TITLE, description: HELP_PROMPT_DESCRIPTION }, iconInfo);
     server.registerPrompt(HELP_PROMPT_NAME, {
@@ -97,3 +108,50 @@ export function registerAnalyzePathPrompt(server, iconInfo) {
         ],
     }));
 }
+export function registerGetToolHelpPrompt(server, iconInfo) {
+    server.registerPrompt(GET_TOOL_HELP_PROMPT_NAME, {
+        ...withDefaultIcons({
+            title: GET_TOOL_HELP_PROMPT_TITLE,
+            description: GET_TOOL_HELP_PROMPT_DESCRIPTION,
+        }, iconInfo),
+        argsSchema: {
+            name: z
+                .string()
+                .min(1)
+                .describe('Tool name from tools/list or internal://tool-info/{name}.'),
+        },
+    }, ({ name }) => {
+        const toolName = findKnownToolName(name);
+        if (!toolName) {
+            throw new McpError(ErrorCode.E_INVALID_INPUT, `Unknown tool: ${name}`);
+        }
+        const toolInfo = buildToolInfo(toolName);
+        if (!toolInfo) {
+            throw new McpError(ErrorCode.E_INVALID_INPUT, `Unknown tool: ${toolName}`);
+        }
+        return {
+            description: GET_TOOL_HELP_PROMPT_DESCRIPTION,
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        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.',
+                    },
+                },
+                {
+                    role: 'user',
+                    content: {
+                        type: 'resource',
+                        resource: {
+                            uri: `internal://tool-info/${toolName}`,
+                            mimeType: 'text/markdown',
+                            text: toolInfo,
+                        },
+                    },
+                },
+            ],
+        };
+    });
+}

package/dist/resources/generated-instructions.js

@@ -1,6 +1,9 @@
 import { buildToolCatalogDetailsOnly } from './tool-catalog.js';
-import { buildCoreContextPack, formatToolNameList, getSharedConstraints, getTaskCapableToolNames, getToolContracts, pickAvailableToolNames, } from './tool-info.js';
+import { buildCoreContextPack, formatToolNameList, getSharedConstraints, getTaskCapableToolNames, getTaskToolNamesBySupport, getToolContracts, pickAvailableToolNames, } from './tool-info.js';
 import { buildWorkflowGuide } from './workflows.js';
+function formatTaskModeLine(label, names) {
+    return `${label}: ${names.length > 0 ? formatToolNameList(names) : 'none'}.`;
+}
 function buildToolsOverview() {
     const rows = [
         ['Navigate', pickAvailableToolNames(['roots', 'ls', 'tree', 'find'])],
@@ -29,6 +32,8 @@ function buildToolsOverview() {
 }
 function buildInstructionsHeader() {
     const taskCapable = formatToolNameList(getTaskCapableToolNames());
+    const optionalTaskTools = getTaskToolNamesBySupport('optional');
+    const requiredTaskTools = getTaskToolNamesBySupport('required');
     return `<role>
 Filesystem agent. Scope: allowed roots only. Discover paths before acting — never guess.
 </role>
@@ -49,9 +54,12 @@ ${buildToolsOverview()}
 </resources>
 
 <task_protocol>
-Task execution: Tools returning a task ID must be polled via \`tasks/get\`, then retrieved via \`tasks/result\`.
+Task execution: Call task-capable tools inline by default; add \`task\` only when durable polling or deferred results are needed.
+Task results: When a task is requested, poll via \`tasks/get\`, then retrieve the final payload via \`tasks/result\`.
 Progress: Pass \`_meta.progressToken\` in \`tools/call\` to receive \`notifications/progress\`.
-Task-capable: ${taskCapable}.
+Task-capable: ${taskCapable || 'none'}.
+${formatTaskModeLine('Optional task mode', optionalTaskTools)}
+${formatTaskModeLine('Required task mode', requiredTaskTools)}
 </task_protocol>
 `;
 }

package/dist/resources/tool-catalog.js

@@ -1,4 +1,4 @@
-import { buildCoreContextPack, pickAvailableToolNames } from './tool-info.js';
+import { buildCoreContextPack, getTaskCapableToolNames, pickAvailableToolNames, } from './tool-info.js';
 function buildCrossToolDataFlow() {
     const flows = [];
     if (pickAvailableToolNames(['find', 'read']).length === 2) {
@@ -14,13 +14,59 @@ function buildCrossToolDataFlow() {
     return flows.join('\n');
 }
 function buildCatalogGuide() {
-    return `<tool_selection_guide>
+    const taskCapable = getTaskCapableToolNames();
+    return (`<tool_selection_guide>
+## Primitive Routing
+
+- ` +
+        '`tools`' +
+        `: model-controlled operations that inspect or mutate the allowed filesystem.
+- ` +
+        '`resources`' +
+        `: application-driven context such as ` +
+        '`internal://instructions`' +
+        `, ` +
+        '`internal://tool-info/{name}`' +
+        `, and cached ` +
+        '`filesystem-mcp://result/{id}`' +
+        ` output.
+- ` +
+        '`prompts`' +
+        `: user-controlled workflow templates for help, comparison, and guided inspection.
+- ` +
+        '`completion`' +
+        `: argument suggestions for prompts and resource templates; not a discovery mechanism.
+
 ## Cross-Tool Data Flow
 
 \`\`\`
 ${buildCrossToolDataFlow()}
 \`\`\`
 
+## Result Contract
+
+- Successful tools return ` +
+        '`content`' +
+        ` and usually ` +
+        '`structuredContent`' +
+        `.
+- Tool/business failures return ` +
+        '`isError: true`' +
+        ` inside the tool result, not a JSON-RPC protocol error.
+- When a tool returns ` +
+        '`resourceUri`' +
+        ` or a ` +
+        '`resource_link`' +
+        `, follow it with ` +
+        '`resources/read`' +
+        ` immediately.
+
+## Task Mode Routing
+
+- Inline first for fast operations.
+- Add task mode only when the caller needs durable polling, deferred retrieval, or cancellation after the initial response.
+- Task-capable tools: ${taskCapable.length > 0 ? taskCapable.map((name) => `\`${name}\``).join(', ') : 'none'}.
+
 ## Search Strategy
 
 - \`find\`: glob file discovery.
@@ -47,7 +93,7 @@ ${buildCrossToolDataFlow()}
 - \`apply_patch\` accepts unified diffs - single-file or multi-file.
 - Multi-file: \`path\` is base directory; each file is best-effort with per-file \`results[]\`.
 </tool_selection_guide>
-`;
+`);
 }
 export function buildToolCatalog() {
     return `${buildCoreContextPack()}\n\n${buildCatalogGuide()}`;

package/dist/resources/tool-info.d.ts

@@ -4,6 +4,7 @@ export declare function getSortedToolContracts(): ToolContract[];
 export declare function pickAvailableToolNames(names: readonly string[]): string[];
 export declare function formatToolNameList(names: readonly string[]): string;
 export declare function getTaskCapableToolNames(): string[];
+export declare function getTaskToolNamesBySupport(taskSupport: Extract<ToolContract['taskSupport'], 'optional' | 'required'>): string[];
 export declare function buildCoreContextPack(): string;
 export declare function getSharedConstraints(): string[];
 export declare function buildToolInfo(name: string): string | undefined;

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,135 @@ 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) {
+    return z.toJSONSchema(schema);
+}
+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 jsonSchema = toJsonSchemaObject(schema);
+    const properties = jsonSchema.properties ?? {};
+    const required = new Set(jsonSchema.required ?? []);
+    const fieldNames = Object.keys(properties);
+    if (fieldNames.length === 0) {
+        return [`<${label}>`, '- object with no fields', `</${label}>`];
+    }
+    return [
+        `<${label}>`,
+        ...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}>`,
+    ];
+}
+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

@@ -63,8 +63,8 @@ export declare const SearchFilesInputSchema: z.ZodObject<{
     sortBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         name: "name";
         size: "size";
-        path: "path";
         modified: "modified";
+        path: "path";
     }>>>;
     maxDepth: z.ZodOptional<z.ZodInt>;
     cursor: z.ZodOptional<z.ZodString>;
@@ -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

@@ -488,6 +488,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()

package/dist/server/bootstrap.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);

package/dist/tools/apply-patch.js

@@ -22,7 +22,7 @@ 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)
@@ -194,9 +194,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/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);

package/dist/tools/diff-files.js

@@ -18,7 +18,7 @@ export const DIFF_FILES_TOOL = {
     outputSchema: DiffFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
     gotchas: ['`isIdentical=true` means no hunks (`@@`) and empty diff.'],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 function computeDiffStats(patch) {
     let linesAdded = 0;
@@ -119,7 +119,11 @@ export function registerDiffFilesTool(server, options = {}) {
                 return `🕮 diff: ${n1} ⟷ ${n2} • failed`;
             if (sc.isIdentical)
                 return `🕮 diff: ${n1} ⟷ ${n2} • identical`;
-            return `🕮 diff: ${n1} ⟷ ${n2} • changed`;
+            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}`;
         },
     });
     const validatedHandler = withValidatedArgs(DiffFilesInputSchema, wrappedHandler);