mocode-ai 1.6.5 → 1.6.7

package/dist/tools/builtins/glob.js

@@ -1,6 +1,11 @@
 import fg from 'fast-glob';
 import { IGNORE } from '../constants.js';
 import { getSandboxRoot, isInsideRoot } from '../../sandbox/index.js';
+/**
+ * glob 超时墙。纯文件名枚举正常是毫秒~秒级;超时只发生在网络盘/断开的 UNC 挂载等病态
+ * 场景。此时杀掉枚举报错,而不是让 spinner 无限期挂住。
+ */
+export const GLOB_TIMEOUT_MS = 30_000;
 // ---------- glob ----------
 export const globTool = {
     name: 'glob',
@@ -13,23 +18,66 @@ export const globTool = {
         },
         required: ['pattern'],
     },
-    async execute(args) {
+    async execute(args, ctx) {
         const pattern = String(args.pattern);
         const cwd = getSandboxRoot() ?? process.cwd();
-        const files = (await fg(pattern, {
-            cwd,
-            onlyFiles: true,
-            dot: true,
-            ignore: IGNORE,
-            followSymbolicLinks: false, // 不跟随软链目录,防经软链列出牢外文件
-            throwErrorOnBrokenSymbolicLink: false,
-        })).filter((f) => isInsideRoot(f)); // 后置兜底:仅留牢内
-        if (files.length === 0)
-            return '无匹配文件';
-        const shown = files.slice(0, 200);
-        let out = shown.join('\n');
-        if (files.length > 200)
-            out += `\n... (共 ${files.length} 个,仅显示前 200)`;
-        return out;
+        // 组合外部 Ctrl+C 信号与超时墙:fast-glob 3.3 原生支持 AbortSignal,中止后枚举立即失败。
+        const controller = new AbortController();
+        const external = ctx?.signal;
+        const onExternal = () => controller.abort();
+        if (external) {
+            if (external.aborted)
+                onExternal();
+            else
+                external.addEventListener('abort', onExternal, { once: true });
+        }
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, GLOB_TIMEOUT_MS);
+        try {
+            // fast-glob 3.3 的 signal 选项运行时不生效(实测),用 Promise.race 做超时/中断墙:
+            // 触发后不再等待枚举——纯只读 readdir 会自行跑完,用户面即时解锁。
+            const fgPromise = fg(pattern, {
+                cwd,
+                onlyFiles: true,
+                dot: true,
+                ignore: IGNORE,
+                followSymbolicLinks: false, // 不跟随软链目录,防经软链列出牢外文件
+                throwErrorOnBrokenSymbolicLink: false,
+            });
+            const cancelled = new Promise((resolve) => {
+                if (controller.signal.aborted)
+                    resolve('cancelled');
+                else
+                    controller.signal.addEventListener('abort', () => resolve('cancelled'), { once: true });
+            });
+            const files = await Promise.race([fgPromise, cancelled]);
+            if (files === 'cancelled') {
+                if (timedOut) {
+                    return {
+                        status: 'error',
+                        code: 'TIMEOUT',
+                        retryable: false,
+                        output: `错误:glob 超过 ${GLOB_TIMEOUT_MS / 1000}s 超时墙已被中止(确认无网络盘挂载,或收窄 pattern 后重试)`,
+                    };
+                }
+                // 外部 Ctrl+C:中断串由 tool-runtime 见 signal.aborted 归一为 aborted。
+                return '已中断';
+            }
+            const safeFiles = files.filter((f) => isInsideRoot(f)); // 后置兜底:仅留牢内
+            if (safeFiles.length === 0)
+                return '无匹配文件';
+            const shown = safeFiles.slice(0, 200);
+            let out = shown.join('\n');
+            if (safeFiles.length > 200)
+                out += `\n... (共 ${safeFiles.length} 个,仅显示前 200)`;
+            return out;
+        }
+        finally {
+            clearTimeout(timer);
+            external?.removeEventListener('abort', onExternal);
+        }
     },
 };

package/dist/tools/builtins/grep.js

@@ -2,69 +2,168 @@ import { readFile } from 'node:fs/promises';
 import fg from 'fast-glob';
 import { IGNORE, MAX_RESULTS } from '../constants.js';
 import { isProbablyBinary } from '../../attachments/image.js';
-// 二进制文件探测统一走 attachments/image.ts 的 isProbablyBinary(与 read_file 同源同口径,
-// 避免两处正则漂移):头部含 C0 控制字符即跳过。否则 grep 扫到 SQLite/压缩文件等会产出
-// 「单行数 KB + 控制字符」的匹配行,这类行进 TUI 展开后被终端 auto-wrap,物理行与缓冲行
-// 失配导致整屏错乱。
 import { getSandboxRoot, isInsideRoot, jailResolve } from '../../sandbox/index.js';
-/** 单文件读取上限:超过即跳过(压缩产物 / 生成物 / 数据 dump)。
- *  逐文件全量 readFile 进内存是 grep 的固有成本,不设上限时一个 200MB 的 bundle
- *  就能把整轮 grep 拖死并撑爆内存。跳过的文件数会在结果尾部报出来,不静默吞。 */
+import { runRipgrep } from '../ripgrep-client.js';
+/**
+ * grep 超时墙。
+ *
+ * ripgrep 正常仓库都是秒级,超时只发生在网络盘挂死这类病态场景——此时与其让 spinner
+ * 无限期冻住,不如杀掉报错让模型换路径(收窄 glob)。比 run_command 默认 120s 更严:
+ * 全库搜索不该有 rg 跑满 2 分钟还出不来的结果。
+ */
+export const GREP_TIMEOUT_MS = 120_000;
+/** Node 兜底路径的单文件读取上限(ripgrep 流式读取不需要这个闸门,仅兜底用)。 */
 const MAX_FILE_BYTES = 2 * 1024 * 1024;
-/** 单条 body 行渲染上限(字符):minified JS / 单行 JSON 截断加 …,
- *  既防 TUI auto-wrap 错乱,也防一行吃掉整个 MAX_RESULTS 预算。 */
+/** 单条 body 行渲染上限(字符):minified JS / 单行 JSON 截断加 …,防 TUI auto-wrap 错乱。 */
 const MAX_BODY_LINE_CHARS = 400;
-/** context 参数上限:邻居行是 ×(1+2C) 放大,给到 10 已远超「看清一段逻辑」的需要。 */
+/** context 参数上限:邻居行是 ×(1+2C) 放大,给到 10 已远超需要。 */
 const MAX_CONTEXT_LINES = 10;
-/** 超长行截断(保留头部:grep 的价值在行首标识与缩进)。 */
 function clipLine(line) {
     if (line.length <= MAX_BODY_LINE_CHARS)
         return line;
     return `${line.slice(0, MAX_BODY_LINE_CHARS)}…(+${line.length - MAX_BODY_LINE_CHARS} 字符)`;
 }
 /**
- * 把命中行号 + context 半径渲染成 body 行。
- *
- * 输出格式契约(context/encoders/search.ts 依赖前两个前缀做 Cold 折叠):
+ * 把命中行 + context 行渲染成 body。输出格式契约(context/encoders/search 依赖前缀做折叠):
  *   `  L<n>: <原文>`   命中行(冒号)
- *   `  L<n>- <原文>`   上下文行(连字符,对齐 ripgrep 的 `:` / `-`)
- *   `  --`             不相邻分块之间的分隔(对齐 ripgrep)
- * 原文**不 trim**:缩进是代码结构信息,trim 掉后模型看不出嵌套层级,只能再发一次
- * read_file 去确认——那正是 context 参数要消灭的往返。
+ *   `  L<n>- <原文>`   上下文行(连字符)
+ *   `  --`             不相邻分块之间的分隔
+ * 原文不 trim:缩进是代码结构信息。
  */
-function renderBodies(lines, lineNos, maxPerFile, context) {
-    const shown = lineNos.slice(0, maxPerFile);
+function renderFileBodies(file, maxPerFile) {
+    const shown = file.matches.slice(0, maxPerFile);
     if (shown.length === 0)
         return [];
-    const matched = new Set(shown);
-    // 命中行 ± context 的并集,排序后按连续块渲染。
-    const wanted = new Set();
-    for (const n of shown) {
-        for (let i = n - context; i <= n + context; i++) {
-            if (i >= 1 && i <= lines.length)
-                wanted.add(i);
-        }
-    }
+    const matched = new Set(shown.map((e) => e.line));
+    const byLine = new Map();
+    for (const e of shown)
+        byLine.set(e.line, e);
+    for (const e of file.contexts)
+        byLine.set(e.line, e);
     const out = [];
     let previous = 0;
-    for (const n of [...wanted].sort((a, b) => a - b)) {
+    for (const n of [...byLine.keys()].sort((a, b) => a - b)) {
         if (previous !== 0 && n !== previous + 1)
             out.push('  --');
         previous = n;
-        out.push(`  L${n}${matched.has(n) ? ':' : '-'} ${clipLine(lines[n - 1])}`);
+        const event = byLine.get(n);
+        out.push(`  L${n}${matched.has(n) ? ':' : '-'} ${clipLine(event.text)}`);
     }
     return out;
 }
+/** 把聚合后的文件事件渲染成工具输出(配额/截断口径与旧实现一致)。 */
+function renderResults(files, maxPerFile, context, truncated) {
+    const hits = [];
+    let budgetTruncated = truncated;
+    for (const file of files) {
+        const bodyCost = Math.min(file.matches.length, maxPerFile) * (1 + 2 * context);
+        const totalCost = file.matches.length + bodyCost;
+        if (hits.length >= MAX_RESULTS || totalCost > MAX_RESULTS * 4) {
+            if (hits.length < MAX_RESULTS)
+                hits.push({ file, bodies: [] });
+            budgetTruncated = true;
+            continue;
+        }
+        hits.push({ file, bodies: renderFileBodies(file, maxPerFile) });
+    }
+    const out = [];
+    let totalShown = 0;
+    for (const h of hits) {
+        out.push(`${h.file.path}: ${h.file.matches.length} 处匹配,行号 [${h.file.matches.map((e) => e.line).join(', ')}]`);
+        if (h.bodies.length > 0)
+            out.push(...h.bodies);
+        else
+            out.push('  (body 已折叠,见上方行号列表 → read_file 精读)');
+        totalShown += h.file.matches.length + h.bodies.length;
+        if (totalShown >= MAX_RESULTS) {
+            out.push(`...(结果达到 ${MAX_RESULTS} 条上限${context > 0 ? ',context 行同样计入;要更全就减小 context 或收窄 glob' : ''})`);
+            break;
+        }
+    }
+    if (budgetTruncated)
+        out.push('...(仍有更多匹配未展示,缩小 glob 或收窄正则)');
+    return out.join('\n');
+}
+/**
+ * Node 兜底:rg 二进制不可用(可选依赖缺失且 PATH 无 rg)时走旧路径。
+ * 与旧实现的唯一差异——每两个文件之间检查 abort 信号,使 Ctrl+C / 超时墙能即时打断。
+ */
+async function nodeFallback(pattern, glob, maxPerFile, context, signal, externalSignal) {
+    let re;
+    try {
+        re = new RegExp(pattern);
+    }
+    catch (e) {
+        return `错误:非法正则 ${pattern}: ${e instanceof Error ? e.message : String(e)}`;
+    }
+    const cwd = getSandboxRoot() ?? process.cwd();
+    const entries = (await fg(glob, {
+        cwd,
+        onlyFiles: true,
+        dot: true,
+        ignore: IGNORE,
+        stats: true,
+        followSymbolicLinks: false,
+        throwErrorOnBrokenSymbolicLink: false,
+    })).filter((entry) => isInsideRoot(entry.path)); // 后置兜底:仅留牢内
+    const files = [];
+    let scanned = 0;
+    let skippedTooLarge = 0;
+    const abortNote = () => externalSignal?.aborted
+        ? { status: 'aborted', code: 'ABORTED', output: '已中断' }
+        : {
+            status: 'error',
+            code: 'TIMEOUT',
+            retryable: false,
+            output: `错误:grep 超过 ${GREP_TIMEOUT_MS / 1000}s 超时墙已被中止(收窄 glob 后重试)`,
+        };
+    for (let fi = 0; fi < entries.length; fi++) {
+        const entry = entries[fi];
+        if ((fi & 31) === 0 && signal.aborted)
+            return abortNote();
+        if (entry.stats && entry.stats.size > MAX_FILE_BYTES) {
+            skippedTooLarge++;
+            continue;
+        }
+        let content;
+        try {
+            content = await readFile(jailResolve(entry.path), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        scanned++;
+        if (isProbablyBinary(content))
+            continue;
+        const lines = content.split(/\r?\n/);
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (re.test(lines[i]))
+                matches.push({ line: i + 1, text: lines[i] });
+        }
+        if (matches.length > 0)
+            files.push({ path: entry.path, matches, contexts: [] });
+    }
+    if (signal.aborted)
+        return abortNote();
+    if (files.length === 0) {
+        const note = skippedTooLarge ? `,跳过 ${skippedTooLarge} 个超过 2MiB 的文件` : '';
+        return `无匹配(扫描了 ${scanned} 个文件${note})`;
+    }
+    // 兜底路径无 context 事件来源(rg 缺失),context 参数退化为只给命中行。
+    const out = renderResults(files, maxPerFile, 0, false);
+    return skippedTooLarge ? `${out}\n...(跳过 ${skippedTooLarge} 个超过 2MiB 的文件)` : out;
+}
 // ---------- grep ----------
 export const grepTool = {
     name: 'grep',
-    description: 'Search file contents by regex (recursive, excludes node_modules/.git/dist).\n' +
+    description: 'Search file contents by regex (recursive; powered by ripgrep: respects .gitignore, skips binaries).\n' +
         'Output: per-file header "<path>: N matches, lines [l1, l2, ...]" plus rendered lines with ORIGINAL INDENTATION kept.\n' +
-        'Pass context=2..5 to include neighbouring lines inline (like ripgrep -C) instead of following each hit with a read_file round-trip. Use read_file when you need a whole region or exact edit text.',
+        'Pass context=2..5 to include neighbouring lines inline (like ripgrep -C) instead of following each hit with a read_file round-trip. Hard wall 120s; narrow the glob if a tree contains network mounts. Use read_file when you need a whole region or exact edit text.',
     parameters: {
         type: 'object',
         properties: {
-            pattern: { type: 'string', description: 'Regular expression' },
+            pattern: { type: 'string', description: 'Regular expression (ripgrep/Rust regex syntax)' },
             glob: { type: 'string', description: 'Optional, restrict to a file glob, e.g. *.ts' },
             max_per_file: {
                 type: 'integer',
@@ -73,106 +172,61 @@ export const grepTool = {
             context: {
                 type: 'integer',
                 description: 'Neighbouring lines to include around each match, like ripgrep -C (default 0, max 10). ' +
-                    'Output grows ~x(1+2*context) and counts against the same result budget, so keep it small.',
+                    'Output grows ~x(1+2*context), so keep it small.',
             },
         },
         required: ['pattern'],
     },
-    async execute(args) {
+    async execute(args, ctx) {
         const pattern = String(args.pattern);
-        const g = String(args.glob ?? '**/*');
+        const glob = String(args.glob ?? '**/*');
         const maxPerFile = Math.min(Math.max(Number(args.max_per_file ?? 15), 1), 50);
         const contextRaw = Number(args.context ?? 0);
         const context = Number.isFinite(contextRaw) ? Math.min(Math.max(Math.trunc(contextRaw), 0), MAX_CONTEXT_LINES) : 0;
-        let re;
-        try {
-            re = new RegExp(pattern);
-        }
-        catch (e) {
-            return `错误:非法正则 ${pattern}: ${e instanceof Error ? e.message : String(e)}`;
+        // 组合外部 Ctrl+C 信号与超时墙:任一触发都中止 rg 子进程。
+        const controller = new AbortController();
+        const external = ctx?.signal;
+        const onExternal = () => controller.abort();
+        if (external) {
+            if (external.aborted)
+                onExternal();
+            else
+                external.addEventListener('abort', onExternal, { once: true });
         }
-        const cwd = getSandboxRoot() ?? process.cwd();
-        // stats:true 让 fast-glob 顺手带回 size,免为体积闸门再付一次 stat 系统调用。
-        const entries = (await fg(g, {
-            cwd,
-            onlyFiles: true,
-            dot: true,
-            ignore: IGNORE,
-            stats: true,
-            followSymbolicLinks: false, // 不跟随软链目录,防经软链扫到牢外文件
-            throwErrorOnBrokenSymbolicLink: false,
-        })).filter((entry) => isInsideRoot(entry.path)); // 后置兜底:仅留牢内
-        const hits = [];
-        let scanned = 0;
-        let skippedTooLarge = 0;
-        let truncated = false;
-        for (const entry of entries) {
-            const f = entry.path;
-            // 体积闸门:压缩产物 / 数据 dump 读进来只会撑爆内存并产出无意义超长行。
-            if (entry.stats && entry.stats.size > MAX_FILE_BYTES) {
-                skippedTooLarge++;
-                continue;
-            }
-            let content;
-            try {
-                // jailResolve:realpath 化,防「牢内文件软链→牢外」的内容泄露;越界/不可读均 catch 跳过
-                content = await readFile(jailResolve(f), 'utf8');
-            }
-            catch {
-                continue; // 跳过无法读的文件(二进制/权限/沙箱越界)
-            }
-            scanned++;
-            // 二进制文件(如 .codegraph/codegraph.db 这类 SQLite)跳过:其「行」是数 KB 的
-            // 序列化记录 + 控制字符,匹配行对 LLM 无意义,还会污染 TUI 展开渲染。
-            if (isProbablyBinary(content))
-                continue;
-            const lines = content.split(/\r?\n/);
-            const lineNos = [];
-            for (let i = 0; i < lines.length; i++) {
-                if (re.test(lines[i]))
-                    lineNos.push(i + 1);
-            }
-            if (lineNos.length === 0)
-                continue;
-            // 全局配额:行号列表总是计入,body 成本按「命中行数 ×(1+2×context)」计入 ——
-            // context 是乘法放大,不按实际渲染量计就会让带 ±5 邻居的 grep 静默撑爆预算。
-            const bodyCost = Math.min(lineNos.length, maxPerFile) * (1 + 2 * context);
-            const totalCost = lineNos.length + bodyCost;
-            if (hits.length >= MAX_RESULTS || totalCost > MAX_RESULTS * 4) {
-                // 文件过多 / 配额爆:仅追加该文件行号列表,不再展开 body
-                if (hits.length < MAX_RESULTS) {
-                    hits.push({ path: f, lineNos, bodies: [] });
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, GREP_TIMEOUT_MS);
+        try {
+            const result = await runRipgrep({ pattern, glob, context }, controller.signal);
+            switch (result.status) {
+                case 'regex_error':
+                    return `错误:非法正则 ${pattern}: ${result.message}`;
+                case 'no-match': {
+                    const trunc = result.truncated ? '\n...(输出截断,缩小 glob 或收窄正则后重试)' : '';
+                    return `无匹配(扫描了 ${result.scanned} 个文件)${trunc}`;
                 }
-                truncated = true;
-                continue;
+                case 'ok':
+                    return renderResults(result.files, maxPerFile, context, result.truncated);
+                case 'unavailable':
+                    return nodeFallback(pattern, glob, maxPerFile, context, controller.signal, external);
+                case 'aborted':
+                    if (timedOut) {
+                        return {
+                            status: 'error',
+                            code: 'TIMEOUT',
+                            retryable: false,
+                            output: `错误:grep 超过 ${GREP_TIMEOUT_MS / 1000}s 超时墙已被中止(收窄 glob 或确认无网络盘挂载后重试)`,
+                        };
+                    }
+                    // 外部 Ctrl+C:返回中断串,tool-runtime 见 signal.aborted 会归一为 aborted。
+                    return '已中断';
             }
-            hits.push({ path: f, lineNos, bodies: renderBodies(lines, lineNos, maxPerFile, context) });
         }
-        const skippedNote = skippedTooLarge
-            ? `,跳过 ${skippedTooLarge} 个超过 ${MAX_FILE_BYTES / 1024 / 1024}MiB 的文件`
-            : '';
-        if (hits.length === 0)
-            return `无匹配(扫描了 ${scanned} 个文件${skippedNote})`;
-        const out = [];
-        let totalShown = 0;
-        for (const h of hits) {
-            out.push(`${h.path}: ${h.lineNos.length} 处匹配,行号 [${h.lineNos.join(', ')}]`);
-            if (h.bodies.length > 0) {
-                out.push(...h.bodies);
-            }
-            else {
-                out.push(`  (body 已折叠,见上方行号列表 → read_file 精读)`);
-            }
-            totalShown += h.lineNos.length + h.bodies.length;
-            if (totalShown >= MAX_RESULTS) {
-                out.push(`...(结果达到 ${MAX_RESULTS} 条上限${context > 0 ? ',context 行同样计入;要更全就减小 context 或收窄 glob' : ''})`);
-                break;
-            }
+        finally {
+            clearTimeout(timer);
+            external?.removeEventListener('abort', onExternal);
         }
-        if (truncated)
-            out.push(`...(仍有更多匹配文件未展示,缩小 glob 或收窄正则)`);
-        if (skippedTooLarge)
-            out.push(`...(跳过 ${skippedTooLarge} 个超过 ${MAX_FILE_BYTES / 1024 / 1024}MiB 的文件)`);
-        return out.join('\n');
     },
 };

package/dist/tools/builtins/index.js

@@ -22,6 +22,8 @@ import { memoryUpdateTool } from './memory-update.js';
 import { memoryForgetTool } from './memory-forget.js';
 import { memoryGraphTool } from './memory-graph.js';
 import { subAgentTool } from './task.js';
+import { arenaTool } from './arena.js';
+import { messageBusTool } from './message-bus.js';
 import { computerTool } from './computer.js';
 import { sessionSearchTool } from './session-search.js';
 /**
@@ -50,8 +52,8 @@ export const CAPABILITIES = {
     // 后台进程与浏览器会话跨调用存活；串行执行避免同一页面/服务被并发操作。
     dev_server: { effect: 'process', concurrency: 'serial', resources: workspaceResource, supportsAbort: true },
     browser: { effect: 'process', concurrency: 'serial', resources: workspaceResource },
-    glob: { effect: 'read', concurrency: 'parallel', resources: workspaceResource },
-    grep: { effect: 'read', concurrency: 'parallel', resources: workspaceResource },
+    glob: { effect: 'read', concurrency: 'parallel', resources: workspaceResource, supportsAbort: true },
+    grep: { effect: 'read', concurrency: 'parallel', resources: workspaceResource, supportsAbort: true },
     // 网络只读查询:无副作用,可安全重复执行 → idempotent 让 runtime 对瞬时失败(429/5xx/超时/
     // 网络抖动)自动退避重试,省掉模型「再发一轮 tool call 自救」的往返。写/进程类工具绝不置此位。
     web_search: { effect: 'network', concurrency: 'parallel', supportsAbort: true, idempotent: true },
@@ -88,6 +90,13 @@ export const CAPABILITIES = {
         parallelOrchestration: true,
         supportsAbort: true,
     },
+    // arena:一次调用内部并行 spawnAgent 出多个候选 + 一次 judge(见 ./arena.ts)。与 sub-agent 同理:
+    // 资源锁委派给内层 spawn 出的工具,否则 arena 自持 workspace 写锁会与候选内 run_command 自锁;
+    // 候选直接写共享工作区 → effect=write;它是单个工具调用,不置 parallelOrchestration(那是跨调用批)。
+    arena: { effect: 'write', concurrency: 'serial', delegatesResourceLocks: true, supportsAbort: true },
+    // message_bus:读写 .mocode/bus 下的内部消息文件(send 写 / inbox·ack·history 多为读),不触碰
+    // 项目代码;用独立 message-bus 资源键串行(类比 memory-store),不作项目 mutation 追踪/回滚。
+    message_bus: { effect: 'write', concurrency: 'serial', resources: () => ['message-bus'] },
 };
 const rawBuiltinTools = [
     readFileTool,
@@ -113,6 +122,8 @@ const rawBuiltinTools = [
     memoryForgetTool,
     memoryGraphTool,
     subAgentTool,
+    arenaTool,
+    messageBusTool,
     computerTool,
     sessionSearchTool,
 ];

package/dist/tools/builtins/message-bus.js

@@ -0,0 +1,98 @@
+import { sendMessage, inbox, markRead, messageHistory, getIdentity } from '../../bots/bus.js';
+// ---------- message_bus ----------
+// D1：通过持久消息总线与其他具名 bot 异步通信。消息落盘，对方不必同时在线——
+// worker bot 之后被 scheduler / bg 唤起时拉 inbox、处理、回结果（再 send 一条 to=原发送者）。
+//
+// action:
+//   send     {to, body, inReplyTo?}  给某 bot 发消息
+//   inbox    拉取当前身份的未读消息（默认拉取后自动 ack）
+//   ack      {ids:[...]}             手动标记已读
+//   history  与当前身份相关的全部消息
+export const messageBusTool = {
+    name: 'message_bus',
+    description: [
+        'Asynchronous persistent messaging between named bots (and the main user). Messages are stored; the recipient need not be running and reads its inbox later.',
+        'Actions: send {to, body, inReplyTo?}, inbox (unread, auto-ack by default), ack {ids}, history. Use for durable hand-offs rather than synchronous sub-agent calls.',
+    ].join(''),
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['send', 'inbox', 'ack', 'history'],
+                description: 'Bus operation.',
+            },
+            to: { type: 'string', description: 'Recipient bot name (send).' },
+            body: { type: 'string', description: 'Message body (send).' },
+            inReplyTo: { type: 'string', description: 'Id of the message being replied to.' },
+            ids: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Message ids to acknowledge (ack).',
+            },
+            autoAck: {
+                type: 'boolean',
+                description: 'With inbox: mark pulled messages read (default true).',
+            },
+        },
+        required: ['action'],
+    },
+    async execute(args) {
+        const action = String(args.action ?? '');
+        const identity = getIdentity();
+        const formatMsg = (m) => `[${m.id}] ${m.from} -> ${m.to} @ ${m.createdAt}\n${m.body}`;
+        let output;
+        try {
+            if (action === 'send') {
+                const to = String(args.to ?? '');
+                const body = String(args.body ?? '');
+                if (!to || !body)
+                    return 'message_bus send requires to and body';
+                const msg = sendMessage({
+                    to,
+                    body,
+                    ...(typeof args.inReplyTo === 'string' ? { inReplyTo: args.inReplyTo } : {}),
+                });
+                output = `sent ${msg.id} to ${msg.to}`;
+            }
+            else if (action === 'inbox') {
+                const msgs = inbox(identity);
+                if (msgs.length === 0) {
+                    output = `(no unread messages for ${identity})`;
+                }
+                else {
+                    output = [`inbox for ${identity}: ${msgs.length} unread`, '', ...msgs.map(formatMsg)].join('\n');
+                    if (args.autoAck !== false) {
+                        const marked = markRead(msgs.map((m) => m.id), identity);
+                        output += `\n\n(acked ${marked.length})`;
+                    }
+                }
+            }
+            else if (action === 'ack') {
+                const ids = Array.isArray(args.ids) ? args.ids.filter((x) => typeof x === 'string') : [];
+                const marked = markRead(ids, identity);
+                output = `acked ${marked.length} message(s)`;
+            }
+            else if (action === 'history') {
+                const msgs = messageHistory(identity);
+                output = msgs.length
+                    ? [`history for ${identity}: ${msgs.length}`, '', ...msgs.map(formatMsg)].join('\n')
+                    : `(no messages for ${identity})`;
+            }
+            else {
+                return `unknown message_bus action: ${action}`;
+            }
+        }
+        catch (e) {
+            const outcome = {
+                status: 'error',
+                code: 'EXECUTION_ERROR',
+                retryable: false,
+                output: e instanceof Error ? e.message : String(e),
+            };
+            return outcome;
+        }
+        const outcome = { status: 'success', code: 'OK', retryable: false, output };
+        return outcome;
+    },
+};

package/dist/tools/builtins/run-command.js

@@ -73,6 +73,7 @@ export async function runCommandRaw(command, timeout = DEFAULT_COMMAND_TIMEOUT_M
             // cmd.exe 需要 verbatim:否则 Node 重新引号化参数,`node -e "..."` 会退化成
             // 字符串字面量并 exit 0,造成 Windows 上的假阳性验证。其它 shell 必须关。
             windowsVerbatimArguments: spec.windowsVerbatimArguments,
+            windowsHide: true,
         });
         const output = new BoundedCommandOutput();
         let finished = false;
@@ -80,7 +81,7 @@ export async function runCommandRaw(command, timeout = DEFAULT_COMMAND_TIMEOUT_M
             try {
                 if (isWin) {
                     if (child.pid != null) {
-                        spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+                        spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
                     }
                 }
                 else {

package/dist/tools/constants.js

@@ -88,6 +88,17 @@ export const IGNORE = [
     '**/rust/**',
     '**/dist/**',
     '**/dist-tests/**',
+    // Python 生态:虚拟环境与缓存目录动辄上万文件,ripgrep 路径下主要靠 .gitignore 自动跳过,
+    // 这里是「非 git 仓库 / 未写进 .gitignore」时的兜底;Node 兜底路径更依赖这份硬名单。
+    '**/.venv/**',
+    '**/venv/**',
+    '**/__pycache__/**',
+    '**/.mypy_cache/**',
+    '**/.pytest_cache/**',
+    '**/.tox/**',
+    '**/htmlcov/**',
+    '**/.ipynb_checkpoints/**',
+    '**/*.egg-info/**',
 ];
 // ── legacy profile fallback（官方 TUI/stdio 已由 ToolPolicy 控制）────────────────
 // 保留导出名以兼容未传 ToolPolicy 的嵌入调用与旧测试。