dominds 1.25.0 → 1.25.2

package/dist/tools/prompts/os/zh/tools.md

@@ -30,6 +30,12 @@
 - `scrollbackLines`（可选）：滚动回看里保留的最近输出行数
 - `timeoutSeconds`（可选）：超时秒数；超时后转为守护进程追踪
 
+**Windows 提示：**
+
+- 默认 `cmd.exe` 路径下，优先使用不带空格的正斜杠路径，如 `D:/path/to/file`
+- 复杂 PowerShell 命令建议显式传 `shell: 'powershell.exe'` 或 `shell: 'pwsh'`；系统会自动用编码方式传递命令，避免引号和反斜杠歧义
+- 不要依赖 `cmd /c "..."`
+
 **返回：**
 
 ```yaml

package/dist/tools/prompts/personal_memory/en/index.md

@@ -36,7 +36,7 @@ Key notes:
 - Personal memory is automatically isolated on disk under `.minds/memory/individual/<member-id>/...`.
 - Your `path` must NOT include your member id (do not write `<member-id>/...`).
 - If you have zero memory files yet, just call `add_personal_memory` — the directory will be created automatically.
-- If the content is a role's long-lived responsibilities/methods/examples, put it in `persona / knowhow / pitfalls` instead; if it should synchronize the team's current effective state, key decisions, next steps, or still-active blockers, use Taskdoc `progress`, the quasi-real-time task bulletin board; if it is only a personal/current-dialog short-term working set or continuation detail, use reminders instead.
+- If the content is a role's long-lived responsibilities/methods/examples, put it in `persona / knowhow / pitfalls` instead; if it should synchronize the team's current effective state, key decisions, next steps, or still-active blockers, use Taskdoc `progress`, the quasi-real-time task bulletin board; if it is only current-task/current-dialog short-term current work or continuation detail, use reminders instead.
 
 Tool list:
 

package/dist/tools/prompts/personal_memory/en/principles.md

@@ -73,7 +73,7 @@ The `personal_memory` toolset uses a **path key-value storage** model:
 - Boundary with skills: workspace-coupled facts, paths, local contracts, and responsibility-area indexes belong in `personal_memory`; workspace-independent operating methods, checklists, triggers, and boundaries belong in skills. If both appear in one experience, split them so skills do not hide repo facts that can go stale.
 - Do not store task progress or daily state here:
   - Information that must synchronize the team's current effective state, key decisions, next step, or still-active blockers belongs in Taskdoc `progress`, the quasi-real-time task bulletin board
-  - Personal or current-dialog short-term working set details belong in reminders
+  - Current-task or current-dialog short-term current-work details belong in reminders
 
 ### 3. Recommended Boundaries
 
@@ -81,7 +81,7 @@ The `personal_memory` toolset uses a **path key-value storage** model:
 - **A member’s own reusable long-lived experience and working index**: `personal_memory`
 - **Reusable operating guidance / checklists / triggers and boundaries**: `skills`
 - **Taskdoc `progress`**: the team-shared quasi-real-time task bulletin board for current effective state, key decisions, next steps, and still-active blockers
-- **reminders**: personal or current-dialog short-term working set, continuation package, and easy-to-lose volatile details
+- **reminders**: current-task or current-dialog short-term current work, continuation package, and easy-to-lose volatile details
 - **Team-shared long-lived conventions / invariants / consensus rules**: `team_memory`
 
 > Note: If the main purpose of the information is to let the team quickly synchronize on where things stand now, which decisions are in effect, what is next, or which blockers still hold, it belongs in Taskdoc `progress`, not in `personal_memory`.

package/dist/tools/prompts/personal_memory/zh/index.md

@@ -36,7 +36,7 @@ personal_memory 是 Dominds 的**个人记忆工具集**，用于管理智能体
 - 个人记忆会自动隔离到磁盘路径：`.minds/memory/individual/<member-id>/...`。
 - `path` 不应包含你的成员 id（不要写 `<member-id>/...`）。
 - 如果你还没有任何个人记忆条目，直接调用 `add_personal_memory` 即可：目录会由系统自动创建。
-- 如果你想写的是角色长期职责/方法/正反例，请改去 `persona / knowhow / pitfalls`；如果你想向全队同步当前有效状态、关键决策、下一步或仍成立阻塞，请改去 Taskdoc `progress` 这一准实时任务公告牌；如果只是个人/当前对话短期工作集与接续细节，请改去 reminders。
+- 如果你想写的是角色长期职责/方法/正反例，请改去 `persona / knowhow / pitfalls`；如果你想向全队同步当前有效状态、关键决策、下一步或仍成立阻塞，请改去 Taskdoc `progress` 这一准实时任务公告牌；如果只是当前任务/当前对话短期手头工作与接续细节，请改去 reminders。
 
 ## 快速导航
 

package/dist/tools/prompts/personal_memory/zh/principles.md

@@ -73,7 +73,7 @@ personal_memory 工具集采用**路径键值存储**模型：
 - 与 skills 的边界：工作区关联强的事实、路径、局部契约、职责域索引写进 `personal_memory`；独立于工作区内容的操作方法、检查清单、触发条件与边界写进 skill。若两者混在一起，请拆开维护，避免 skill 藏着容易过期的仓库事实。
 - 不要把任务进度/当天状态写进个人记忆：
   - 需要向全队同步的当前有效状态、关键决策、下一步与仍成立阻塞，用 Taskdoc `progress` 这一准实时任务公告牌
-  - 只供个人/当前对话短期持有的接续细节、临时 bridge 信息与工作集，用 reminders
+  - 只供当前任务/当前对话短期持有的接续细节、临时 bridge 信息与手头工作提示，用 reminders
 
 ### 3. 推荐边界
 
@@ -81,7 +81,7 @@ personal_memory 工具集采用**路径键值存储**模型：
 - **成员自己的长期可复用经验与个人工作索引**：`personal_memory`
 - **可复用操作指引 / 检查清单 / 触发条件与边界**：`skills`
 - **Taskdoc `progress`**：全队共享的准实时任务公告牌，承接当前有效状态、关键决策、下一步与仍成立阻塞
-- **reminders**：个人/当前对话短期工作集、接续包、容易丢的临时细节
+- **reminders**：当前任务/当前对话短期手头工作、接续包、容易丢的临时细节
 - **团队共享的长期约定 / 不变量 / 共识原则**：`team_memory`
 
 > 注：如果信息的主要目的，是让全队快速同步“现在到哪了、哪些决策已生效、下一步是什么、哪些阻塞仍成立”，它更适合进入 Taskdoc `progress` 这一准实时公告牌，而不是 `personal_memory`。

package/dist/tools/registry.d.ts

@@ -17,6 +17,12 @@ export type ToolsetMeta = {
      * system according to dialog scope rather than granted by team config.
      */
     assignable?: boolean;
+    /**
+     * Whether wildcard toolset expansion (`toolsets: ['*']`) may include this
+     * toolset. Defaults to true. Use false for explicitly grantable toolsets that
+     * should not be mass-assigned by wildcard baselines.
+     */
+    wildcardAssignable?: boolean;
     descriptionI18n?: I18nText;
     /**
      * Toolset-level prompt injected into the agent system prompt when the member

package/dist/tools/ripgrep.d.ts

@@ -1,6 +1,11 @@
 import type { FuncTool } from '../tool';
 export declare const ripgrepFilesTool: FuncTool;
+export declare const fsRipgrepFilesTool: FuncTool;
 export declare const ripgrepCountTool: FuncTool;
+export declare const fsRipgrepCountTool: FuncTool;
 export declare const ripgrepSnippetsTool: FuncTool;
+export declare const fsRipgrepSnippetsTool: FuncTool;
 export declare const ripgrepFixedTool: FuncTool;
+export declare const fsRipgrepFixedTool: FuncTool;
 export declare const ripgrepSearchTool: FuncTool;
+export declare const fsRipgrepSearchTool: FuncTool;

package/dist/tools/ripgrep.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ripgrepSearchTool = exports.ripgrepFixedTool = exports.ripgrepSnippetsTool = exports.ripgrepCountTool = exports.ripgrepFilesTool = void 0;
+exports.fsRipgrepSearchTool = exports.ripgrepSearchTool = exports.fsRipgrepFixedTool = exports.ripgrepFixedTool = exports.fsRipgrepSnippetsTool = exports.ripgrepSnippetsTool = exports.fsRipgrepCountTool = exports.ripgrepCountTool = exports.fsRipgrepFilesTool = exports.ripgrepFilesTool = void 0;
 /**
  * Module: tools/ripgrep
  *
@@ -629,6 +629,39 @@ function baseRgArgs(options, member) {
         globCompatibilityWarnings: filters.globCompatibilityWarnings,
     };
 }
+function fsBaseRgArgs(options) {
+    const args = ['--no-messages', '--color=never'];
+    if (options.includeHidden)
+        args.push('--hidden');
+    if (options.followSymlinks)
+        args.push('--follow');
+    if (options.caseMode === 'smart')
+        args.push('--smart-case');
+    if (options.caseMode === 'sensitive')
+        args.push('--case-sensitive');
+    if (options.caseMode === 'insensitive')
+        args.push('--ignore-case');
+    if (options.fixedStrings)
+        args.push('--fixed-strings');
+    const simple = process.platform === 'win32'
+        ? extractSimpleExtensionGlobs(options.globs)
+        : { typeArgs: [], extensionFilters: [], passthroughGlobs: options.globs };
+    args.push(...simple.typeArgs);
+    for (const glob of simple.passthroughGlobs) {
+        args.push('--glob', glob);
+    }
+    const globCompatibilityWarnings = process.platform === 'win32' && simple.passthroughGlobs.length > 0
+        ? [
+            'Some complex globs were passed through to rg --glob. On Windows, simple extension filters are translated to --type, but complex globs may still be affected by ripgrep glob/path compatibility.',
+        ]
+        : [];
+    return {
+        args,
+        postFilter: (relPath) => simple.extensionFilters.length === 0 ||
+            simple.extensionFilters.some((ext) => relPath.toLowerCase().endsWith(`.${ext}`)),
+        globCompatibilityWarnings,
+    };
+}
 function buildRipgrepDiagnostics(run, filterPlan, returnedMatches) {
     const diagnostics = [];
     if (run.partialPathFailure) {
@@ -980,6 +1013,95 @@ exports.ripgrepFilesTool = {
         return await runRipgrepFiles(caller, pattern, searchPath, options);
     },
 };
+async function runFsRipgrepFiles(pattern, searchPath, options) {
+    const filterPlan = fsBaseRgArgs(options);
+    const args = [
+        ...filterPlan.args,
+        '--files-with-matches',
+        '--',
+        pattern,
+        normalizeRipgrepSearchPath(searchPath),
+    ];
+    try {
+        let totalFiles = 0;
+        const results = [];
+        const run = await runRgLines(args, (line) => {
+            if (!filterPlan.postFilter(line))
+                return;
+            totalFiles++;
+            if (results.length < options.maxFiles)
+                results.push({ path: line });
+        });
+        const diagnostics = buildRipgrepDiagnostics(run, filterPlan, totalFiles > 0);
+        const truncated = totalFiles > options.maxFiles;
+        const summary = totalFiles === 0
+            ? formatRipgrepNoMatchesSummary(run.partialPathFailure)
+            : truncated
+                ? `Found ${totalFiles} files; showing first ${options.maxFiles} (truncated=true).${run.partialPathFailure ? ` ${RIPGREP_PARTIAL_PATH_FAILURE_SUMMARY}` : ''}`
+                : `Found ${totalFiles} files.${run.partialPathFailure ? ` ${RIPGREP_PARTIAL_PATH_FAILURE_SUMMARY}` : ''}`;
+        const yaml = [
+            `status: ${run.partialPathFailure ? 'partial_failure' : 'ok'}`,
+            `pattern: ${yamlQuote(pattern)}`,
+            `mode: fs_files`,
+            `path: ${yamlQuote(searchPath)}`,
+            ...(options.globs.length > 0 ? [`globs: ${yamlFlowStringArray(options.globs)}`] : []),
+            `case: ${options.caseMode}`,
+            `fixed_strings: ${options.fixedStrings}`,
+            `regex: ${!options.fixedStrings}`,
+            `truncated: ${truncated}`,
+            `limits:`,
+            `  max_files: ${options.maxFiles}`,
+            `totals:`,
+            `  files_matched: ${totalFiles}`,
+            `diagnostics:`,
+            `  partial_path_failure: ${run.partialPathFailure}`,
+            `  messages: ${yamlFlowStringArray(diagnostics)}`,
+            `summary: ${yamlQuote(summary)}`,
+            `results:`,
+            ...results.map((r) => `  - path: ${yamlQuote(r.path)}`),
+        ].join('\n');
+        return run.partialPathFailure ? (0, tool_1.toolPartialFailure)(formatYamlCodeBlock(yaml)) : okYaml(yaml);
+    }
+    catch (error) {
+        return failYaml([
+            `status: error`,
+            `pattern: ${yamlQuote(pattern)}`,
+            `mode: fs_files`,
+            `path: ${yamlQuote(searchPath)}`,
+            `error: FAILED`,
+            `summary: ${yamlQuote(error instanceof Error ? error.message : String(error))}`,
+        ].join('\n'));
+    }
+}
+exports.fsRipgrepFilesTool = {
+    type: 'func',
+    name: 'fs_ripgrep_files',
+    description: 'Search local filesystem file paths containing a pattern without restricting paths to rtws (rg-backed).',
+    descriptionI18n: {
+        en: 'Search local filesystem file paths containing a pattern without restricting paths to rtws (rg-backed).',
+        zh: '搜索本机文件系统中包含匹配内容的文件路径，不限制路径必须位于 rtws 内（rg 驱动）。',
+    },
+    parameters: exports.ripgrepFilesTool.parameters,
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const pattern = requireNonEmptyStringArg(args, 'pattern');
+        const searchPath = optionalStringArg(args, 'path') ?? '.';
+        const globs = parseRipgrepGlobsArg(args);
+        const caseMode = parseRipgrepCaseModeArg(args, 'smart');
+        const fixedStrings = optionalBooleanArg(args, 'fixed_strings') ?? false;
+        const includeHidden = optionalBooleanArg(args, 'include_hidden') ?? false;
+        const followSymlinks = optionalBooleanArg(args, 'follow_symlinks') ?? false;
+        const maxFiles = optionalPositiveIntegerArg(args, 'max_files') ?? 50;
+        return await runFsRipgrepFiles(pattern, searchPath, {
+            globs,
+            caseMode,
+            fixedStrings,
+            includeHidden,
+            followSymlinks,
+            maxFiles,
+        });
+    },
+};
 async function runRipgrepCount(caller, pattern, searchPath, options) {
     const forbiddenPath = detectForbiddenRipgrepSearchPath(caller, searchPath);
     if (forbiddenPath) {
@@ -1104,6 +1226,106 @@ exports.ripgrepCountTool = {
         return await runRipgrepCount(caller, pattern, searchPath, options);
     },
 };
+async function runFsRipgrepCount(pattern, searchPath, options) {
+    const filterPlan = fsBaseRgArgs(options);
+    const args = [
+        ...filterPlan.args,
+        '--count-matches',
+        '--',
+        pattern,
+        normalizeRipgrepSearchPath(searchPath),
+    ];
+    try {
+        let totalFiles = 0;
+        let totalMatches = 0;
+        const results = [];
+        const run = await runRgLines(args, (line) => {
+            const idx = line.lastIndexOf(':');
+            if (idx <= 0)
+                return;
+            const p = line.slice(0, idx);
+            if (!filterPlan.postFilter(p))
+                return;
+            const rawCount = line.slice(idx + 1);
+            const count = Number.parseInt(rawCount, 10);
+            if (!Number.isFinite(count))
+                return;
+            totalFiles++;
+            totalMatches += count;
+            if (results.length < options.maxFiles)
+                results.push({ path: p, count });
+        });
+        const diagnostics = buildRipgrepDiagnostics(run, filterPlan, totalMatches > 0);
+        const truncated = totalFiles > options.maxFiles;
+        const summary = totalMatches === 0
+            ? formatRipgrepNoMatchesSummary(run.partialPathFailure)
+            : truncated
+                ? `Counted ${totalMatches} matches in ${totalFiles} files; showing first ${options.maxFiles} files (truncated=true).${run.partialPathFailure ? ` ${RIPGREP_PARTIAL_PATH_FAILURE_SUMMARY}` : ''}`
+                : `Counted ${totalMatches} matches in ${totalFiles} files.${run.partialPathFailure ? ` ${RIPGREP_PARTIAL_PATH_FAILURE_SUMMARY}` : ''}`;
+        const yaml = [
+            `status: ${run.partialPathFailure ? 'partial_failure' : 'ok'}`,
+            `pattern: ${yamlQuote(pattern)}`,
+            `mode: fs_count`,
+            `path: ${yamlQuote(searchPath)}`,
+            ...(options.globs.length > 0 ? [`globs: ${yamlFlowStringArray(options.globs)}`] : []),
+            `case: ${options.caseMode}`,
+            `fixed_strings: ${options.fixedStrings}`,
+            `regex: ${!options.fixedStrings}`,
+            `truncated: ${truncated}`,
+            `limits:`,
+            `  max_files: ${options.maxFiles}`,
+            `totals:`,
+            `  files_matched: ${totalFiles}`,
+            `  matches: ${totalMatches}`,
+            `diagnostics:`,
+            `  partial_path_failure: ${run.partialPathFailure}`,
+            `  messages: ${yamlFlowStringArray(diagnostics)}`,
+            `summary: ${yamlQuote(summary)}`,
+            `results:`,
+            ...results.map((r) => `  - path: ${yamlQuote(r.path)}\n    count: ${r.count}`),
+        ].join('\n');
+        return run.partialPathFailure ? (0, tool_1.toolPartialFailure)(formatYamlCodeBlock(yaml)) : okYaml(yaml);
+    }
+    catch (error) {
+        return failYaml([
+            `status: error`,
+            `pattern: ${yamlQuote(pattern)}`,
+            `mode: fs_count`,
+            `path: ${yamlQuote(searchPath)}`,
+            `error: FAILED`,
+            `summary: ${yamlQuote(error instanceof Error ? error.message : String(error))}`,
+        ].join('\n'));
+    }
+}
+exports.fsRipgrepCountTool = {
+    type: 'func',
+    name: 'fs_ripgrep_count',
+    description: 'Count local filesystem matches per file without restricting paths to rtws (rg-backed).',
+    descriptionI18n: {
+        en: 'Count local filesystem matches per file without restricting paths to rtws (rg-backed).',
+        zh: '统计本机文件系统中每个文件的匹配数量，不限制路径必须位于 rtws 内（rg 驱动）。',
+    },
+    parameters: exports.ripgrepCountTool.parameters,
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const pattern = requireNonEmptyStringArg(args, 'pattern');
+        const searchPath = optionalStringArg(args, 'path') ?? '.';
+        const globs = parseRipgrepGlobsArg(args);
+        const caseMode = parseRipgrepCaseModeArg(args, 'smart');
+        const fixedStrings = optionalBooleanArg(args, 'fixed_strings') ?? false;
+        const includeHidden = optionalBooleanArg(args, 'include_hidden') ?? false;
+        const followSymlinks = optionalBooleanArg(args, 'follow_symlinks') ?? false;
+        const maxFiles = optionalPositiveIntegerArg(args, 'max_files') ?? 200;
+        return await runFsRipgrepCount(pattern, searchPath, {
+            globs,
+            caseMode,
+            fixedStrings,
+            includeHidden,
+            followSymlinks,
+            maxFiles,
+        });
+    },
+};
 async function runRipgrepSnippets(caller, pattern, searchPath, options) {
     const forbiddenPath = detectForbiddenRipgrepSearchPath(caller, searchPath);
     if (forbiddenPath) {
@@ -1237,6 +1459,113 @@ exports.ripgrepSnippetsTool = {
         return await runRipgrepSnippets(caller, pattern, searchPath, options);
     },
 };
+async function runFsRipgrepSnippets(pattern, searchPath, options) {
+    const filterPlan = fsBaseRgArgs(options);
+    const args = [
+        ...filterPlan.args,
+        '--vimgrep',
+        '--',
+        pattern,
+        normalizeRipgrepSearchPath(searchPath),
+    ];
+    try {
+        let totalMatches = 0;
+        const fileSet = new Set();
+        const results = [];
+        const fileCache = new Map();
+        const run = await runRgLines(args, async (line) => {
+            const first = line.indexOf(':');
+            if (first <= 0)
+                return;
+            const second = line.indexOf(':', first + 1);
+            if (second <= first)
+                return;
+            const third = line.indexOf(':', second + 1);
+            if (third <= second)
+                return;
+            const filePath = line.slice(0, first);
+            const lineStr = line.slice(first + 1, second);
+            const colStr = line.slice(second + 1, third);
+            const text = line.slice(third + 1);
+            const ln = Number.parseInt(lineStr, 10);
+            const col = Number.parseInt(colStr, 10);
+            if (!Number.isFinite(ln) || !Number.isFinite(col))
+                return;
+            if (!filterPlan.postFilter(filePath))
+                return;
+            totalMatches++;
+            fileSet.add(filePath);
+            if (results.length >= options.maxResults)
+                return;
+            let lines = fileCache.get(filePath);
+            if (!lines) {
+                lines = await loadFileLines(filePath).catch(() => []);
+                fileCache.set(filePath, lines);
+            }
+            const idx0 = ln - 1;
+            const before = lines.slice(Math.max(0, idx0 - options.contextBefore), idx0);
+            const after = lines.slice(idx0 + 1, idx0 + 1 + options.contextAfter);
+            results.push({ path: filePath, line: ln, col, match: text, before, after });
+        });
+        const diagnostics = buildRipgrepDiagnostics(run, filterPlan, totalMatches > 0);
+        return formatRipgrepSnippetYaml({
+            pattern,
+            searchPath,
+            globs: options.globs,
+            caseMode: options.caseMode,
+            fixedStrings: options.fixedStrings,
+            maxResults: options.maxResults,
+            fileCount: fileSet.size,
+            totalMatches,
+            partialPathFailure: run.partialPathFailure,
+            diagnostics,
+            results,
+        });
+    }
+    catch (error) {
+        return failYaml([
+            `status: error`,
+            `pattern: ${yamlQuote(pattern)}`,
+            `mode: fs_snippets`,
+            `path: ${yamlQuote(searchPath)}`,
+            `error: FAILED`,
+            `summary: ${yamlQuote(error instanceof Error ? error.message : String(error))}`,
+        ].join('\n'));
+    }
+}
+exports.fsRipgrepSnippetsTool = {
+    type: 'func',
+    name: 'fs_ripgrep_snippets',
+    description: 'Search local filesystem snippets with line/col without restricting paths to rtws (rg-backed).',
+    descriptionI18n: {
+        en: 'Search local filesystem snippets with line/col without restricting paths to rtws (rg-backed).',
+        zh: '搜索本机文件系统并显示带行列的匹配片段，不限制路径必须位于 rtws 内（rg 驱动）。',
+    },
+    parameters: exports.ripgrepSnippetsTool.parameters,
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const pattern = requireNonEmptyStringArg(args, 'pattern');
+        const searchPath = optionalStringArg(args, 'path') ?? '.';
+        const globs = parseRipgrepGlobsArg(args);
+        const caseMode = parseRipgrepCaseModeArg(args, 'smart');
+        const fixedStrings = optionalBooleanArg(args, 'fixed_strings') ?? false;
+        const includeHidden = optionalBooleanArg(args, 'include_hidden') ?? false;
+        const followSymlinks = optionalBooleanArg(args, 'follow_symlinks') ?? false;
+        const maxResults = optionalPositiveIntegerArg(args, 'max_results') ?? 50;
+        const contextBefore = optionalNonNegativeIntegerArg(args, 'context_before') ?? 1;
+        const contextAfter = optionalNonNegativeIntegerArg(args, 'context_after') ?? 1;
+        return await runFsRipgrepSnippets(pattern, searchPath, {
+            globs,
+            caseMode,
+            fixedStrings,
+            includeHidden,
+            followSymlinks,
+            maxResults,
+            contextBefore,
+            contextAfter,
+        });
+    },
+};
 exports.ripgrepFixedTool = {
     type: 'func',
     name: 'ripgrep_fixed',
@@ -1300,6 +1629,53 @@ exports.ripgrepFixedTool = {
         return await runRipgrepSnippets(caller, literal, searchPath, options);
     },
 };
+exports.fsRipgrepFixedTool = {
+    type: 'func',
+    name: 'fs_ripgrep_fixed',
+    description: 'Fixed-string ripgrep convenience tool for local filesystem search without restricting paths to rtws.',
+    descriptionI18n: {
+        en: 'Fixed-string ripgrep convenience tool for local filesystem search without restricting paths to rtws.',
+        zh: '本机文件系统固定字符串 ripgrep 便捷工具，不限制路径必须位于 rtws 内。',
+    },
+    parameters: exports.ripgrepFixedTool.parameters,
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const literal = requireNonEmptyStringArg(args, 'literal');
+        const searchPath = optionalStringArg(args, 'path') ?? '.';
+        const modeRaw = optionalStringArg(args, 'mode') ?? 'snippets';
+        if (modeRaw !== 'files' && modeRaw !== 'snippets' && modeRaw !== 'count') {
+            throw new Error("Invalid arguments: `mode` must be one of: 'files', 'snippets', 'count'");
+        }
+        const globs = parseRipgrepGlobsArg(args);
+        const caseMode = parseRipgrepCaseModeArg(args, 'smart');
+        const includeHidden = optionalBooleanArg(args, 'include_hidden') ?? false;
+        const followSymlinks = optionalBooleanArg(args, 'follow_symlinks') ?? false;
+        const base = {
+            globs,
+            caseMode,
+            fixedStrings: true,
+            includeHidden,
+            followSymlinks,
+        };
+        if (modeRaw === 'files') {
+            const maxFiles = optionalPositiveIntegerArg(args, 'max_files') ?? 50;
+            return await runFsRipgrepFiles(literal, searchPath, { ...base, maxFiles });
+        }
+        if (modeRaw === 'count') {
+            const maxFiles = optionalPositiveIntegerArg(args, 'max_files') ?? 200;
+            return await runFsRipgrepCount(literal, searchPath, { ...base, maxFiles });
+        }
+        const maxResults = optionalPositiveIntegerArg(args, 'max_results') ?? 50;
+        const contextBefore = optionalNonNegativeIntegerArg(args, 'context_before') ?? 1;
+        const contextAfter = optionalNonNegativeIntegerArg(args, 'context_after') ?? 1;
+        return await runFsRipgrepSnippets(literal, searchPath, {
+            ...base,
+            maxResults,
+            contextBefore,
+            contextAfter,
+        });
+    },
+};
 const DISALLOWED_RG_ARGS = new Set(['--pre', '--pre-glob']);
 async function runRipgrepSearch(caller, pattern, searchPath, rawRgArgs) {
     const forbiddenPath = detectForbiddenRipgrepSearchPath(caller, searchPath);
@@ -1423,3 +1799,108 @@ exports.ripgrepSearchTool = {
         return await runRipgrepSearch(caller, pattern, searchPath, rgArgs);
     },
 };
+async function runFsRipgrepSearch(pattern, searchPath, rawRgArgs) {
+    for (const tok of rawRgArgs) {
+        if (DISALLOWED_RG_ARGS.has(tok)) {
+            return failYaml(`status: error\nerror: DISALLOWED_ARG\nsummary: ${yamlQuote(`Disallowed rg arg: ${tok}`)}`);
+        }
+        if (tok === '--json' ||
+            tok === '--count' ||
+            tok === '--count-matches' ||
+            tok === '--files-with-matches' ||
+            tok === '--files') {
+            return failYaml(`status: error\nerror: DISALLOWED_ARG\nsummary: ${yamlQuote(`Disallowed rg output arg: ${tok}`)}`);
+        }
+    }
+    const options = {
+        ...defaultBaseOptions(),
+        fixedStrings: false,
+        maxResults: 50,
+        contextBefore: 1,
+        contextAfter: 1,
+    };
+    const filterPlan = fsBaseRgArgs(options);
+    const rawArgsPlan = buildRawRipgrepArgsPlan(rawRgArgs);
+    const rgArgs = [
+        ...filterPlan.args,
+        ...rawArgsPlan.args,
+        '--vimgrep',
+        '--',
+        pattern,
+        normalizeRipgrepSearchPath(searchPath),
+    ];
+    try {
+        let totalMatches = 0;
+        const fileSet = new Set();
+        const results = [];
+        const run = await runRgLines(rgArgs, (line) => {
+            const first = line.indexOf(':');
+            if (first <= 0)
+                return;
+            const secondColon = line.indexOf(':', first + 1);
+            if (secondColon <= first)
+                return;
+            const thirdColon = line.indexOf(':', secondColon + 1);
+            if (thirdColon <= secondColon)
+                return;
+            const filePath = line.slice(0, first);
+            const lineStr = line.slice(first + 1, secondColon);
+            const colStr = line.slice(secondColon + 1, thirdColon);
+            const text = line.slice(thirdColon + 1);
+            const ln = Number.parseInt(lineStr, 10);
+            const col = Number.parseInt(colStr, 10);
+            if (!Number.isFinite(ln) || !Number.isFinite(col))
+                return;
+            if (!rawArgsPlan.postFilter(filePath))
+                return;
+            totalMatches++;
+            fileSet.add(filePath);
+            if (results.length < options.maxResults)
+                results.push({ path: filePath, line: ln, col, match: text });
+        });
+        const diagnostics = [
+            ...buildRipgrepDiagnostics(run, filterPlan, totalMatches > 0),
+            ...rawArgsPlan.globCompatibilityWarnings,
+        ];
+        return formatRipgrepSnippetYaml({
+            pattern,
+            searchPath,
+            globs: [],
+            caseMode: 'smart',
+            fixedStrings: false,
+            maxResults: options.maxResults,
+            fileCount: fileSet.size,
+            totalMatches,
+            partialPathFailure: run.partialPathFailure,
+            diagnostics,
+            results,
+        });
+    }
+    catch (error) {
+        return failYaml([
+            `status: error`,
+            `pattern: ${yamlQuote(pattern)}`,
+            `mode: fs_snippets`,
+            `path: ${yamlQuote(searchPath)}`,
+            `error: FAILED`,
+            `summary: ${yamlQuote(error instanceof Error ? error.message : String(error))}`,
+        ].join('\n'));
+    }
+}
+exports.fsRipgrepSearchTool = {
+    type: 'func',
+    name: 'fs_ripgrep_search',
+    description: 'Escape hatch: run rg-style local filesystem search without restricting paths to rtws. Output is normalized to YAML snippets mode.',
+    descriptionI18n: {
+        en: 'Escape hatch: run rg-style local filesystem search without restricting paths to rtws. Output is normalized to YAML snippets mode.',
+        zh: '逃生舱：运行本机文件系统 rg 风格搜索，不限制路径必须位于 rtws 内。输出归一为 YAML snippets 模式。',
+    },
+    parameters: exports.ripgrepSearchTool.parameters,
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const pattern = requireNonEmptyStringArg(args, 'pattern');
+        const searchPath = optionalStringArg(args, 'path') ?? '.';
+        const rgArgs = optionalStringArrayArg(args, 'rg_args') ?? [];
+        return await runFsRipgrepSearch(pattern, searchPath, rgArgs);
+    },
+};