@j0hanz/filesystem-mcp 1.6.1 → 1.7.0

package/README.md

@@ -474,10 +474,14 @@ Replace text in all files matching a glob. Replaces **all** occurrences per file
 
 ### Resources
 
-| URI                            | Description                        | MIME Type       |
-| :----------------------------- | :--------------------------------- | :-------------- |
-| `internal://instructions`      | Usage guidance for models          | `text/markdown` |
-| `filesystem-mcp://result/{id}` | Ephemeral cached large tool output | varies          |
+| URI                            | Description                         | MIME Type          |
+| :----------------------------- | :---------------------------------- | :----------------- |
+| `internal://instructions`      | Usage guidance for models           | `text/markdown`    |
+| `internal://tool-catalog`      | Tool routing and data-flow guide    | `text/markdown`    |
+| `internal://workflows`         | Explore/search/edit/patch workflows | `text/markdown`    |
+| `internal://tool-info/{name}`  | Per-tool nuances and gotchas        | `text/markdown`    |
+| `filesystem-mcp://metrics`     | Live per-tool metrics snapshot      | `application/json` |
+| `filesystem-mcp://result/{id}` | Ephemeral cached large tool output  | varies             |
 
 When a tool response includes a `resource_link`/`resourceUri`, treat it as authoritative for full payload retrieval and call `resources/read` with that URI.
 
@@ -565,7 +569,7 @@ Set `FS_CONTEXT_STRIP_STRUCTURED=1` to strip `structuredContent` from tool resul
 - **Input limits**: Paths are bounded to 4,096 characters; patterns to 1,000 characters.
 - **Atomic writes**: File writes use an atomic write-then-rename strategy to prevent partial writes.
 - **Docker**: The container runs as a non-root user (`mcp`).
-- **HTTP host binding**: The HTTP transport binds to `127.0.0.1` by default. Setting `FILESYSTEM_MCP_HTTP_HOST=0.0.0.0` binds to all network interfaces and exposes the server externally — only do this behind a trusted reverse proxy with `FILESYSTEM_MCP_AUTH_TOKEN` configured.
+- **HTTP host binding**: The HTTP transport binds to `127.0.0.1` by default. Setting `FILESYSTEM_MCP_HTTP_HOST=0.0.0.0` binds to all network interfaces and exposes the server externally — only do this behind a trusted reverse proxy with `FILESYSTEM_MCP_API_KEY` configured.
 
 > [!IMPORTANT]
 > All diagnostic output goes to `stderr`. Tool handlers must never write to `stdout`, as doing so would corrupt the stdio transport.
@@ -580,18 +584,16 @@ npm ci
 
 ### Scripts
 
-| Script          | Command                                                   | Purpose                             |
-| :-------------- | :-------------------------------------------------------- | :---------------------------------- |
-| `dev`           | `tsc --watch`                                             | Watch-mode TypeScript compilation   |
-| `dev:run`       | `node --watch dist/index.js`                              | Run built server with file watching |
-| `build`         | `node scripts/tasks.mjs build`                            | Production build                    |
-| `test`          | `node scripts/tasks.mjs test`                             | Run full test suite                 |
-| `test:fast`     | `node --test --import tsx/esm src/__tests__/**/*.test.ts` | Fast test runner (no build step)    |
-| `test:coverage` | `node scripts/tasks.mjs test --coverage`                  | Test with coverage                  |
-| `lint`          | `eslint .`                                                | Lint source files                   |
-| `lint:fix`      | `eslint . --fix`                                          | Auto-fix lint issues                |
-| `format`        | `prettier --write .`                                      | Format all files                    |
-| `type-check`    | `node scripts/tasks.mjs type-check`                       | TypeScript type checking            |
+| Script       | Command                             | Purpose                             |
+| :----------- | :---------------------------------- | :---------------------------------- |
+| `dev`        | `tsc --watch`                       | Watch-mode TypeScript compilation   |
+| `dev:run`    | `node --watch dist/index.js`        | Run built server with file watching |
+| `build`      | `node scripts/tasks.mjs build`      | Production build                    |
+| `test`       | `node scripts/tasks.mjs test`       | Run full test suite                 |
+| `lint`       | `eslint .`                          | Lint source files                   |
+| `lint:fix`   | `eslint . --fix`                    | Auto-fix lint issues                |
+| `format`     | `prettier --write .`                | Format all files                    |
+| `type-check` | `node scripts/tasks.mjs type-check` | TypeScript type checking            |
 
 ### MCP Inspector
 

package/dist/lib/errors.js

@@ -125,15 +125,16 @@ function walkErrorChain(error, visitor) {
     let current = error;
     const visited = new Set();
     while (current !== undefined && current !== null && !visited.has(current)) {
-        if (visitor(current))
-            return true;
+        const visitedResult = visitor(current);
+        if (visitedResult !== undefined)
+            return visitedResult;
         if (!isNativeError(current))
             break;
         visited.add(current);
         const next = current.cause;
         current = next;
     }
-    return false;
+    return undefined;
 }
 function isAbortErrorSingle(error) {
     if (!isNativeError(error))
@@ -144,7 +145,7 @@ function isAbortErrorSingle(error) {
     return code === 'ABORT_ERR';
 }
 export function isAbortError(error) {
-    return walkErrorChain(error, isAbortErrorSingle);
+    return (walkErrorChain(error, (candidate) => isAbortErrorSingle(candidate) ? true : undefined) === true);
 }
 function isTimeoutErrorSingle(error) {
     if (!isNativeError(error))
@@ -158,7 +159,7 @@ function isTimeoutErrorSingle(error) {
     return message.includes('timed out') || message.includes('timeout');
 }
 export function isTimeoutLikeError(error) {
-    return walkErrorChain(error, isTimeoutErrorSingle);
+    return (walkErrorChain(error, (candidate) => isTimeoutErrorSingle(candidate) ? true : undefined) === true);
 }
 export class McpError extends Error {
     code;
@@ -224,17 +225,20 @@ function classifyMessageError(error) {
     return undefined;
 }
 function classifyError(error) {
-    if (isAbortError(error)) {
-        return ErrorCode.E_CANCELLED;
-    }
-    if (isTimeoutLikeError(error)) {
-        return ErrorCode.E_TIMEOUT;
-    }
-    const direct = getDirectErrorCode(error);
-    if (direct)
-        return direct;
-    const messageCode = classifyMessageError(error);
-    return messageCode ?? ErrorCode.E_UNKNOWN;
+    let timeoutCode;
+    let fallbackCode;
+    const terminalCode = walkErrorChain(error, (candidate) => {
+        if (isAbortErrorSingle(candidate)) {
+            return ErrorCode.E_CANCELLED;
+        }
+        if (timeoutCode === undefined && isTimeoutErrorSingle(candidate)) {
+            timeoutCode = ErrorCode.E_TIMEOUT;
+        }
+        fallbackCode ??=
+            getDirectErrorCode(candidate) ?? classifyMessageError(candidate);
+        return undefined;
+    });
+    return terminalCode ?? timeoutCode ?? fallbackCode ?? ErrorCode.E_UNKNOWN;
 }
 export function createDetailedError(error, path, additionalDetails) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/lib/file-operations/glob-engine.js

@@ -106,40 +106,57 @@ function buildHiddenPatterns(normalizedPattern, maxDepth) {
 function shouldUseGlobDirents(options) {
     return !options.stats && !options.followSymbolicLinks;
 }
-function assertOptionsShape(options) {
-    const unknownOptions = options;
-    if (unknownOptions === null || typeof unknownOptions !== 'object') {
-        throw new TypeError('globEntries: options must be an object');
-    }
-    const o = unknownOptions;
-    if (typeof o.cwd !== 'string') {
-        throw new TypeError('globEntries: options.cwd must be a string');
+function assertOptionString(options, key) {
+    if (typeof options[key] !== 'string') {
+        throw new TypeError(`globEntries: options.${key} must be a string`);
     }
-    if (typeof o.pattern !== 'string') {
-        throw new TypeError('globEntries: options.pattern must be a string');
-    }
-    if (!Array.isArray(o.excludePatterns)) {
+}
+function assertExcludePatternsOption(options) {
+    if (!Array.isArray(options.excludePatterns)) {
         throw new TypeError('globEntries: options.excludePatterns must be an array');
     }
-    for (const p of o.excludePatterns) {
-        if (typeof p !== 'string') {
+    for (const pattern of options.excludePatterns) {
+        if (typeof pattern !== 'string') {
             throw new TypeError('globEntries: options.excludePatterns must contain only strings');
         }
     }
+}
+function assertBooleanOptions(options) {
     for (const key of GLOB_BOOLEAN_OPTION_KEYS) {
-        if (typeof o[key] !== 'boolean') {
+        if (typeof options[key] !== 'boolean') {
             throw new TypeError(`globEntries: options.${key} must be a boolean`);
         }
     }
-    if (o.maxDepth !== undefined) {
-        if (typeof o.maxDepth !== 'number' || !Number.isFinite(o.maxDepth)) {
-            throw new TypeError('globEntries: options.maxDepth must be a finite number');
-        }
+}
+function assertOptionalMaxDepth(options) {
+    const { maxDepth } = options;
+    if (maxDepth === undefined)
+        return;
+    if (typeof maxDepth !== 'number' || !Number.isFinite(maxDepth)) {
+        throw new TypeError('globEntries: options.maxDepth must be a finite number');
     }
-    if (o.suppressErrors !== undefined && typeof o.suppressErrors !== 'boolean') {
+}
+function assertOptionalSuppressErrors(options) {
+    const { suppressErrors } = options;
+    if (suppressErrors === undefined)
+        return;
+    if (typeof suppressErrors !== 'boolean') {
         throw new TypeError('globEntries: options.suppressErrors must be a boolean');
     }
 }
+function assertOptionsShape(options) {
+    const unknownOptions = options;
+    if (unknownOptions === null || typeof unknownOptions !== 'object') {
+        throw new TypeError('globEntries: options must be an object');
+    }
+    const o = unknownOptions;
+    assertOptionString(o, 'cwd');
+    assertOptionString(o, 'pattern');
+    assertExcludePatternsOption(o);
+    assertBooleanOptions(o);
+    assertOptionalMaxDepth(o);
+    assertOptionalSuppressErrors(o);
+}
 function normalizeOptions(options) {
     const cwd = path.resolve(options.cwd);
     const normalizedPattern = normalizePattern(options.pattern, options.baseNameMatch);

package/dist/lib/fs-helpers.js

@@ -120,23 +120,22 @@ function createParallelAbortError() {
     return createAbortError();
 }
 export async function processInParallel(items, processor, concurrency = PARALLEL_CONCURRENCY, signal) {
-    if (items.length === 0)
+    const itemCount = items.length;
+    if (itemCount === 0)
         return { results: [], errors: [] };
     const effectiveConcurrency = normalizeConcurrency(concurrency);
     // Pre-allocate slots by index to guarantee input-order output.
-    const resultSlots = new Array(items.length);
+    const resultSlots = new Array(itemCount);
     const errors = [];
     if (signal?.aborted)
         throw createParallelAbortError();
     let nextIndex = 0;
     const next = async () => {
-        while (nextIndex < items.length) {
+        while (nextIndex < itemCount) {
             if (signal?.aborted)
                 throw createParallelAbortError();
-            const index = nextIndex++;
-            // Check again because another worker might have incremented past length
-            if (index >= items.length)
-                break;
+            const index = nextIndex;
+            nextIndex += 1;
             const item = items[index];
             try {
                 const result = await processor(item);
@@ -154,7 +153,7 @@ export async function processInParallel(items, processor, concurrency = PARALLEL
             }
         }
     };
-    const workerCount = Math.min(items.length, effectiveConcurrency);
+    const workerCount = Math.min(itemCount, effectiveConcurrency);
     const workers = new Array(workerCount);
     for (let index = 0; index < workerCount; index += 1) {
         workers[index] = next();

package/dist/lib/path-policy.js

@@ -36,45 +36,61 @@ function compilePatterns(patterns) {
         const normalized = normalizeForMatch(pattern);
         const matchesPath = normalized.includes('/');
         compiled.push({
-            raw: normalized,
             globs: matchesPath ? compilePatternGlobs(normalized) : [normalized],
             matchesPath,
         });
     }
     return compiled;
 }
-const DENY_PATTERNS = compilePatterns(SENSITIVE_FILE_DENYLIST);
-const ALLOW_PATTERNS = compilePatterns(SENSITIVE_FILE_ALLOWLIST);
+function toPatternSet(patterns) {
+    const pathGlobs = new Set();
+    const nameGlobs = new Set();
+    for (const pattern of patterns) {
+        const target = pattern.matchesPath ? pathGlobs : nameGlobs;
+        for (const glob of pattern.globs) {
+            target.add(glob);
+        }
+    }
+    return {
+        pathGlobs: [...pathGlobs],
+        nameGlobs: [...nameGlobs],
+    };
+}
+const DENY_PATTERNS = toPatternSet(compilePatterns(SENSITIVE_FILE_DENYLIST));
+const ALLOW_PATTERNS = toPatternSet(compilePatterns(SENSITIVE_FILE_ALLOWLIST));
 function uniquePair(primary, secondary) {
     if (!secondary || secondary === primary)
         return [primary];
     return [primary, secondary];
 }
-function matchesAny(patterns, pathCandidates, nameCandidates) {
-    for (const pattern of patterns) {
-        const candidates = pattern.matchesPath ? pathCandidates : nameCandidates;
-        for (const candidate of candidates) {
-            for (const glob of pattern.globs) {
-                if (path.posix.matchesGlob(candidate, glob))
-                    return true;
-            }
+function matchesAnyGlobs(globs, candidates) {
+    if (globs.length === 0 || candidates.length === 0)
+        return false;
+    for (const candidate of candidates) {
+        for (const glob of globs) {
+            if (path.posix.matchesGlob(candidate, glob))
+                return true;
         }
     }
     return false;
 }
 export function isSensitivePath(requestedPath, resolvedPath) {
-    if (DENY_PATTERNS.length === 0)
+    if (DENY_PATTERNS.pathGlobs.length === 0 &&
+        DENY_PATTERNS.nameGlobs.length === 0) {
         return false;
+    }
     const normalizedRequested = normalizeForMatch(requestedPath);
     const normalizedResolved = resolvedPath
         ? normalizeForMatch(resolvedPath)
         : undefined;
     const pathCandidates = uniquePair(normalizedRequested, normalizedResolved);
     const nameCandidates = uniquePair(path.posix.basename(normalizedRequested), normalizedResolved ? path.posix.basename(normalizedResolved) : undefined);
-    if (matchesAny(ALLOW_PATTERNS, pathCandidates, nameCandidates)) {
+    if (matchesAnyGlobs(ALLOW_PATTERNS.pathGlobs, pathCandidates) ||
+        matchesAnyGlobs(ALLOW_PATTERNS.nameGlobs, nameCandidates)) {
         return false;
     }
-    return matchesAny(DENY_PATTERNS, pathCandidates, nameCandidates);
+    return (matchesAnyGlobs(DENY_PATTERNS.pathGlobs, pathCandidates) ||
+        matchesAnyGlobs(DENY_PATTERNS.nameGlobs, nameCandidates));
 }
 export function assertAllowedFileAccess(requestedPath, resolvedPath) {
     if (!isSensitivePath(requestedPath, resolvedPath))

package/dist/prompts.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { withDefaultIcons } from './tools/shared.js';
 const HELP_PROMPT_NAME = 'get-help';
 const HELP_PROMPT_TITLE = 'Get Help';
-const HELP_PROMPT_DESCRIPTION = 'Return the filesystem-mcp usage instructions.';
+const HELP_PROMPT_DESCRIPTION = 'Retrieve the full filesystem-mcp XML usage guide.';
 function filterInstructionsByTopic(instructions, topic) {
     const normalized = topic.trim().toLowerCase();
     if (!normalized)

package/dist/resources/generated-instructions.js

@@ -1,46 +1,48 @@
 import { buildToolCatalogDetailsOnly } from './tool-catalog.js';
 import { buildCoreContextPack, getSharedConstraints, getToolContracts, } from './tool-info.js';
 import { buildWorkflowGuide } from './workflows.js';
-const INSTRUCTIONS_HEADER = `# FILESYSTEM-MCP
-
-Operate ONLY within allowed roots. Always discover before acting — never guess paths.
-
-## TOOLS
+const INSTRUCTIONS_HEADER = `<role>
+Expert filesystem agent. Operate ONLY within allowed roots. Always discover before acting — never guess paths.
+</role>
 
+<tools_overview>
 | Category | Tools |
 |----------|-------|
 | Navigate | \`roots\`, \`ls\`, \`tree\`, \`find\` |
 | Inspect  | \`stat\`, \`stat_many\`, \`grep\`, \`calculate_hash\` |
 | Read     | \`read\`, \`read_many\`, \`diff_files\` |
 | Write    | \`mkdir\`, \`write\`, \`edit\`, \`mv\`, \`rm\`, \`apply_patch\`, \`search_and_replace\` |
+</tools_overview>
 
-## RESOURCES
-
-- \`filesystem-mcp://result/{id}\`: Large output is cached here. **If a response includes \`resourceUri\`, call \`resources/read\` immediately — results expire on process restart.**
-- \`filesystem-mcp://metrics\`: Live per-tool call/error stats.
-
-## TASK PROTOCOL
+<resources>
+- \`internal://instructions\`: Full server usage guide.
+- \`internal://tool-catalog\`: Tool routing and cross-tool data-flow guide.
+- \`internal://workflows\`: Standard operating sequences (explore/search/edit/patch).
+- \`internal://tool-info/{name}\`: Per-tool details (nuances/gotchas), e.g. \`internal://tool-info/read\`.
+- \`filesystem-mcp://result/{id}\`: Large output cache. Call \`resources/read\` immediately if \`resourceUri\` is returned.
+- \`filesystem-mcp://metrics\`: Live per-tool stats.
+</resources>
 
-Long-running tools support async execution: provide \`_meta.progressToken\` in \`tools/call\`, poll \`tasks/get\`, then call \`tasks/result\`.
+<task_protocol>
+Async execution: provide \`_meta.progressToken\` in \`tools/call\`, poll \`tasks/get\`, call \`tasks/result\`.
 Task-capable: \`find\`, \`tree\`, \`read\`, \`read_many\`, \`stat_many\`, \`grep\`, \`mkdir\`, \`write\`, \`mv\`, \`rm\`, \`calculate_hash\`, \`apply_patch\`, \`search_and_replace\`.
-
+</task_protocol>
 `;
-const INSTRUCTIONS_FOOTER = `
-## CONSTRAINTS
-
+const INSTRUCTIONS_FOOTER = `<constraints>
 ${getSharedConstraints()
     .map((c) => `- ${c}`)
     .join('\n')}
+</constraints>
 
-## ERROR HANDLING
-
+<error_handling>
 - \`E_ACCESS_DENIED\` → Call \`roots\`; use allowed path.
 - \`E_NOT_FOUND\`     → Call \`ls\`/\`find\`; verify spelling.
 - \`E_TOO_LARGE\`     → Use range/head or \`read_many\`.
 - \`E_TIMEOUT\`       → Reduce scope or result limits.
+</error_handling>
 `;
 function formatToolSection(tool) {
-    const parts = [`${tool.name}: ${tool.description}`];
+    const parts = [`### ${tool.name}\n${tool.description}`];
     if (tool.nuances && tool.nuances.length > 0) {
         parts.push(...tool.nuances.map((n) => `» ${n}`));
     }
@@ -57,13 +59,12 @@ export function buildServerInstructions() {
         '',
         buildToolCatalogDetailsOnly(),
         '',
-        '## TOOL REFERENCE',
-        '',
+        '<tool_reference>',
         toolSections,
+        '</tool_reference>',
         '',
         buildWorkflowGuide(),
         '',
-        '---',
         INSTRUCTIONS_FOOTER,
     ].join('\n');
 }

package/dist/resources/tool-catalog.js

@@ -1,6 +1,5 @@
 import { buildCoreContextPack } from './tool-info.js';
-const CATALOG_GUIDE = `## Tool Selection Guide
-
+const CATALOG_GUIDE = `<tool_selection_guide>
 ## Cross-Tool Data Flow
 
 \`\`\`
@@ -25,6 +24,7 @@ diff_files (patch text) -> apply_patch.patch
 - Always generate a patch with \`diff_files\` first.
 - Always use \`dryRun: true\` with \`apply_patch\` to verify changes.
 - \`apply_patch\` works on unified diff format.
+</tool_selection_guide>
 `;
 export function buildToolCatalog() {
     return `${buildCoreContextPack()}\n\n${CATALOG_GUIDE}`;

package/dist/resources/tool-info.js

@@ -33,7 +33,7 @@ export function buildCoreContextPack() {
         const annotations = e.annotations ? ` ${e.annotations.join(' ')}` : '';
         return `| \`${e.name}\` | ${e.description}${annotations} |`;
     });
-    return `## Core Context Pack\n\n| Tool | Purpose |\n|------|---------|\n${rows.join('\n')}`;
+    return `<core_context>\n| Tool | Purpose |\n|------|---------|\n${rows.join('\n')}\n</core_context>`;
 }
 export function getSharedConstraints() {
     return [

package/dist/resources/workflows.js

@@ -1,6 +1,5 @@
 export function buildWorkflowGuide() {
-    return `## Workflow Reference
-
+    return `<workflows>
 ### A: EXPLORE
 Use when: navigating an unfamiliar directory or reading file content.
 1. \`roots\` (List allowed paths).
@@ -30,5 +29,5 @@ Use when: applying structured diffs produced by \`diff_files\`.
 2. \`apply_patch\` (dryRun: true).
 3. \`apply_patch\` (dryRun: false).
    > **Tip:** Pass \`diff_files\` output directly into \`apply_patch\`.
-`;
+</workflows>`;
 }

package/dist/resources.js

@@ -21,7 +21,7 @@ const TOOL_INFO_RESOURCE_NAME = 'filesystem-mcp-tool-info';
 const TOOL_INFO_RESOURCE_DESCRIPTION = 'Per-tool contract details, nuances, and gotchas. Read internal://tool-info/{name} with a tool name such as "read", "ls", or "grep".';
 const INSTRUCTIONS_RESOURCE_NAME = 'filesystem-mcp-instructions';
 const INSTRUCTIONS_RESOURCE_URI = 'internal://instructions';
-const INSTRUCTIONS_RESOURCE_DESCRIPTION = 'Guidance for using the filesystem-mcp MCP tools effectively.';
+const INSTRUCTIONS_RESOURCE_DESCRIPTION = 'Comprehensive rules and guidelines for filesystem-mcp usage.';
 const RESULT_RESOURCE_NAME = 'filesystem-mcp-result';
 const RESULT_RESOURCE_DESCRIPTION = 'Ephemeral cached tool output exposed as an MCP resource. Not guaranteed to be listed via resources/list.';
 const METRICS_RESOURCE_NAME = 'filesystem-mcp-metrics';
@@ -29,10 +29,10 @@ const METRICS_RESOURCE_URI = 'filesystem-mcp://metrics';
 const METRICS_RESOURCE_DESCRIPTION = 'Live per-tool call/error/avgDurationMs metrics snapshot.';
 const CATALOG_RESOURCE_NAME = 'filesystem-mcp-catalog';
 const CATALOG_RESOURCE_URI = 'internal://tool-catalog';
-const CATALOG_RESOURCE_DESCRIPTION = 'Detailed catalog of tools and their inter-dependencies.';
+const CATALOG_RESOURCE_DESCRIPTION = 'Tool selection guide and data flow map.';
 const WORKFLOW_RESOURCE_NAME = 'filesystem-mcp-workflows';
 const WORKFLOW_RESOURCE_URI = 'internal://workflows';
-const WORKFLOW_RESOURCE_DESCRIPTION = 'Recommended workflows for common tasks.';
+const WORKFLOW_RESOURCE_DESCRIPTION = 'Standard operating procedures for exploration, search, edit, and patch.';
 export function registerInstructionResource(server, instructions, iconInfo) {
     server.registerResource(INSTRUCTIONS_RESOURCE_NAME, INSTRUCTIONS_RESOURCE_URI, withDefaultIcons({
         title: 'Server Instructions',

package/dist/server/bootstrap.js

@@ -59,9 +59,7 @@ export async function createServer(options = {}) {
         }),
     };
     if (taskToolSupport) {
-        // Note: InMemoryTaskStore has no TTL — tasks accumulate for the process
-        // lifetime. In HTTP mode this may grow unboundedly for long-lived servers.
-        // Use a custom TaskStore with eviction for production HTTP deployments.
+        // Enabling task tool support requires configuring a task store and message queue on the server config. We use in-memory implementations which are suitable for short-lived stdio sessions. Long-running HTTP servers should replace these with TTL-evicting implementations to avoid unbounded memory growth.
         serverConfig.taskStore = new InMemoryTaskStore();
         serverConfig.taskMessageQueue = new InMemoryTaskMessageQueue();
     }
@@ -171,9 +169,6 @@ async function createHttpSession(options, sessions) {
             sessions.set(sessionId, { server: mcpServer, transport });
             rootsManager.logMissingDirectoriesIfNeeded(mcpServer);
         },
-        onsessionclosed: (sessionId) => {
-            sessions.delete(sessionId);
-        },
     });
     transport.onclose = () => {
         const { sessionId } = transport;

package/dist/server/capabilities.js

@@ -5,13 +5,16 @@ function detectTaskToolSupport() {
         return cachedTaskToolSupport;
     }
     try {
+        // Instantiate a minimal, unconnected probe server to duck-type check for
+        // task tool support. The probe has no transport or active connections, so
+        // close() only releases in-memory state; fire-and-forget is safe here.
         const probe = new McpServer({
             name: 'filesystem-mcp-capability-probe',
             version: '0.0.0',
         }, { capabilities: { tools: {} } });
         cachedTaskToolSupport =
             typeof probe.experimental.tasks.registerToolTask === 'function';
-        void probe.close().catch(() => { });
+        probe.close().catch(() => { });
     }
     catch {
         cachedTaskToolSupport = false;

package/dist/server/roots-manager.d.ts

@@ -5,6 +5,8 @@ export declare class RootsManager {
     private rootsUpdateTimeout;
     private rootDirectories;
     private clientInitialized;
+    private updatingRoots;
+    private pendingRootsUpdate;
     private readonly options;
     readonly loggingState: LoggingState;
     constructor(options: ServerOptions, loggingState: LoggingState);

package/dist/server/roots-manager.js

@@ -84,6 +84,10 @@ export class RootsManager {
     rootsUpdateTimeout;
     rootDirectories = [];
     clientInitialized = false;
+    // Set to true when an update is in progress, to prevent concurrent executions. If a change arrives while true, we queue a single retry after completion to ensure the last-known state is applied. This
+    updatingRoots = false;
+    // If an update is in progress and a change arrives, we set this flag to ensure we run another update after completion to apply the latest state
+    pendingRootsUpdate = false;
     options;
     loggingState;
     constructor(options, loggingState) {
@@ -151,23 +155,37 @@ export class RootsManager {
         logToMcp(server, 'warning', 'No allowed directories specified. Please provide directories as command-line arguments or enable --allow-cwd to use the current working directory.', this.loggingState.minimumLevel);
     }
     async updateRootsFromClient(server) {
+        // Guard against concurrent executions: if one is already running, queue a
+        // single retry so the last-known state is always applied after completion.
+        if (this.updatingRoots) {
+            this.pendingRootsUpdate = true;
+            return;
+        }
+        this.updatingRoots = true;
         try {
             const clientCapabilities = server.server.getClientCapabilities();
             if (!clientCapabilities?.roots) {
                 this.rootDirectories = [];
-                return;
             }
-            const rootsResult = await server.server.listRoots(undefined, {
-                timeout: ROOTS_TIMEOUT_MS,
-            });
-            const roots = extractRoots(rootsResult);
-            this.rootDirectories = await resolveRootDirectories(roots);
+            else {
+                const rootsResult = await server.server.listRoots(undefined, {
+                    timeout: ROOTS_TIMEOUT_MS,
+                });
+                const roots = extractRoots(rootsResult);
+                this.rootDirectories = await resolveRootDirectories(roots);
+            }
         }
         catch (error) {
             logToMcp(server, 'debug', `[DEBUG] MCP Roots protocol unavailable or failed: ${formatUnknownErrorMessage(error)}`, this.loggingState.minimumLevel);
         }
         finally {
             await this.recomputeAllowedDirectories();
+            this.updatingRoots = false;
+            // If a change arrived while we were running, apply it now.
+            if (this.pendingRootsUpdate) {
+                this.pendingRootsUpdate = false;
+                void this.updateRootsFromClient(server);
+            }
         }
     }
 }