@j0hanz/filesystem-mcp 1.14.0 → 1.14.1

package/dist/resources/generated-instructions.js

@@ -28,52 +28,61 @@ function buildToolsOverview() {
         .join('\n');
 }
 function buildInstructionsHeader() {
-    return `<role>
-Filesystem agent. Scope: allowed roots only. Discover paths before acting — never guess.
-</role>
+    return `## Role
+
+Secure filesystem agent. Operate strictly within allowed roots. Resolve paths before acting — never assume.
+
+## Tools Overview
 
-<tools_overview>
 | Category | Tools |
-|----------|-------|
+| -------- | ----- |
+
 ${buildToolsOverview()}
-</tools_overview>
 
-<resources>
-- \`internal://instructions\`: Full usage reference.
-- \`internal://tool-catalog\`: Tool routing and data flow.
-- \`internal://workflows\`: Standard execution sequences.
-- \`internal://tool-info/{name}\`: Per-tool nuances (e.g. \`internal://tool-info/read\`).
-- \`filesystem-mcp://result/{id}\`: Cached large output — call \`resources/read\` immediately when \`resourceUri\` is returned.
-- \`filesystem-mcp://metrics\`: Per-tool runtime metrics.
-</resources>
+## Resources
+
+| URI                              | Purpose                                                        |
+| -------------------------------- | -------------------------------------------------------------- |
+| \`internal://instructions\`      | Full usage reference (this document)                           |
+| \`internal://tool-catalog\`      | Tool routing, data flow, and selection guide                   |
+| \`internal://workflows\`         | Step-by-step execution sequences                               |
+| \`internal://tool-info/{name}\`  | Per-tool contract (e.g. \`internal://tool-info/read\`)         |
+| \`filesystem-mcp://result/{id}\` | Cached large output — fetch via \`resources/read\` immediately |
+| \`filesystem-mcp://metrics\`     | Per-tool call count, error rate, and avg duration              |
 
-<task_protocol>
-Task execution: Check \`execution.taskSupport\` per tool — \`forbidden\` (default): never send \`task\`; \`optional\`: send \`task\` only when durable polling or deferred results are needed; \`required\`: always send \`task\`.
-Task results: Poll via \`tasks/get\`, then retrieve the final payload via \`tasks/result\`.
-Progress: Pass \`_meta.progressToken\` in \`tools/call\` to receive \`notifications/progress\`.
-</task_protocol>
+## Task Protocol
+
+- Check \`execution.taskSupport\` before sending task metadata.
+  - \`forbidden\` (default): Do not send \`task\`.
+  - \`optional\`: Send \`task\` only when durable polling or deferred retrieval is needed.
+  - \`required\`: Always send \`task\`.
+- Poll status via \`tasks/get\`, retrieve final payload via \`tasks/result\`.
+- Pass \`_meta.progressToken\` in \`tools/call\` to receive \`notifications/progress\`.
 `;
 }
-const INSTRUCTIONS_FOOTER = `<constraints>
+const INSTRUCTIONS_FOOTER = `## Constraints
+
 ${getSharedConstraints()
     .map((c) => `- ${c}`)
     .join('\n')}
-</constraints>
 
-<error_handling>
-- \`E_ACCESS_DENIED\` => call \`roots\`, use an allowed path.
-- \`E_NOT_FOUND\` => call \`ls\` or \`find\`, verify spelling.
-- \`E_TOO_LARGE\` => use \`head\`, line ranges, or \`read_many\`.
-- \`E_TIMEOUT\` => reduce scope or result limits.
-</error_handling>
+## Error Recovery
+
+| Error Code          | Action                                                                    |
+| ------------------- | ------------------------------------------------------------------------- |
+| \`ACCESS_DENIED\`   | Run \`roots\` to list allowed directories, retry with a valid path.       |
+| \`NOT_FOUND\`       | Run \`ls\` or \`find\` to verify the path.                                |
+| \`TOO_LARGE\`       | Use \`head\`/\`tail\`, line ranges, or split across \`read_many\`.        |
+| \`TIMEOUT\`         | Reduce scope, depth, or maxResults.                                       |
+| \`INVALID_INPUT\`   | Re-read tool contract via \`internal://tool-info/{name}\`.                |
 `;
 function formatToolSection(tool) {
     const parts = [`### ${tool.name}\n${tool.description}`];
     if (tool.nuances && tool.nuances.length > 0) {
-        parts.push(...tool.nuances.map((n) => `- Nuance: ${n}`));
+        parts.push(...tool.nuances.map((n) => `- ${n}`));
     }
     if (tool.gotchas && tool.gotchas.length > 0) {
-        parts.push(...tool.gotchas.map((g) => `- Gotcha: ${g}`));
+        parts.push(...tool.gotchas.map((g) => `- ⚠ ${g}`));
     }
     return parts.join('\n');
 }
@@ -85,9 +94,9 @@ export function buildServerInstructions() {
         '',
         buildToolCatalogDetailsOnly(),
         '',
-        '<tool_reference>',
+        '## Tool Reference',
+        '',
         toolSections,
-        '</tool_reference>',
         '',
         buildWorkflowGuide(),
         '',

package/dist/resources/tool-catalog.js

@@ -15,13 +15,16 @@ function buildCrossToolDataFlow() {
 }
 function buildCatalogGuide() {
     const taskCapable = getTaskCapableToolNames();
-    return `<tool_selection_guide>
+    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.
+| Primitive      | Purpose                                                                                                                            |
+| -------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| \`tools\`      | Model-controlled operations that inspect or mutate the filesystem within allowed roots.                                            |
+| \`resources\`  | Application-driven context: \`internal://instructions\`, \`internal://tool-info/{name}\`, cached \`filesystem-mcp://result/{id}\`. |
+| \`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
 
@@ -31,37 +34,40 @@ ${buildCrossToolDataFlow()}
 
 ## Result Contract
 
-- Successful tools return \`content\` and \`structuredContent\` (when \`outputSchema\` is declared).
-- When \`isError: true\`, \`structuredContent\` is omitted — parse the \`content\` text instead.
-- 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.
+- Success: returns both \`content\` (JSON text) and \`structuredContent\` (when \`outputSchema\` is declared).
+- Error: \`isError: true\` in tool result, \`structuredContent\` omitted. Parse \`content\` text for error details.
+- Tool/business failures use \`isError: true\` inside the tool result, not JSON-RPC protocol errors.
+- When a response includes \`resourceUri\` or \`resource_link\`, follow up with \`resources/read\` immediately.
+
+## Task Mode
 
-## Task Mode Routing
+Use inline execution by default. Add task mode only when the caller needs durable polling, deferred retrieval, or cancellation.
 
-- 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'}.
+Task-capable tools: ${taskCapable.length > 0 ? taskCapable.map((name) => `\`${name}\``).join(', ') : 'none'}.
 
 ## Search Strategy
 
-- \`find\`: glob file discovery.
-- \`grep\`: text content search.
-- \`search_and_replace\`: replacement only, not discovery.
+| Goal                    | Tool                                       |
+| ----------------------- | ------------------------------------------ |
+| Find files by name/glob | \`find\`                                   |
+| Search file contents    | \`grep\`                                   |
+| Replace across files    | \`search_and_replace\` (not for discovery) |
 
 ## Write Strategy
 
-1. **Single file, targeted change?** -> \`edit\` (match exact text, replace first occurrence)
-2. **Single file, full rewrite?** -> \`write\` (overwrite entire content)
-3. **Multiple files, same change?** -> \`search_and_replace\` (glob + pattern across files)
-4. **Not sure what to change?** -> \`grep\` first, then decide
+| Scenario                    | Tool                                                  |
+| --------------------------- | ----------------------------------------------------- |
+| Single file, targeted edit  | \`edit\` — match exact text, replace first occurrence |
+| Single file, full rewrite   | \`write\` — overwrite entire content                  |
+| Multiple files, same change | \`search_and_replace\` — glob + pattern across files  |
+| Unsure what to change       | \`grep\` first, then decide                           |
 
-## Patch Management
+## Patch Strategy
 
-- Generate patches with \`diff_files\` first.
-- Validate with \`apply_patch(dryRun:true)\` before writing.
-- \`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>
+1. Generate with \`diff_files\`.
+2. Validate with \`apply_patch(dryRun: true)\` before writing.
+3. Apply with \`apply_patch\`.
+4. Multi-file patches: set \`path\` to the base directory; results are per-file.
 `;
 }
 export function buildToolCatalog() {

package/dist/resources/tool-info.js

@@ -63,14 +63,14 @@ export function buildCoreContextPack() {
         const annotations = e.annotations ? ` ${e.annotations.join(' ')}` : '';
         return `| \`${e.name}\` | ${e.description}${annotations} |`;
     });
-    return `<core_context>\n| Tool | Purpose |\n|------|---------|\n${rows.join('\n')}\n</core_context>`;
+    return `## Tool Summary\n\n| Tool | Purpose |\n|------|---------|\n${rows.join('\n')}`;
 }
 export function getSharedConstraints() {
     return [
-        'Use allowed roots only (from CLI negotiation).',
-        'Sensitive paths are denylisted by default.',
-        `Limits enforced: max file size ${Math.floor(MAX_TEXT_FILE_SIZE / 1024 / 1024)}MB; search caps ${MAX_SEARCH_RESULTS} files, ${DEFAULT_SEARCH_CONTENT_RESULTS} content matches.`,
-        'If response includes `resourceUri`, call `resources/read` immediately — cached results expire on restart.',
+        'Operate within allowed roots only (negotiated at startup via CLI).',
+        'Sensitive file paths (e.g. .env, *.pem, *id_rsa*) are denied by default.',
+        `Enforced limits: max file size ${Math.floor(MAX_TEXT_FILE_SIZE / 1024 / 1024)} MB, file search cap ${MAX_SEARCH_RESULTS} results, content search cap ${DEFAULT_SEARCH_CONTENT_RESULTS} matches.`,
+        'When a response includes `resourceUri`, call `resources/read` immediately — cached results expire on server restart.',
     ];
 }
 function formatTaskSupportLabel(taskSupport) {
@@ -86,6 +86,14 @@ function formatTaskSupportLabel(taskSupport) {
 function toJsonSchemaObject(schema, io = 'output') {
     return z.toJSONSchema(schema, { io });
 }
+function summarizeArrayType(schema) {
+    if (Array.isArray(schema.prefixItems) && schema.prefixItems.length > 0) {
+        const itemTypes = schema.prefixItems.map(summarizeSchemaType).join(', ');
+        return `tuple<${itemTypes}>`;
+    }
+    const itemType = schema.items ? summarizeSchemaType(schema.items) : 'unknown';
+    return `array<${itemType}>`;
+}
 function summarizeSchemaType(schema) {
     if (Array.isArray(schema.enum) && schema.enum.length > 0) {
         return `enum(${schema.enum.map((value) => JSON.stringify(value)).join(', ')})`;
@@ -100,14 +108,7 @@ function summarizeSchemaType(schema) {
         return schema.oneOf.map(summarizeSchemaType).join(' | ');
     }
     if (schema.type === 'array') {
-        if (Array.isArray(schema.prefixItems) && schema.prefixItems.length > 0) {
-            const itemTypes = schema.prefixItems.map(summarizeSchemaType).join(', ');
-            return `tuple<${itemTypes}>`;
-        }
-        const itemType = schema.items
-            ? summarizeSchemaType(schema.items)
-            : 'unknown';
-        return `array<${itemType}>`;
+        return summarizeArrayType(schema);
     }
     if (schema.type === 'object' && schema.additionalProperties === false) {
         return 'object (strict)';
@@ -117,16 +118,23 @@ function summarizeSchemaType(schema) {
     }
     return 'unknown';
 }
+function formatFieldLabel(label) {
+    return label
+        .split('_')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
 function buildSchemaFieldLines(label, schema) {
+    const heading = `**${formatFieldLabel(label)}:**`;
     if (!schema) {
-        return [`<${label}>`, '- none', `</${label}>`];
+        return [heading, '- none'];
     }
     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}>`];
+    const lines = [heading];
     if (typeof jsonSchema.description === 'string' &&
         jsonSchema.description.length > 0) {
         lines.push(`- Schema constraints: ${jsonSchema.description}`);
@@ -135,7 +143,7 @@ function buildSchemaFieldLines(label, schema) {
         lines.push('- Unknown fields are rejected (`additionalProperties: false`).');
     }
     if (fieldNames.length === 0) {
-        lines.push('- object with no fields', `</${label}>`);
+        lines.push('- object with no fields');
         return lines;
     }
     lines.push(...fieldNames.map((fieldName) => {
@@ -147,7 +155,7 @@ function buildSchemaFieldLines(label, schema) {
             ? fieldSchema.description
             : 'No description.';
         return `- ${fieldName} (${type}, ${requiredLabel}): ${description}`;
-    }), `</${label}>`);
+    }));
     return lines;
 }
 export function buildToolInfo(name) {
@@ -165,37 +173,34 @@ export function buildToolInfo(name) {
     if (contract.annotations?.openWorldHint)
         annotationLines.push('- openWorldHint: true');
     const lines = [
-        `<tool_info name="${entry.name}">`,
-        `## ${entry.name}`,
+        `---`,
+        `# ${entry.name}`,
         '',
-        `Title: ${entry.title}`,
-        `Description: ${entry.description}`,
+        `**Title:** ${entry.title}`,
+        `**Description:** ${entry.description}`,
         '',
-        '<execution>',
+        '**Execution:**',
         `- taskSupport: ${formatTaskSupportLabel(contract.taskSupport)}`,
-        '</execution>',
         '',
         ...buildSchemaFieldLines('input_fields', contract.inputSchema),
         '',
         ...buildSchemaFieldLines('output_fields', contract.outputSchema),
     ];
     if (annotationLines.length > 0) {
-        lines.push('', '<annotations>', ...annotationLines, '</annotations>');
+        lines.push('', '**Behavior:**', ...annotationLines);
     }
     if (entry.nuances && entry.nuances.length > 0) {
-        lines.push('', '<nuances>');
+        lines.push('', '**Usage Notes:**');
         for (const nuance of entry.nuances) {
             lines.push(`- ${nuance}`);
         }
-        lines.push('</nuances>');
     }
     if (entry.gotchas && entry.gotchas.length > 0) {
-        lines.push('', '<gotchas>');
+        lines.push('', '**Warnings:**');
         for (const gotcha of entry.gotchas) {
             lines.push(`- ${gotcha}`);
         }
-        lines.push('</gotchas>');
     }
-    lines.push('</tool_info>');
+    lines.push('---');
     return lines.join('\n');
 }

package/dist/resources/workflows.js

@@ -18,22 +18,43 @@ export function buildWorkflowGuide() {
         'rm',
         'mkdir',
     ]));
-    return `<workflows>
-### A: EXPLORE — directory layout or file content
-1. ${exploreTools}.
-   > **Strict:** Resolve paths first. Never guess.
-
-### B: SEARCH — files by pattern or content
-1. ${searchTools}.
-   > **Strict:** Content search with \`grep\`, not \`find\`.
-
-### C: EDIT — modify files or layout
-1. ${editTools}.
-2. Use \`edit\` for targeted changes, \`search_and_replace\` for bulk changes, and \`mv\`/\`rm\`/\`mkdir\` for layout updates.
-   > **Strict:** Confirm destructive ops (\`write\`, \`mv\`, \`rm\`, bulk replace).
-
-### D: PATCH — apply unified diffs
-1. \`diff_files\` → \`apply_patch(dryRun:true)\` → \`apply_patch\`.
-   > **Tip:** Feed \`diff_files\` output directly. Multi-file patches: \`path\` = base dir, results per file.
-</workflows>`;
+    return `## Workflows
+
+### A: Explore — Discover directory layout or file content
+
+**Tools:** ${exploreTools}
+
+1. Start with \`roots\` to identify allowed directories.
+2. Use \`ls\` or \`tree\` to map structure, then \`stat\` or \`read\` for details.
+
+> Resolve paths before acting. Never assume a path exists.
+
+### B: Search — Find files by name or content
+
+**Tools:** ${searchTools}
+
+1. Use \`find\` for file name/glob matching.
+2. Use \`grep\` for content search (supports regex).
+3. Use \`read\` to inspect matched files.
+
+> Use \`grep\` for content, \`find\` for filenames. Do not conflate them.
+
+### C: Edit — Modify files or directory layout
+
+**Tools:** ${editTools}
+
+1. Use \`edit\` for targeted single-file changes (exact text match → replace).
+2. Use \`search_and_replace\` for bulk changes across multiple files.
+3. Use \`mv\`, \`rm\`, \`mkdir\` for structural changes.
+
+> Confirm destructive operations (\`write\`, \`mv\`, \`rm\`, bulk replace) before executing.
+
+### D: Patch — Generate and apply unified diffs
+
+1. Generate: \`diff_files(original, modified)\`.
+2. Validate: \`apply_patch(patch, dryRun: true)\`.
+3. Apply: \`apply_patch(patch)\`.
+
+> Multi-file patches: set \`path\` to the base directory. Results are reported per file.
+`;
 }

package/dist/resources.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ResourceStore } from './lib/resource-store.js';
 import { type IconInfo } from './tools/shared.js';
 export declare function registerInstructionResource(server: McpServer, instructions: string, iconInfo?: IconInfo): void;

package/dist/resources.js

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

package/dist/schemas.d.ts

@@ -22,9 +22,9 @@ export declare const ListDirectoryInputSchema: z.ZodObject<{
     maxDepth: z.ZodOptional<z.ZodInt>;
     maxEntries: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
     sortBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        name: "name";
-        size: "size";
         type: "type";
+        size: "size";
+        name: "name";
         modified: "modified";
     }>>>;
     pattern: z.ZodOptional<z.ZodString>;
@@ -39,8 +39,8 @@ export declare const SearchFilesInputSchema: z.ZodObject<{
     includeIgnored: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     sortBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        name: "name";
         size: "size";
+        name: "name";
         path: "path";
         modified: "modified";
     }>>>;
@@ -208,18 +208,18 @@ export declare const ReadMultipleFilesOutputSchema: z.ZodObject<{
         }>>;
         error: z.ZodOptional<z.ZodObject<{
             code: z.ZodEnum<{
-                readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
-                readonly E_NOT_FOUND: "E_NOT_FOUND";
-                readonly E_NOT_FILE: "E_NOT_FILE";
-                readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
-                readonly E_TOO_LARGE: "E_TOO_LARGE";
-                readonly E_TIMEOUT: "E_TIMEOUT";
-                readonly E_CANCELLED: "E_CANCELLED";
-                readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
-                readonly E_INVALID_INPUT: "E_INVALID_INPUT";
-                readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
-                readonly E_SYMLINK_NOT_ALLOWED: "E_SYMLINK_NOT_ALLOWED";
-                readonly E_UNKNOWN: "E_UNKNOWN";
+                readonly ACCESS_DENIED: "ACCESS_DENIED";
+                readonly NOT_FOUND: "NOT_FOUND";
+                readonly NOT_FILE: "NOT_FILE";
+                readonly NOT_DIRECTORY: "NOT_DIRECTORY";
+                readonly TOO_LARGE: "TOO_LARGE";
+                readonly TIMEOUT: "TIMEOUT";
+                readonly CANCELLED: "CANCELLED";
+                readonly INVALID_PATTERN: "INVALID_PATTERN";
+                readonly INVALID_INPUT: "INVALID_INPUT";
+                readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+                readonly SYMLINK_NOT_ALLOWED: "SYMLINK_NOT_ALLOWED";
+                readonly UNKNOWN: "UNKNOWN";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodString>;
@@ -279,18 +279,18 @@ export declare const GetMultipleFileInfoOutputSchema: z.ZodObject<{
         }, z.core.$strict>>;
         error: z.ZodOptional<z.ZodObject<{
             code: z.ZodEnum<{
-                readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
-                readonly E_NOT_FOUND: "E_NOT_FOUND";
-                readonly E_NOT_FILE: "E_NOT_FILE";
-                readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
-                readonly E_TOO_LARGE: "E_TOO_LARGE";
-                readonly E_TIMEOUT: "E_TIMEOUT";
-                readonly E_CANCELLED: "E_CANCELLED";
-                readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
-                readonly E_INVALID_INPUT: "E_INVALID_INPUT";
-                readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
-                readonly E_SYMLINK_NOT_ALLOWED: "E_SYMLINK_NOT_ALLOWED";
-                readonly E_UNKNOWN: "E_UNKNOWN";
+                readonly ACCESS_DENIED: "ACCESS_DENIED";
+                readonly NOT_FOUND: "NOT_FOUND";
+                readonly NOT_FILE: "NOT_FILE";
+                readonly NOT_DIRECTORY: "NOT_DIRECTORY";
+                readonly TOO_LARGE: "TOO_LARGE";
+                readonly TIMEOUT: "TIMEOUT";
+                readonly CANCELLED: "CANCELLED";
+                readonly INVALID_PATTERN: "INVALID_PATTERN";
+                readonly INVALID_INPUT: "INVALID_INPUT";
+                readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+                readonly SYMLINK_NOT_ALLOWED: "SYMLINK_NOT_ALLOWED";
+                readonly UNKNOWN: "UNKNOWN";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodString>;
@@ -354,18 +354,18 @@ export declare const MoveFileOutputSchema: z.ZodObject<{
         source: z.ZodString;
         error: z.ZodObject<{
             code: z.ZodEnum<{
-                readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
-                readonly E_NOT_FOUND: "E_NOT_FOUND";
-                readonly E_NOT_FILE: "E_NOT_FILE";
-                readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
-                readonly E_TOO_LARGE: "E_TOO_LARGE";
-                readonly E_TIMEOUT: "E_TIMEOUT";
-                readonly E_CANCELLED: "E_CANCELLED";
-                readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
-                readonly E_INVALID_INPUT: "E_INVALID_INPUT";
-                readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
-                readonly E_SYMLINK_NOT_ALLOWED: "E_SYMLINK_NOT_ALLOWED";
-                readonly E_UNKNOWN: "E_UNKNOWN";
+                readonly ACCESS_DENIED: "ACCESS_DENIED";
+                readonly NOT_FOUND: "NOT_FOUND";
+                readonly NOT_FILE: "NOT_FILE";
+                readonly NOT_DIRECTORY: "NOT_DIRECTORY";
+                readonly TOO_LARGE: "TOO_LARGE";
+                readonly TIMEOUT: "TIMEOUT";
+                readonly CANCELLED: "CANCELLED";
+                readonly INVALID_PATTERN: "INVALID_PATTERN";
+                readonly INVALID_INPUT: "INVALID_INPUT";
+                readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+                readonly SYMLINK_NOT_ALLOWED: "SYMLINK_NOT_ALLOWED";
+                readonly UNKNOWN: "UNKNOWN";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodString>;
@@ -431,18 +431,18 @@ export declare const ApplyPatchOutputSchema: z.ZodObject<{
         linesRemoved: z.ZodOptional<z.ZodInt>;
         error: z.ZodOptional<z.ZodObject<{
             code: z.ZodEnum<{
-                readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
-                readonly E_NOT_FOUND: "E_NOT_FOUND";
-                readonly E_NOT_FILE: "E_NOT_FILE";
-                readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
-                readonly E_TOO_LARGE: "E_TOO_LARGE";
-                readonly E_TIMEOUT: "E_TIMEOUT";
-                readonly E_CANCELLED: "E_CANCELLED";
-                readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
-                readonly E_INVALID_INPUT: "E_INVALID_INPUT";
-                readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
-                readonly E_SYMLINK_NOT_ALLOWED: "E_SYMLINK_NOT_ALLOWED";
-                readonly E_UNKNOWN: "E_UNKNOWN";
+                readonly ACCESS_DENIED: "ACCESS_DENIED";
+                readonly NOT_FOUND: "NOT_FOUND";
+                readonly NOT_FILE: "NOT_FILE";
+                readonly NOT_DIRECTORY: "NOT_DIRECTORY";
+                readonly TOO_LARGE: "TOO_LARGE";
+                readonly TIMEOUT: "TIMEOUT";
+                readonly CANCELLED: "CANCELLED";
+                readonly INVALID_PATTERN: "INVALID_PATTERN";
+                readonly INVALID_INPUT: "INVALID_INPUT";
+                readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+                readonly SYMLINK_NOT_ALLOWED: "SYMLINK_NOT_ALLOWED";
+                readonly UNKNOWN: "UNKNOWN";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodString>;
@@ -458,9 +458,9 @@ export declare const SearchAndReplaceInputSchema: z.ZodObject<{
     isRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    includeHidden: z.ZodOptional<z.ZodBoolean>;
-    includeIgnored: z.ZodOptional<z.ZodBoolean>;
-    returnDiff: z.ZodOptional<z.ZodBoolean>;
+    includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeIgnored: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    returnDiff: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     maxFiles: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 export declare const SearchAndReplaceOutputSchema: z.ZodObject<{
@@ -473,18 +473,18 @@ export declare const SearchAndReplaceOutputSchema: z.ZodObject<{
         path: z.ZodString;
         error: z.ZodObject<{
             code: z.ZodEnum<{
-                readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
-                readonly E_NOT_FOUND: "E_NOT_FOUND";
-                readonly E_NOT_FILE: "E_NOT_FILE";
-                readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
-                readonly E_TOO_LARGE: "E_TOO_LARGE";
-                readonly E_TIMEOUT: "E_TIMEOUT";
-                readonly E_CANCELLED: "E_CANCELLED";
-                readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
-                readonly E_INVALID_INPUT: "E_INVALID_INPUT";
-                readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
-                readonly E_SYMLINK_NOT_ALLOWED: "E_SYMLINK_NOT_ALLOWED";
-                readonly E_UNKNOWN: "E_UNKNOWN";
+                readonly ACCESS_DENIED: "ACCESS_DENIED";
+                readonly NOT_FOUND: "NOT_FOUND";
+                readonly NOT_FILE: "NOT_FILE";
+                readonly NOT_DIRECTORY: "NOT_DIRECTORY";
+                readonly TOO_LARGE: "TOO_LARGE";
+                readonly TIMEOUT: "TIMEOUT";
+                readonly CANCELLED: "CANCELLED";
+                readonly INVALID_PATTERN: "INVALID_PATTERN";
+                readonly INVALID_INPUT: "INVALID_INPUT";
+                readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+                readonly SYMLINK_NOT_ALLOWED: "SYMLINK_NOT_ALLOWED";
+                readonly UNKNOWN: "UNKNOWN";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodString>;