mocode-ai 1.6.6 → 1.6.8

package/dist/models/protocol.js

@@ -5,12 +5,21 @@ export const OPENAI_DEFAULT_BASE_URL = 'https://api.openai.com/v1';
  * 不带 /v1——anthropic.ts 的 endpoint() 会在后面拼 `/v1/messages`。
  */
 export const ANTHROPIC_DEFAULT_BASE_URL = 'https://api.anthropic.com';
+/** Gemini Developer API 的模型目录。 */
+export const GEMINI_DEFAULT_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/models';
+/**
+ * Vertex Express API 全局端点（不含区域前缀）：模型目录最全，API key 可直接直发。
+ * Google GenAI SDK 的 `genai.Client(vertexai=True, api_key=...)` 默认就是这个端点。
+ * 网络出口国家由本机代理决定，与 Vertex 区域无关。
+ */
+export const VERTEX_DEFAULT_BASE_URL = 'https://aiplatform.googleapis.com/v1/publishers/google/models';
 /**
  * 判定该 provider 能否用 mocode 现有 fetch 直发。
  * - 官方 anthropic 包 → Anthropic Messages 路径
  * - openai-compatible 且带端点 → OpenAI Chat 路径
  * - 官方 openai 包 → OpenAI Chat 路径（端点缺省补官方 /v1）
- * - 其余（google/bedrock/azure/vertex/各 gateway…）→ 二期，UI 置灰
+ * - Google / Vertex Gemini → Gemini Contents 路径
+ * - 其余（bedrock/azure/Vertex Anthropic/各 gateway…）→ 暂不支持
  */
 export function classifyProvider(provider) {
     switch (provider.npm) {
@@ -20,25 +29,61 @@ export function classifyProvider(provider) {
             return provider.api && provider.api.trim() ? 'openai-chat' : 'unsupported';
         case '@ai-sdk/openai':
             return 'openai-chat';
+        case '@ai-sdk/google':
+        case '@ai-sdk/google-vertex':
+            return 'gemini-contents';
         default:
             return 'unsupported';
     }
 }
-/** provider 实际要用的 baseURL：官方 openai/anthropic 缺 api 时补默认，其余原样返回。 */
-export function resolveBaseURL(provider) {
+function vertexBaseURL(env = process.env) {
+    // 默认走全局 Express 端点；仅当显式设置 GOOGLE_VERTEX_LOCATION（需要数据驻留）时用区域端点。
+    // 注意：区域端点的模型上线晚于全局端点，部分新模型在区域端点可能 404。
+    const raw = env.GOOGLE_VERTEX_LOCATION?.trim().toLowerCase() ?? '';
+    if (/^[a-z][a-z0-9-]*[a-z0-9]$/.test(raw)) {
+        return `https://${raw}-aiplatform.googleapis.com/v1/publishers/google/models`;
+    }
+    return VERTEX_DEFAULT_BASE_URL;
+}
+/** 模型级协议覆盖优先；未覆盖时使用 provider 顶层协议。 */
+export function classifyModel(provider, model) {
+    const npm = model?.provider?.npm;
+    if (npm === '@ai-sdk/google-vertex/anthropic')
+        return 'unsupported';
+    if (npm === '@ai-sdk/openai-compatible') {
+        const api = model?.provider?.api?.trim();
+        // Vertex MaaS 模板需要 project/location/ADC，不属于本次 Express API key 直连路径。
+        return api && !api.includes('${') ? 'openai-chat' : 'unsupported';
+    }
+    return classifyProvider(provider);
+}
+/** 模型级 baseURL 覆盖优先；未覆盖时使用 provider 顶层端点。 */
+export function resolveModelBaseURL(provider, model, env = process.env) {
+    if (model?.provider?.api?.trim())
+        return model.provider.api.trim();
+    return resolveBaseURL(provider, env);
+}
+/** provider 实际要用的 baseURL：显式 api 优先，否则按协议补官方默认值。 */
+export function resolveBaseURL(provider, env = process.env) {
     if (provider.api && provider.api.trim())
         return provider.api.trim();
     if (provider.npm === '@ai-sdk/openai')
         return OPENAI_DEFAULT_BASE_URL;
     if (provider.npm === '@ai-sdk/anthropic')
         return ANTHROPIC_DEFAULT_BASE_URL;
+    if (provider.npm === '@ai-sdk/google')
+        return GEMINI_DEFAULT_BASE_URL;
+    if (provider.npm === '@ai-sdk/google-vertex')
+        return vertexBaseURL(env);
     return '';
 }
-/** 映射到 ModelPreset.provider（presets.ts 的两值）。 */
+/** 映射到 ModelPreset.provider。 */
 export function toPresetProvider(proto) {
     if (proto === 'openai-chat')
         return 'openai';
     if (proto === 'anthropic-messages')
         return 'anthropic';
+    if (proto === 'gemini-contents')
+        return 'google';
     return null;
 }

package/dist/models/search.js

@@ -1,11 +1,11 @@
-import { classifyProvider } from './protocol.js';
+import { classifyModel } from './protocol.js';
 /** 把目录拍平成条目列表。 */
 export function flattenCatalog(providers) {
     const out = [];
     for (const [providerId, provider] of Object.entries(providers)) {
-        const supported = classifyProvider(provider) !== 'unsupported';
         const providerName = provider.name || providerId;
         for (const [modelId, model] of Object.entries(provider.models ?? {})) {
+            const supported = classifyModel(provider, model) !== 'unsupported';
             out.push({ providerId, providerName, modelId, model, supported });
         }
     }

package/dist/repl/commands/effort.js

@@ -23,7 +23,7 @@ const LEVEL_LABELS = {
 /** 当前目标模型是否在白名单内(未识别则给提示)。 */
 function currentModelRecognized() {
     return recognizesReasoning({
-        provider: config.provider === 'anthropic' ? 'anthropic' : 'openai',
+        provider: config.provider,
         model: config.model,
         maxTokens: config.maxTokens,
     });

package/dist/repl/commands/model-actions.js

@@ -14,7 +14,7 @@ import { reconfigureClient } from '../../llm/index.js';
 import { promptIntervention } from '../../ui/intervention.js';
 import { renderHistory } from '../message-format.js';
 import { refreshCatalog } from '../../models/catalog.js';
-import { buildPreset, defaultPresetName, resolveApiKey } from '../../models/map-preset.js';
+import { buildPreset, defaultPresetName, preferredKeyEnvName, resolveApiKey } from '../../models/map-preset.js';
 /** 应用预设到 config + 落 config 文件 + 重建 client + 重显。 */
 export function applyPresetConfig(ctx, p) {
     updateModelConfig({
@@ -51,7 +51,7 @@ export async function addCatalogModel(ctx, entry, providers) {
     if (!catalogProvider)
         return 'cancelled';
     // key：无论环境变量是否找到，都弹一次确认——回车沿用预填值、粘贴即覆盖。
-    const envName = catalogProvider.env?.[0] ?? 'API_KEY';
+    const envName = preferredKeyEnvName(catalogProvider);
     const detectedKey = resolveApiKey(catalogProvider);
     const kres = await promptIntervention({
         type: 'input',

package/dist/repl/commands/model.js

@@ -178,7 +178,7 @@ export const modelCommands = [
             layout.contentWrite(`  ${ui.accent}apiKey  ${ui.reset}  ${maskKey(config.apiKey)}\n`);
             layout.contentWrite(`  ${ui.accent}model   ${ui.reset}  ${config.model}\n`);
             const recognized = recognizesReasoning({
-                provider: config.provider === 'anthropic' ? 'anthropic' : 'openai',
+                provider: config.provider,
                 model: config.model,
                 maxTokens: config.maxTokens,
             });

package/dist/session/scheduler.js

@@ -7,9 +7,6 @@ import { pruneStaleArtifacts, refreshArtifactFreshness } from '../context/artifa
 import { pruneSuperseded } from '../context/relevance.js';
 import { clearRetrievableResults } from '../context/clearing.js';
 import { createAgeAwareEncodingState } from '../context/age-aware.js';
-function atPressure(report) {
-    return Math.max(report.rawTotal, report.total) >= report.window * DEFAULT_BUDGET_POLICY.pressureTriggerRatio;
-}
 function emptyPressure(report) {
     return {
         triggered: false,

package/dist/session/store.js

@@ -235,7 +235,7 @@ export class SessionStore {
     load(id) {
         const currentPath = this.sessionPath(id);
         const legacyPath = path.join(this.sessionsRoot, `${id}.json`);
-        let source = existsSync(currentPath) ? currentPath : legacyPath;
+        const source = existsSync(currentPath) ? currentPath : legacyPath;
         // 活会话与 legacy 单文件都没有:回退从归档 gz 取回(30-90 天的会话仍可 resume)。
         if (!existsSync(source)) {
             const archived = loadArchivedSession(this.sessionsRoot, id);

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

@@ -52,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 },
@@ -90,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,

package/dist/tools/builtins/task.js

@@ -14,6 +14,7 @@ export const subAgentTool = {
     risk: 'dangerous',
     description: [
         'Spawn a worker with your own full capability set and conversation context for an isolated sub-task; only its structured result returns.',
+        'Use it for exploration-heavy work (unfamiliar subsystems, multi-file research, audits) and for independent sub-tasks; emit several calls in one message to run them concurrently.',
         'The worker sees everything you have already read and concluded, so it does not repeat exploration.',
     ].join(''),
     parameters: {