@j0hanz/filesystem-mcp 1.13.1 → 1.14.0

package/dist/lib/file-operations/metadata.js

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_LIST_MAX_ENTRIES, DEFAULT_MAX_DEPTH, DEFAULT_READ_MANY_MAX_TOTAL_SIZE, DEFAULT_SEARCH_TIMEOUT_MS, getMimeType, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../constants.js';
 import { isAbortError } from '../errors.js';
 import { assertNotAborted, getFileType, isHidden, processInParallel, readFile, readFileWithStats, withAbort, withTimedAbortSignal, } from '../fs-helpers.js';
+import { assertSafeGlobPattern } from '../globs.js';
 import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, toPosixPath, validateExistingDirectory, validateExistingPath, validateExistingPathDetailed, } from '../paths.js';
 import { applyIndexedErrors, applyIndexedValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, withOptionalStoppedReason, } from './core.js';
 import { globEntries } from './traversal.js';
@@ -149,6 +150,7 @@ function normalizeListOptions(options) {
         timeoutMs: options.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
     };
     if (options.pattern && options.pattern.length > 0) {
+        assertSafeGlobPattern(options.pattern);
         normalized.pattern = options.pattern;
     }
     return normalized;
@@ -590,6 +592,7 @@ function buildReadOptions(options) {
     const readOptions = {
         encoding: options.encoding,
         maxSize: options.maxSize,
+        skipBinary: true,
     };
     applyLineSelection(readOptions, options);
     return readOptions;
@@ -653,10 +656,13 @@ function applyLineSelection(target, source) {
         target.head = source.head;
     if (source.tail !== undefined)
         target.tail = source.tail;
-    if (source.startLine !== undefined)
-        target.startLine = source.startLine;
-    if (source.endLine !== undefined)
+    if (source.endLine !== undefined) {
+        target.startLine = source.startLine ?? 1;
         target.endLine = source.endLine;
+    }
+    else if (source.startLine !== undefined) {
+        target.startLine = source.startLine;
+    }
 }
 function resolveNormalizedReadOptions(options) {
     const { signal, ...rest } = options;

package/dist/lib/file-operations/search.d.ts

@@ -1,21 +1,5 @@
-import * as fsp from 'node:fs/promises';
 import { z } from 'zod';
-import type { ContentMatch, SearchContentResult, SearchFilesResult } from '../../config.js';
-export declare const MatcherOptionsSchema: z.ZodObject<{
-    caseSensitive: z.ZodBoolean;
-    wholeWord: z.ZodBoolean;
-    isLiteral: z.ZodBoolean;
-    multiline: z.ZodBoolean;
-}, z.core.$strict>;
-export type MatcherOptions = z.infer<typeof MatcherOptionsSchema>;
-export type Matcher = (line: string) => number;
-export declare function validatePattern(pattern: string, options: MatcherOptions): void;
-export declare function buildMatcher(pattern: string, options: MatcherOptions): Matcher;
-export interface ScanFileOptions {
-    maxFileSize: number;
-    skipBinary: boolean;
-    contextLines: number;
-}
+import type { SearchContentResult, SearchFilesResult } from '../../config.js';
 declare const SearchOptionsSchema: z.ZodObject<{
     filePattern: z.ZodString;
     excludePatterns: z.ZodArray<z.ZodString>;
@@ -28,7 +12,6 @@ declare const SearchOptionsSchema: z.ZodObject<{
     contextLines: z.ZodInt;
     wholeWord: z.ZodBoolean;
     isLiteral: z.ZodBoolean;
-    multiline: z.ZodBoolean;
     includeHidden: z.ZodBoolean;
     baseNameMatch: z.ZodBoolean;
     caseSensitiveFileMatch: z.ZodBoolean;
@@ -41,40 +24,6 @@ export interface SearchContentOptions extends Partial<ResolvedOptions> {
         current: number;
     }) => void;
 }
-type BinaryDetector = (resolvedPath: string, handle: fsp.FileHandle, signal?: AbortSignal) => Promise<boolean>;
-export interface ScanRequest {
-    type: 'scan';
-    id: number;
-    resolvedPath: string;
-    requestedPath: string;
-    pattern: string;
-    matcherOptions: MatcherOptions;
-    scanOptions: ScanFileOptions;
-    maxMatches: number;
-}
-export interface ScanResult {
-    type: 'result';
-    id: number;
-    result: {
-        matches: readonly ContentMatch[];
-        matched: boolean;
-        skippedTooLarge: boolean;
-        skippedBinary: boolean;
-    };
-}
-export interface ScanError {
-    type: 'error';
-    id: number;
-    error: string;
-}
-export type WorkerResponse = ScanResult | ScanError;
-interface WorkerScanResult {
-    matches: readonly ContentMatch[];
-    matched: boolean;
-    skippedTooLarge: boolean;
-    skippedBinary: boolean;
-}
-export declare function scanFileInWorker(resolvedPath: string, requestedPath: string, matcher: Matcher, options: ScanFileOptions, maxMatches: number, isCancelled: () => boolean, isBinaryDetector: BinaryDetector): Promise<WorkerScanResult>;
 export declare function searchContent(basePath: string, pattern: string, options?: SearchContentOptions): Promise<SearchContentResult>;
 type SortBy = 'name' | 'size' | 'modified' | 'path';
 interface SearchFilesOptions {
@@ -93,12 +42,5 @@ interface SearchFilesOptions {
         current: number;
     }) => void;
 }
-interface Sortable {
-    name?: string;
-    size?: number;
-    modified?: Date;
-    path?: string;
-}
-export declare function sortSearchResults(results: Sortable[], sortBy: SortBy): void;
 export declare function searchFiles(basePath: string, pattern: string, excludePatterns?: readonly string[], options?: SearchFilesOptions): Promise<SearchFilesResult>;
 export {};

package/dist/lib/file-operations/search.js

@@ -68,12 +68,6 @@ import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, norm
 import { mergeOptions, omitOptionKeys, reportPeriodicProgress, } from '../utils.js';
 import { compareOptionalNumberDesc, compareStringValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, stableSortByDerivedString, withOptionalStoppedReason, } from './core.js';
 import { buildGlobOptions, globEntries } from './traversal.js';
-export const MatcherOptionsSchema = z.strictObject({
-    caseSensitive: z.boolean(),
-    wholeWord: z.boolean(),
-    isLiteral: z.boolean(),
-    multiline: z.boolean(),
-});
 function countRegexLineMatches(regex, line) {
     regex.lastIndex = 0;
     let count = 0;
@@ -91,7 +85,7 @@ function buildRegexPattern(pattern, options) {
     const escaped = options.isLiteral ? escapeLiteral(pattern) : pattern;
     return options.wholeWord ? `\\b${escaped}\\b` : escaped;
 }
-export function validatePattern(pattern, options) {
+function validatePattern(pattern, options) {
     if (options.isLiteral && pattern.length === 0)
         return;
     if (options.isLiteral && !options.wholeWord)
@@ -123,14 +117,12 @@ function buildLiteralMatcher(pattern, options) {
         return count;
     };
 }
-function buildRegexMatcher(final, caseSensitive, multiline) {
-    let flags = caseSensitive ? 'g' : 'gi';
-    if (multiline)
-        flags += 'm';
+function buildRegexMatcher(final, caseSensitive) {
+    const flags = caseSensitive ? 'g' : 'gi';
     const regex = new RE2(final, flags);
     return (line) => countRegexLineMatches(regex, line);
 }
-export function buildMatcher(pattern, options) {
+function buildMatcher(pattern, options) {
     if (options.isLiteral && pattern.length === 0)
         return () => 0;
     if (options.isLiteral && !options.wholeWord) {
@@ -139,7 +131,7 @@ export function buildMatcher(pattern, options) {
     }
     const final = buildRegexPattern(pattern, options);
     validatePattern(pattern, options); // Re-validate to be safe
-    return buildRegexMatcher(final, options.caseSensitive, options.multiline);
+    return buildRegexMatcher(final, options.caseSensitive);
 }
 // --- Configuration & Schemas ---
 const SEARCH_CONTENT_MAX_RESULTS = 500;
@@ -155,7 +147,6 @@ const SearchOptionsSchema = z.strictObject({
     contextLines: z.int().min(0),
     wholeWord: z.boolean(),
     isLiteral: z.boolean(),
-    multiline: z.boolean(),
     includeHidden: z.boolean(),
     baseNameMatch: z.boolean(),
     caseSensitiveFileMatch: z.boolean(),
@@ -172,7 +163,6 @@ const DEFAULTS = {
     contextLines: 0,
     wholeWord: false,
     isLiteral: true,
-    multiline: false,
     includeHidden: false,
     baseNameMatch: false,
     caseSensitiveFileMatch: true,
@@ -188,7 +178,7 @@ function resolveOptions(options) {
     const merged = mergeOptions(DEFAULTS, normalizedOptions);
     const result = SearchOptionsSchema.safeParse(merged);
     if (!result.success) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid search options: ${result.error.message}`, undefined, { errors: z.treeifyError(result.error) });
+        throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid search options:\n${z.prettifyError(result.error)}`, undefined, { errors: z.treeifyError(result.error) });
     }
     return result.data;
 }
@@ -376,7 +366,6 @@ function buildMatcherOptions(opts) {
         caseSensitive: opts.caseSensitive,
         wholeWord: opts.wholeWord,
         isLiteral: opts.isLiteral,
-        multiline: opts.multiline,
     };
 }
 function applyScanOutcome(summary, outcome) {
@@ -411,7 +400,6 @@ function buildSearchContentResult(root, pattern, filePattern, matches, summary)
         skippedTooLarge: summary.skippedTooLarge,
         skippedBinary: summary.skippedBinary,
         skippedInaccessible: summary.skippedInaccessible,
-        linesSkippedDueToRegexTimeout: 0,
     };
     return {
         basePath: root,
@@ -751,7 +739,7 @@ async function executeParallel(files, pattern, opts, signal, summary) {
     return matches;
 }
 // --- Entry Points ---
-export async function scanFileInWorker(resolvedPath, requestedPath, matcher, options, maxMatches, isCancelled, isBinaryDetector) {
+async function scanFileInWorker(resolvedPath, requestedPath, matcher, options, maxMatches, isCancelled, isBinaryDetector) {
     // Direct scan used by worker script
     const res = await scanFileResolved(resolvedPath, requestedPath, matcher, options, undefined, maxMatches, isBinaryDetector);
     return {
@@ -1051,7 +1039,7 @@ const SORT_COMPARATORS = {
     path: (a, b) => comparePathThenName(a, b),
     name: (a, b) => compareNameThenPath(a, b),
 };
-export function sortSearchResults(results, sortBy) {
+function sortSearchResults(results, sortBy) {
     if (sortBy === 'name') {
         stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
         return;
@@ -1086,8 +1074,7 @@ function getMatcherCacheKey(pattern, options) {
     const cs = options.caseSensitive ? '1' : '0';
     const ww = options.wholeWord ? '1' : '0';
     const lit = options.isLiteral ? '1' : '0';
-    const ml = options.multiline ? '1' : '0';
-    return `${pattern}|${cs}|${ww}|${lit}|${ml}`;
+    return `${pattern}|${cs}|${ww}|${lit}`;
 }
 function getCachedMatcher(pattern, options) {
     const key = getMatcherCacheKey(pattern, options);

package/dist/lib/file-operations/traversal.d.ts

@@ -6,7 +6,7 @@ interface GlobEntry {
     dirent: DirentLike;
     stats?: Stats;
 }
-export interface GlobEntriesOptions {
+interface GlobEntriesOptions {
     cwd: string;
     pattern: string;
     excludePatterns: readonly string[];
@@ -20,7 +20,7 @@ export interface GlobEntriesOptions {
     suppressErrors?: boolean;
 }
 export declare function globEntries(options: GlobEntriesOptions): AsyncGenerator<GlobEntry>;
-export interface GlobConfig {
+interface GlobConfig {
     cwd: string;
     pattern: string;
     excludePatterns?: readonly string[];

package/dist/lib/fs-helpers.d.ts

@@ -43,11 +43,10 @@ interface ReadFileResult {
     linesRead?: number;
     hasMoreLines?: boolean;
 }
-declare function headFile(handle: fsp.FileHandle, numLines: number, encoding?: BufferEncoding, maxBytesRead?: number, signal?: AbortSignal): Promise<string>;
 export declare function readFileWithStats(filePath: string, validPath: string, stats: Stats, options?: ReadFileOptions): Promise<ReadFileResult>;
 export declare function readFile(filePath: string, options?: ReadFileOptions): Promise<ReadFileResult>;
 export declare function atomicWriteFile(filePath: string, content: string, options?: {
     encoding?: BufferEncoding;
     signal?: AbortSignal | undefined;
 }): Promise<void>;
-export { headFile };
+export {};

package/dist/lib/fs-helpers.js

@@ -287,13 +287,11 @@ function validateReadOptions(options) {
     if (hasTail && (hasHead || hasStart || hasEnd)) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'tail cannot be used together with head/startLine/endLine');
     }
-    if (hasEnd && !hasStart) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'endLine requires startLine');
-    }
-    if (options.startLine !== undefined &&
-        options.endLine !== undefined &&
-        options.endLine < options.startLine) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'endLine must be greater than or equal to startLine');
+    {
+        const effectiveStart = options.startLine ?? 1;
+        if (options.endLine !== undefined && options.endLine < effectiveStart) {
+            throw new McpError(ErrorCode.E_INVALID_INPUT, 'endLine must be greater than or equal to startLine (default: 1)');
+        }
     }
 }
 function normalizeOptions(options) {
@@ -309,12 +307,13 @@ function normalizeOptions(options) {
     if (options.tail !== undefined) {
         normalized.tail = options.tail;
     }
-    if (options.startLine !== undefined) {
-        normalized.startLine = options.startLine;
-    }
     if (options.endLine !== undefined) {
+        normalized.startLine = options.startLine ?? 1;
         normalized.endLine = options.endLine;
     }
+    else if (options.startLine !== undefined) {
+        normalized.startLine = options.startLine;
+    }
     if (options.signal) {
         normalized.signal = options.signal;
     }
@@ -340,7 +339,7 @@ function resolveReadMode(options) {
         return 'head';
     if (options.tail !== undefined)
         return 'tail';
-    if (options.startLine !== undefined)
+    if (options.startLine !== undefined || options.endLine !== undefined)
         return 'range';
     return 'full';
 }
@@ -667,4 +666,3 @@ export async function atomicWriteFile(filePath, content, options = {}) {
         throw error;
     }
 }
-export { headFile };

package/dist/lib/globs.d.ts

@@ -0,0 +1,2 @@
+export declare function isSafeGlobPattern(value: string): boolean;
+export declare function assertSafeGlobPattern(value: string, message?: string): void;

package/dist/lib/globs.js

@@ -0,0 +1,19 @@
+import { ErrorCode, McpError } from './errors.js';
+const ABSOLUTE_GLOB_RE = /^([/\\]|[A-Za-z]:[/\\]|\\\\)/u;
+const PARENT_SEGMENT_RE = /[\\/]\.\.(?:[/\\]|$)/u;
+export function isSafeGlobPattern(value) {
+    if (value.length === 0)
+        return false;
+    if (value.includes('**/**/**'))
+        return false;
+    if (ABSOLUTE_GLOB_RE.test(value))
+        return false;
+    if (value.startsWith('..') || PARENT_SEGMENT_RE.test(value))
+        return false;
+    return true;
+}
+export function assertSafeGlobPattern(value, message = 'Invalid glob or unsafe path (absolute/.. forbidden)') {
+    if (!isSafeGlobPattern(value)) {
+        throw new McpError(ErrorCode.E_INVALID_PATTERN, message);
+    }
+}

package/dist/lib/paths.d.ts

@@ -1,5 +1,4 @@
 import type { Root } from '@modelcontextprotocol/sdk/types.js';
-import { McpError } from './errors.js';
 export declare function toPosixPath(value: string): string;
 export declare function isSensitivePath(requestedPath: string, resolvedPath?: string): boolean;
 export declare function assertAllowedFileAccess(requestedPath: string, resolvedPath?: string): void;
@@ -15,7 +14,6 @@ export interface AllowedDirectoriesState {
  */
 export declare function normalizePath(p: string): string;
 export declare function withAllowedDirectoriesState<T>(state: AllowedDirectoriesState, run: () => T): T;
-export declare function getAllowedDirectoriesState(): AllowedDirectoriesState;
 export declare function setAllowedDirectoriesStateResolved(state: AllowedDirectoriesState): void;
 export declare function getAllowedDirectories(): string[];
 export declare function isAllowedDirectoryRoot(normalizedPath: string): boolean;
@@ -24,7 +22,6 @@ export declare function resolveAllowedDirectoriesState(dirs: readonly string[],
 export declare function setAllowedDirectoriesResolved(dirs: readonly string[], signal?: AbortSignal): Promise<void>;
 export declare function getReservedDeviceNameForPath(requestedPath: string): string | undefined;
 export declare function isWindowsDriveRelativePath(requestedPath: string): boolean;
-export declare function toAccessDeniedWithHint(requestedPath: string, resolvedPath: string, normalizedResolved: string): McpError;
 interface ValidatedPathDetails {
     requestedPath: string;
     resolvedPath: string;

package/dist/lib/paths.js

@@ -252,9 +252,6 @@ function getActiveAllowedDirectoriesState() {
 export function withAllowedDirectoriesState(state, run) {
     return allowedDirectoriesContext.run(cloneAllowedDirectoriesState(state), run);
 }
-export function getAllowedDirectoriesState() {
-    return cloneAllowedDirectoriesState(getActiveAllowedDirectoriesState());
-}
 export function setAllowedDirectoriesStateResolved(state) {
     setAllowedDirectoriesState(state.primary, state.expanded);
 }
@@ -453,7 +450,7 @@ function toMcpError(requestedPath, error) {
     }
     return new McpError(ErrorCode.E_NOT_FOUND, `Path is not accessible: ${requestedPath}`, requestedPath, { originalCode: code, originalMessage }, error);
 }
-export function toAccessDeniedWithHint(requestedPath, resolvedPath, normalizedResolved) {
+function toAccessDeniedWithHint(requestedPath, resolvedPath, normalizedResolved) {
     const suggestion = buildAllowedDirectoriesHint();
     return new McpError(ErrorCode.E_ACCESS_DENIED, `Access denied: Path '${requestedPath}' is outside allowed directories.\n${suggestion}`, requestedPath, { resolvedPath, normalizedResolvedPath: normalizedResolved });
 }

package/dist/lib/utils.d.ts

@@ -5,15 +5,15 @@ export declare function debounce<Args extends unknown[]>(func: (...args: Args) =
 };
 export declare function mergeOptions<T extends object>(defaults: T, overrides: Partial<T>): T;
 export declare function omitOptionKeys<T extends object, K extends keyof T>(input: T, keys: readonly K[]): Omit<T, K>;
-export declare function setIfDefined<T extends object, K extends keyof T>(target: T, key: K, value: T[K] | undefined): void;
-export interface ProgressPayload {
+interface ProgressPayload {
     current: number;
     total?: number;
 }
-export type ProgressCallback = ((progress: ProgressPayload) => void) | undefined;
-export interface PeriodicProgressOptions {
+type ProgressCallback = ((progress: ProgressPayload) => void) | undefined;
+interface PeriodicProgressOptions {
     total?: number;
     throttleModulo?: number;
     force?: boolean;
 }
 export declare function reportPeriodicProgress(onProgress: ProgressCallback, current: number, options?: PeriodicProgressOptions): void;
+export {};

package/dist/lib/utils.js

@@ -14,11 +14,7 @@ export function debounce(func, waitMs) {
             func(...args);
         }, waitMs);
         // Unref if in Node environment to not block process exit
-        const nodeTimeout = timeoutId;
-        if (typeof nodeTimeout === 'object' &&
-            typeof nodeTimeout.unref === 'function') {
-            nodeTimeout.unref();
-        }
+        timeoutId.unref();
     };
     debounced.cancel = () => {
         if (timeoutId !== undefined) {
@@ -39,11 +35,6 @@ export function omitOptionKeys(input, keys) {
     }
     return output;
 }
-export function setIfDefined(target, key, value) {
-    if (value !== undefined) {
-        target[key] = value;
-    }
-}
 export function reportPeriodicProgress(onProgress, current, options = {}) {
     if (!onProgress || current === 0)
         return;

package/dist/lib/zod-codecs.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare function createBase64JsonCodec<Schema extends z.ZodType>(schema: Schema): z.ZodCodec<z.ZodString, Schema>;

package/dist/lib/zod-codecs.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export function createBase64JsonCodec(schema) {
+    return z.codec(z.string(), schema, {
+        decode: (value) => {
+            let parsed;
+            try {
+                parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf-8'));
+            }
+            catch (error) {
+                throw new Error('Invalid base64url-encoded JSON payload.', {
+                    cause: error,
+                });
+            }
+            return parsed;
+        },
+        encode: (value) => Buffer.from(JSON.stringify(value)).toString('base64url'),
+    });
+}

package/dist/pkg-info.d.ts

@@ -1,4 +1,5 @@
 export declare const pkgInfo: {
+    [x: string]: unknown;
     name: string;
     version: string;
     description?: string | undefined;

package/dist/pkg-info.js

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import packageJsonRaw from '../package.json' with { type: 'json' };
-const PkgInfoSchema = z.object({
+const PkgInfoSchema = z.looseObject({
     name: z.string(),
     version: z.string(),
     description: z.string().optional(),
-    homepage: z.string().optional(),
+    homepage: z.url().optional(),
 });
 export const pkgInfo = PkgInfoSchema.parse(packageJsonRaw);

package/dist/prompts.js

@@ -1,5 +1,5 @@
+import { ErrorCode as SdkErrorCode, McpError as SdkMcpError, } from '@modelcontextprotocol/sdk/types.js';
 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';
@@ -123,11 +123,11 @@ export function registerGetToolHelpPrompt(server, iconInfo) {
     }, ({ name }) => {
         const toolName = findKnownToolName(name);
         if (!toolName) {
-            throw new McpError(ErrorCode.E_INVALID_INPUT, `Unknown tool: ${name}`);
+            throw new SdkMcpError(SdkErrorCode.InvalidParams, `Unknown tool: ${name}`);
         }
         const toolInfo = buildToolInfo(toolName);
         if (!toolInfo) {
-            throw new McpError(ErrorCode.E_INVALID_INPUT, `Unknown tool: ${toolName}`);
+            throw new SdkMcpError(SdkErrorCode.InvalidParams, `Unknown tool: ${toolName}`);
         }
         return {
             description: GET_TOOL_HELP_PROMPT_DESCRIPTION,

package/dist/resources/generated-instructions.js

@@ -1,9 +1,6 @@
 import { buildToolCatalogDetailsOnly } from './tool-catalog.js';
-import { buildCoreContextPack, formatToolNameList, getSharedConstraints, getTaskCapableToolNames, getTaskToolNamesBySupport, getToolContracts, pickAvailableToolNames, } from './tool-info.js';
+import { buildCoreContextPack, formatToolNameList, getSharedConstraints, 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'])],
@@ -31,9 +28,6 @@ function buildToolsOverview() {
         .join('\n');
 }
 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>
@@ -54,12 +48,9 @@ ${buildToolsOverview()}
 </resources>
 
 <task_protocol>
-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\`.
+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-capable: ${taskCapable || 'none'}.
-${formatTaskModeLine('Optional task mode', optionalTaskTools)}
-${formatTaskModeLine('Required task mode', requiredTaskTools)}
 </task_protocol>
 `;
 }

package/dist/resources/tool-catalog.js

@@ -15,27 +15,13 @@ 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.
+- \`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
 
@@ -45,21 +31,10 @@ ${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.
+- 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.
 
 ## Task Mode Routing
 
@@ -75,12 +50,6 @@ ${buildCrossToolDataFlow()}
 
 ## Write Strategy
 
-- \`edit\`: precise first-occurrence replacements.
-- \`write\`: create files or overwrite full contents.
-- \`search_and_replace\`: bulk multi-file replacements.
-
-### edit vs write vs search_and_replace Decision
-
 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)
@@ -93,7 +62,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,7 +4,6 @@ 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;