@j0hanz/filesystem-mcp 1.9.1 → 1.10.0

package/dist/tools/read.js

@@ -1,4 +1,5 @@
 import * as path from 'node:path';
+import { createHash } from 'node:crypto';
 import { DEFAULT_SEARCH_TIMEOUT_MS, MAX_TEXT_FILE_SIZE, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { readFile } from '../lib/fs-helpers.js';
@@ -17,6 +18,7 @@ export const READ_FILE_TOOL = {
     nuances: [
         'Large content is externalized to `filesystem-mcp://result/{id}` and preview is returned inline.',
     ],
+    taskSupport: 'optional',
 };
 async function handleReadFile(args, signal, resourceStore) {
     const options = {
@@ -27,6 +29,9 @@ async function handleReadFile(args, signal, resourceStore) {
     if (args.head !== undefined) {
         options.head = args.head;
     }
+    if (args.tail !== undefined) {
+        options.tail = args.tail;
+    }
     if (args.startLine !== undefined) {
         options.startLine = args.startLine;
     }
@@ -46,11 +51,18 @@ async function handleReadFile(args, signal, resourceStore) {
             ? { totalLines: result.totalLines }
             : {}),
         ...(result.head !== undefined ? { head: result.head } : {}),
+        ...(result.tail !== undefined ? { tail: result.tail } : {}),
         ...(result.startLine !== undefined ? { startLine: result.startLine } : {}),
         ...(result.endLine !== undefined ? { endLine: result.endLine } : {}),
+        ...(result.linesRead !== undefined ? { linesRead: result.linesRead } : {}),
         ...(result.hasMoreLines ? { hasMoreLines: result.hasMoreLines } : {}),
     };
     const externalized = maybeExternalizeTextContent(resourceStore, result.content, { name: `read:${path.basename(args.path)}`, mimeType: 'text/plain' });
+    if (args.includeHash) {
+        structured.contentHash = createHash('sha256')
+            .update(result.content, 'utf-8')
+            .digest('hex');
+    }
     if (!externalized) {
         return buildToolResponse(result.content, structured);
     }
@@ -72,6 +84,7 @@ async function handleReadFile(args, signal, resourceStore) {
             name: entry.name,
             mimeType: entry.mimeType,
             description: 'Full file contents',
+            expiresAt: entry.expiresAt,
         }),
     ]);
 }
@@ -90,8 +103,12 @@ export function registerReadFileTool(server, options = {}) {
             const name = path.basename(args.path);
             if (args.startLine !== undefined) {
                 const end = args.endLine ?? '…';
-                return `🕮 read: ${name} [${args.startLine}-${end}]`;
+                return `🕮 read: ${name} [lines ${args.startLine}–${end}]`;
             }
+            if (args.head !== undefined)
+                return `🕮 read: ${name} [head ${args.head}]`;
+            if (args.tail !== undefined)
+                return `🕮 read: ${name} [tail ${args.tail}]`;
             return `🕮 read: ${name}`;
         },
         completionMessage: (args, result) => {
@@ -101,11 +118,26 @@ export function registerReadFileTool(server, options = {}) {
             const sc = result.structuredContent;
             if (!sc.ok)
                 return `🕮 read: ${name} • failed`;
-            if (sc.hasMoreLines)
-                return `🕮 read: ${name} • truncated [${sc.totalLines ?? '?'} lines]`;
-            if (sc.startLine !== undefined)
-                return `🕮 read: ${name} • lines ${sc.startLine}–${sc.endLine ?? '?'}`;
-            return `🕮 read: ${name} • ${sc.totalLines ?? '?'} lines`;
+            const lines = sc.linesRead ?? sc.totalLines;
+            if (sc.startLine !== undefined) {
+                const end = sc.linesRead
+                    ? sc.startLine + sc.linesRead - 1
+                    : (sc.endLine ?? '…');
+                return `🕮 read: ${name} • lines ${sc.startLine}–${end}`;
+            }
+            if (sc.head !== undefined) {
+                return sc.hasMoreLines
+                    ? `🕮 read: ${name} • first ${lines ?? sc.head} lines`
+                    : `🕮 read: ${name} • ${lines ?? sc.head} lines`;
+            }
+            if (sc.tail !== undefined) {
+                return sc.hasMoreLines
+                    ? `🕮 read: ${name} • last ${lines ?? sc.tail} lines`
+                    : `🕮 read: ${name} • ${lines ?? sc.tail} lines`;
+            }
+            if (sc.truncated)
+                return `🕮 read: ${name} • truncated [${String(lines)} lines]`;
+            return `🕮 read: ${name} • ${String(lines)} lines`;
         },
     });
     const validatedHandler = withValidatedArgs(ReadFileInputSchema, wrappedHandler);

package/dist/tools/replace-in-files.js

@@ -34,6 +34,7 @@ const MAX_FAILURES = 20;
 const REPLACE_CONCURRENCY = Math.min(PARALLEL_CONCURRENCY, 8);
 const MAX_CHANGED_FILES = 100;
 const MAX_DIFF_SIZE = 20 * 1024; // 20KB limit for diff output
+const DIFF_APPEND_BUFFER = 1024;
 function recordFailure(failures, failure) {
     if (failures.length >= MAX_FAILURES)
         return;
@@ -47,9 +48,10 @@ function recordChangedFile(summary, filePath, matchCount) {
     }
     summary.changedFilesTruncated = true;
 }
-function createRegexMatcher(pattern) {
+function createRegexMatcher(pattern, caseSensitive) {
+    const flags = caseSensitive ? 'g' : 'gi';
     try {
-        return new RE2(pattern, 'g');
+        return new RE2(pattern, flags);
     }
     catch (error) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
@@ -73,7 +75,12 @@ function createRegexReplacementMatcher(regex) {
     };
     return { count, replace };
 }
-function createLiteralReplacementMatcher(searchPattern) {
+function createLiteralReplacementMatcher(searchPattern, caseSensitive) {
+    if (!caseSensitive) {
+        const escaped = searchPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RE2(escaped, 'gi');
+        return createRegexReplacementMatcher(regex);
+    }
     const count = (content) => {
         let matchCount = 0;
         let pos = content.indexOf(searchPattern);
@@ -90,7 +97,8 @@ function createLiteralReplacementMatcher(searchPattern) {
 function formatFileTooLargeError(filePath, size, maxFileSize) {
     return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
 }
-async function processEntry(entryPath, options, replacement, matcher, maxFileSize, signal, summary) {
+async function processEntry(entryPath, context) {
+    const { options, replacement, matcher, maxFileSize, signal, summary } = context;
     let validPath;
     try {
         validPath = await validatePathForWrite(entryPath, signal);
@@ -123,14 +131,12 @@ async function processEntry(entryPath, options, replacement, matcher, maxFileSiz
             summary.filesChanged++;
             recordChangedFile(summary, validPath, matchCount);
             const newContent = matcher.replace(content, replacement);
-            if ((options.dryRun || options.returnDiff) &&
-                summary.diff.length < MAX_DIFF_SIZE) {
-                const patch = createTwoFilesPatch(path.basename(validPath), path.basename(validPath), content, newContent, 'Original', 'Modified');
-                // Only append if it won't exceed the limit too much
-                if (summary.diff.length + patch.length <= MAX_DIFF_SIZE + 1024) {
-                    summary.diff += patch;
-                }
-            }
+            maybeAppendPatchDiff(summary, {
+                filePath: validPath,
+                originalContent: content,
+                updatedContent: newContent,
+                includeDiff: options.dryRun || options.returnDiff,
+            });
             if (!options.dryRun) {
                 await atomicWriteFile(validPath, newContent, {
                     encoding: 'utf-8',
@@ -147,9 +153,27 @@ async function processEntry(entryPath, options, replacement, matcher, maxFileSiz
         });
     }
 }
+function maybeAppendPatchDiff(summary, params) {
+    if (!params.includeDiff)
+        return;
+    if (summary.diff.length >= MAX_DIFF_SIZE) {
+        summary.diffTruncated = true;
+        return;
+    }
+    const patch = createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified');
+    if (summary.diff.length + patch.length <=
+        MAX_DIFF_SIZE + DIFF_APPEND_BUFFER) {
+        summary.diff += patch;
+        return;
+    }
+    summary.diffTruncated = true;
+}
 async function processEntriesConcurrently(entries, options) {
     const pending = new Set();
-    const { signal, concurrency, onEntry, runEntry } = options;
+    const seen = new Set();
+    const { signal, concurrency, maxEntries, onEntry, runEntry } = options;
+    let dispatched = 0;
+    let stoppedByLimit = false;
     const waitForSlot = async () => {
         if (pending.size < concurrency)
             return;
@@ -158,8 +182,16 @@ async function processEntriesConcurrently(entries, options) {
     for await (const entry of entries) {
         if (signal?.aborted)
             break;
+        if (maxEntries !== undefined && dispatched >= maxEntries) {
+            stoppedByLimit = true;
+            break;
+        }
+        if (seen.has(entry.path))
+            continue;
+        seen.add(entry.path);
         await waitForSlot();
         onEntry();
+        dispatched++;
         const task = runEntry(entry.path);
         pending.add(task);
         void task.finally(() => {
@@ -169,6 +201,7 @@ async function processEntriesConcurrently(entries, options) {
     if (pending.size > 0) {
         await Promise.allSettled([...pending]);
     }
+    return { stoppedByLimit };
 }
 function createReplaceSummary(root) {
     return {
@@ -181,6 +214,7 @@ function createReplaceSummary(root) {
         changedFiles: [],
         changedFilesTruncated: false,
         diff: '',
+        diffTruncated: false,
     };
 }
 async function resolveSearchRoot(pathValue, signal) {
@@ -194,14 +228,14 @@ function createReplacementRegex(args) {
     if (!safeRegex(args.searchPattern)) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, `Unsafe regex pattern: ${args.searchPattern}`);
     }
-    return createRegexMatcher(args.searchPattern);
+    return createRegexMatcher(args.searchPattern, args.caseSensitive);
 }
 function createReplacementMatcher(args) {
     const regex = createReplacementRegex(args);
     if (regex) {
         return createRegexReplacementMatcher(regex);
     }
-    return createLiteralReplacementMatcher(args.searchPattern);
+    return createLiteralReplacementMatcher(args.searchPattern, args.caseSensitive);
 }
 export async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
     const maxFileSize = MAX_TEXT_FILE_SIZE;
@@ -220,9 +254,10 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
         suppressErrors: true,
     });
     const summary = createReplaceSummary(root);
-    await processEntriesConcurrently(entries, {
+    const { stoppedByLimit } = await processEntriesConcurrently(entries, {
         signal,
         concurrency: REPLACE_CONCURRENCY,
+        ...(args.maxFiles !== undefined ? { maxEntries: args.maxFiles } : {}),
         onEntry: () => {
             summary.processedFiles++;
             reportPeriodicProgress(onProgress, summary.processedFiles, {
@@ -230,10 +265,20 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
             });
         },
         runEntry: async (entryPath) => processEntry(entryPath, {
-            dryRun: args.dryRun,
-            returnDiff: args.returnDiff ?? false,
-        }, args.replacement, matcher, maxFileSize, signal, summary),
+            options: {
+                dryRun: args.dryRun,
+                returnDiff: args.returnDiff ?? false,
+            },
+            replacement: args.replacement,
+            matcher,
+            maxFileSize,
+            signal,
+            summary,
+        }),
     });
+    if (stoppedByLimit) {
+        summary.stoppedReason = 'maxFiles';
+    }
     reportPeriodicProgress(onProgress, summary.processedFiles, {
         throttleModulo: 25,
         force: true,
@@ -253,6 +298,10 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
         ...((args.dryRun || args.returnDiff) && summary.diff
             ? { diff: summary.diff }
             : {}),
+        ...(summary.diffTruncated ? { diffTruncated: true } : {}),
+        ...(summary.stoppedReason
+            ? { stoppedReason: summary.stoppedReason }
+            : {}),
         dryRun: args.dryRun,
     });
 }
@@ -265,12 +314,12 @@ export function registerSearchAndReplaceTool(server, options = {}) {
         run: async (signal) => {
             const dryLabel = args.dryRun ? ' [dry run]' : '';
             const context = `"${args.searchPattern}" in ${args.filePattern}${dryLabel}`;
-            const progress = createToolProgressSession(extra, `🛠 search_and_replace: ${context}`);
+            const progress = createToolProgressSession(extra, `🛠 replace: ${context}`);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🛠 search_and_replace: ${args.searchPattern} [${current} files processed]`,
+                    message: `🛠 replace: ${args.searchPattern} [${current} files]`,
                 });
             };
             try {
@@ -282,13 +331,11 @@ export function registerSearchAndReplaceTool(server, options = {}) {
                 let endSuffix = `${sc.matches ?? 0} ${matchWord} in ${sc.filesChanged ?? 0} ${fileWord}`;
                 if (sc.failedFiles)
                     endSuffix += `, ${sc.failedFiles} failed`;
-                if (sc.dryRun)
-                    endSuffix += ' [dry run]';
-                progress.complete(`🛠 search_and_replace: ${context} • ${endSuffix}`, finalCurrent);
+                progress.complete(`🛠 replace: ${context} • ${endSuffix}`, finalCurrent);
                 return result;
             }
             catch (error) {
-                progress.fail(`🛠 search_and_replace: ${context} • failed`);
+                progress.fail(`🛠 replace: ${context} • failed`);
                 throw error;
             }
         },

package/dist/tools/roots.js

@@ -12,6 +12,7 @@ export const LIST_ALLOWED_DIRECTORIES_TOOL = {
     outputSchema: ListAllowedDirectoriesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
     nuances: ['Returns absolute paths of all allowed directories.'],
+    taskSupport: 'optional',
 };
 function buildTextRoots(dirs) {
     if (dirs.length === 0) {

package/dist/tools/search-content.js

@@ -34,36 +34,62 @@ function assertValidRegexPattern(pattern) {
         throw new McpError(ErrorCode.E_INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
     }
 }
+function findColumnOffset(content, pattern, isRegex, caseSensitive) {
+    try {
+        if (isRegex) {
+            const flags = caseSensitive ? '' : 'i';
+            const regex = new RE2(pattern, flags);
+            const match = regex.exec(content);
+            return match ? match.index : undefined;
+        }
+        if (caseSensitive) {
+            const idx = content.indexOf(pattern);
+            return idx >= 0 ? idx : undefined;
+        }
+        const lowerContent = content.toLowerCase();
+        const lowerPattern = pattern.toLowerCase();
+        const idx = lowerContent.indexOf(lowerPattern);
+        return idx >= 0 ? idx : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function buildSearchTextResult(result, normalizedMatches) {
     const { summary } = result;
     if (normalizedMatches.length === 0)
         return 'No matches';
     let truncatedReason;
     if (summary.truncated) {
-        if (summary.stoppedReason === 'timeout') {
-            truncatedReason = 'timeout';
-        }
-        else if (summary.stoppedReason === 'maxFiles') {
-            truncatedReason = `max files (${summary.filesScanned})`;
-        }
-        else {
-            truncatedReason = `max results (${summary.matches})`;
-        }
+        truncatedReason = resolveTruncatedReason(summary);
     }
     const summaryOptions = {
         truncated: summary.truncated,
         ...(truncatedReason ? { truncatedReason } : {}),
     };
-    const lines = [`Found ${normalizedMatches.length}:`];
-    for (const match of normalizedMatches) {
+    return (buildMatchListText(`Found ${normalizedMatches.length}:`, normalizedMatches) + formatOperationSummary(summaryOptions));
+}
+function resolveTruncatedReason(summary) {
+    if (summary.stoppedReason === 'timeout')
+        return 'timeout';
+    if (summary.stoppedReason === 'maxFiles') {
+        return `max files (${summary.filesScanned})`;
+    }
+    return `max results (${summary.matches})`;
+}
+function buildMatchListText(heading, matches) {
+    const lines = [heading];
+    for (const match of matches) {
         lines.push(formatSearchMatchLine(match));
     }
-    return joinLines(lines) + formatOperationSummary(summaryOptions);
+    return joinLines(lines);
 }
-function buildSearchMatchPayload(match) {
+function buildSearchMatchPayload(match, context) {
+    const column = findColumnOffset(match.content, context.pattern, context.isRegex, context.caseSensitive);
     return {
         file: match.relativeFile,
         line: match.line,
+        ...(column !== undefined ? { column } : {}),
         content: match.content,
         matchCount: match.matchCount,
         ...(match.contextBefore ? { contextBefore: [...match.contextBefore] } : {}),
@@ -74,9 +100,9 @@ function formatSearchMatchLine(match) {
     const lineNum = String(match.line).padStart(4);
     return `  ${match.relativeFile}:${lineNum}: ${match.content}`;
 }
-function buildStructuredSearchResult(result, normalizedMatches, options) {
+function buildStructuredSearchResult(result, normalizedMatches, options, context) {
     const { summary } = result;
-    const matches = normalizedMatches.map((match) => buildSearchMatchPayload(match));
+    const matches = normalizedMatches.map((match) => buildSearchMatchPayload(match, context));
     return {
         ok: true,
         patternType: options.patternType,
@@ -141,6 +167,7 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
         contextLines: args.contextLines,
         maxResults: args.maxResults,
         isLiteral: !args.isRegex,
+        multiline: args.multiline,
     };
     if (signal) {
         options.signal = signal;
@@ -159,16 +186,21 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
         throw error;
     }
     const normalizedMatches = normalizeSearchMatches(result);
+    const searchContext = {
+        pattern: args.pattern,
+        isRegex: args.isRegex,
+        caseSensitive: args.caseSensitive,
+    };
     const structuredFull = buildStructuredSearchResult(result, normalizedMatches, {
         patternType,
         caseSensitive: args.caseSensitive,
-    });
+    }, searchContext);
     const needsExternalize = normalizedMatches.length > MAX_INLINE_MATCHES;
     if (!resourceStore || !needsExternalize) {
         return buildToolResponse(buildSearchTextResult(result, normalizedMatches), structuredFull);
     }
     const previewMatches = normalizedMatches.slice(0, MAX_INLINE_MATCHES);
-    const previewPayload = previewMatches.map((match) => buildSearchMatchPayload(match));
+    const previewPayload = previewMatches.map((match) => buildSearchMatchPayload(match, searchContext));
     const previewStructured = {
         ...structuredFull,
         matches: previewPayload,
@@ -181,19 +213,14 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
         text: JSON.stringify(structuredFull),
     });
     previewStructured.resourceUri = entry.uri;
-    const textLines = [
-        `Found ${normalizedMatches.length} (showing first ${MAX_INLINE_MATCHES}):`,
-    ];
-    for (const match of previewMatches) {
-        textLines.push(formatSearchMatchLine(match));
-    }
-    const text = joinLines(textLines);
+    const text = buildMatchListText(`Found ${normalizedMatches.length} (showing first ${MAX_INLINE_MATCHES}):`, previewMatches);
     return buildToolResponse(text, previewStructured, [
         buildResourceLink({
             uri: entry.uri,
             name: entry.name,
             mimeType: entry.mimeType,
             description: 'Full grep results as JSON (structuredContent)',
+            expiresAt: entry.expiresAt,
         }),
     ]);
 }
@@ -205,13 +232,12 @@ export function registerSearchContentTool(server, options = {}) {
         run: async (signal) => {
             const scope = args.filePattern;
             const { pattern } = args;
-            const progress = createToolProgressSession(extra, `🔎︎ grep: ${pattern} in ${scope}`);
+            const progress = createToolProgressSession(extra, `🔎︎ grep: ${pattern}`);
             const progressWithMessage = ({ current, total, }) => {
-                const fileWord = current === 1 ? 'file' : 'files';
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ grep: ${pattern} [${current} ${fileWord} scanned]`,
+                    message: `🔎︎ grep: ${pattern} [${current} files]`,
                 });
             };
             try {
@@ -220,37 +246,39 @@ export function registerSearchContentTool(server, options = {}) {
                 const count = sc.ok && sc.totalMatches ? sc.totalMatches : 0;
                 const filesMatched = sc.ok ? (sc.filesMatched ?? 0) : 0;
                 const stoppedReason = sc.ok ? sc.stoppedReason : undefined;
-                let suffix;
-                if (count === 0) {
-                    suffix = `No matches in ${scope}`;
-                }
-                else {
-                    const matchWord = count === 1 ? 'match' : 'matches';
-                    const fileInfo = filesMatched > 0
-                        ? ` in ${filesMatched} ${filesMatched === 1 ? 'file' : 'files'}`
-                        : '';
-                    suffix = `${count} ${matchWord}${fileInfo}`;
-                    if (stoppedReason === 'timeout') {
-                        suffix += ' [stopped — timeout]';
-                    }
-                    else if (stoppedReason === 'maxResults') {
-                        suffix += ' [truncated — max results]';
-                    }
-                    else if (stoppedReason === 'maxFiles') {
-                        suffix += ' [truncated — max files]';
-                    }
-                }
+                const suffix = buildCompletionSuffix({
+                    count,
+                    filesMatched,
+                    scope,
+                    stoppedReason,
+                });
                 const finalCurrent = resolveFinalProgressCurrent(progress, (sc.filesScanned ?? 0) + 1);
                 progress.complete(`🔎︎ grep: ${pattern} • ${suffix}`, finalCurrent);
                 return result;
             }
             catch (error) {
-                progress.fail(`🔎︎ grep: ${pattern} in ${scope} • failed`);
+                progress.fail(`🔎︎ grep: ${pattern} • failed`);
                 throw error;
             }
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path ?? '.'),
     });
+    function buildCompletionSuffix(params) {
+        if (params.count === 0) {
+            return `No matches in ${params.scope}`;
+        }
+        const matchWord = params.count === 1 ? 'match' : 'matches';
+        const fileWord = params.filesMatched === 1 ? 'file' : 'files';
+        const reasonLabels = {
+            timeout: 'timeout',
+            maxResults: 'max results',
+            maxFiles: 'max files',
+        };
+        const reasonSuffix = params.stoppedReason !== undefined
+            ? ` [${reasonLabels[params.stoppedReason]}]`
+            : '';
+        return `${params.count} ${matchWord} in ${params.filesMatched} ${fileWord}${reasonSuffix}`;
+    }
     const { isInitialized } = options;
     const wrappedHandler = wrapToolHandler(handler, {
         guard: isInitialized,

package/dist/tools/search-files.js

@@ -113,17 +113,16 @@ export function registerSearchFilesTool(server, options = {}) {
             let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
-                message: `🔎︎ find: ${context}`,
+                message: `🔎︎ find: ${pattern}`,
             });
             const baseReporter = createProgressReporter(extra);
             const progressWithMessage = ({ current, total, }) => {
                 if (current > progressCursor)
                     progressCursor = current;
-                const fileWord = current === 1 ? 'file' : 'files';
                 baseReporter({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ find: ${pattern} [${current} ${fileWord} scanned]`,
+                    message: `🔎︎ find: ${pattern} [${current} files]`,
                 });
             };
             try {
@@ -133,18 +132,18 @@ export function registerSearchFilesTool(server, options = {}) {
                 const stoppedReason = sc.ok ? sc.stoppedReason : undefined;
                 let suffix;
                 if (count === 0) {
-                    suffix = `No matches in ${scopeLabel}`;
+                    suffix = 'No matches';
                 }
                 else {
                     suffix = `${count} ${count === 1 ? 'match' : 'matches'}`;
                     if (stoppedReason === 'timeout') {
-                        suffix += ' [stopped — timeout]';
+                        suffix += ' [timeout]';
                     }
                     else if (stoppedReason === 'maxResults') {
-                        suffix += ' [truncated — max results]';
+                        suffix += ' [max results]';
                     }
                     else if (stoppedReason === 'maxFiles') {
-                        suffix += ' [truncated — max files]';
+                        suffix += ' [max files]';
                     }
                 }
                 const finalCurrent = Math.max((sc.filesScanned ?? 0) + 1, progressCursor + 1);

package/dist/tools/shared.d.ts

@@ -37,6 +37,7 @@ export declare function buildResourceLink(params: {
     name: string;
     mimeType?: string;
     description?: string;
+    expiresAt?: string;
 }): ContentBlock;
 export declare function buildToolResponse<T>(text: string, structuredContent: T, extraContent?: ContentBlock[]): {
     content: ContentBlock[];
@@ -128,7 +129,7 @@ export interface BatchProgressCallbacks {
     progress: ToolProgressSession;
     onItemComplete: () => void;
 }
-export declare function createToolProgressSession(extra: ToolExtra, startMessage: string): ToolProgressSession;
+export declare function createToolProgressSession(extra: ToolExtra, startMessage: string, initialTotal?: number): ToolProgressSession;
 export declare function createBatchProgressCallbacks(extra: ToolExtra, params: {
     toolLabel: string;
     context: string;