mocode-ai 1.6.9 → 1.6.10

package/dist/tools/builtins/index.js

@@ -52,8 +52,12 @@ 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, supportsAbort: true },
-    grep: { effect: 'read', concurrency: 'parallel', resources: workspaceResource, supportsAbort: true },
+    // glob/grep 不取任何资源锁:读枚举容忍命令执行期间的瞬时不一致(一次目录扫描的结果
+    // 本来就无事务语义),换取「一条 run_command/dev_server 持 workspace 写锁期间,只读
+    // 枚举与并行子 agent 的读不被全面压制」。文件级一致性仍由 read_file 的 file:<path>
+    // 锁保证(与 file-locked 写互斥)。网络只读同理不锁。
+    glob: { effect: 'read', concurrency: 'parallel', resources: () => [], supportsAbort: true },
+    grep: { effect: 'read', concurrency: 'parallel', resources: () => [], supportsAbort: true },
     // 网络只读查询:无副作用,可安全重复执行 → idempotent 让 runtime 对瞬时失败(429/5xx/超时/
     // 网络抖动)自动退避重试,省掉模型「再发一轮 tool call 自救」的往返。写/进程类工具绝不置此位。
     web_search: { effect: 'network', concurrency: 'parallel', supportsAbort: true, idempotent: true },

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

@@ -1,4 +1,4 @@
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { MAX_OUTPUT } from '../constants.js';
 import { getSandboxRoot, filterEnv, isCommandDenied, jailResolve } from '../../sandbox/index.js';
 import { t } from '../../i18n/index.js';
@@ -77,12 +77,22 @@ export async function runCommandRaw(command, timeout = DEFAULT_COMMAND_TIMEOUT_M
         });
         const output = new BoundedCommandOutput();
         let finished = false;
-        const killTree = () => {
+        // 异步树杀:spawnSync('taskkill') 会同步阻塞整个事件循环(扫进程树期间流式渲染、
+        // 其它并行工具全部停摆)。taskkill 自身是独立进程,发出去后等它退出即可;
+        // 只在 abort/timeout 路径调用,正常退出(close)不杀。
+        const killTree = async () => {
             try {
                 if (isWin) {
-                    if (child.pid != null) {
-                        spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
-                    }
+                    if (child.pid == null)
+                        return;
+                    await new Promise((resolve) => {
+                        const killer = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], {
+                            stdio: 'ignore',
+                            windowsHide: true,
+                        });
+                        killer.on('close', () => resolve());
+                        killer.on('error', () => resolve());
+                    });
                 }
                 else {
                     child.kill('SIGTERM');
@@ -100,23 +110,35 @@ export async function runCommandRaw(command, timeout = DEFAULT_COMMAND_TIMEOUT_M
             signal?.removeEventListener('abort', onAbort);
             done({ ...result, durationMs: Date.now() - startedAt });
         };
+        // 树杀(异步)进行中:child 的 close 事件可能由 taskkill 触发并抢在 finish 前,
+        // 必须忽略之,否则 abort/timeout 会被误报成 failed(进程被杀的 exitCode ≠ 0)。
+        let pendingTermination = null;
+        const terminate = (status) => {
+            if (finished || pendingTermination)
+                return;
+            pendingTermination = status;
+            void killTree().then(() => {
+                finish({ status, exitCode: null, output: output.render().trim() });
+            });
+        };
         const onAbort = () => {
-            killTree();
-            finish({ status: 'aborted', exitCode: null, output: output.render().trim() });
+            terminate('aborted');
         };
         const onChunk = (chunk) => output.append(chunk.toString('utf8'));
         // 先起 timer 再挂事件:finish/onAbort 是闭包,里面要 clearTimeout(timer)。
         // 把 timer 的初始化提到所有引用它的注册点之前,避免依赖"事件回调必然异步"这一前提。
         const timer = setTimeout(() => {
-            killTree();
-            finish({ status: 'timed_out', exitCode: null, output: output.render().trim() });
+            terminate('timed_out');
         }, effectiveTimeout);
         child.stdout.on('data', onChunk);
         child.stderr.on('data', onChunk);
         child.on('error', (error) => {
-            finish({ status: 'spawn_error', exitCode: null, output: error.message });
+            if (!pendingTermination)
+                finish({ status: 'spawn_error', exitCode: null, output: error.message });
         });
         child.on('close', (code) => {
+            if (pendingTermination)
+                return;
             finish({
                 status: code === 0 ? 'passed' : 'failed',
                 exitCode: code,

package/dist/tools/policy.js

@@ -56,7 +56,7 @@ function addToolGroupsSchema(groups) {
         type: 'function',
         function: {
             name: ADD_TOOL_GROUPS_TOOL_NAME,
-            description: 'Expand the tool surface for this turn when the current tools are insufficient. Call this tool ALONE, before any dependent tool call. Added groups become available on the next model step and cannot be removed during the turn.',
+            description: 'Expand the tool surface for this turn when the current tools are insufficient. Call it alone or batched with read-only tools (read_file/glob/grep/web_search/web_fetch): the read-only calls run in the same step and the new groups take effect on the next model step. Write/execute tools batched with it are skipped and must be retried on the next step, so keep calls that depend on the newly added groups for the next step. Groups cannot be removed during the turn.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -237,7 +237,7 @@ export class ToolPolicyController {
             '## Tool route (current turn)',
             `Policy ${snapshot.id} v${snapshot.version}; active groups: ${active}.`,
             `Router reason: ${snapshot.reason}`,
-            'Use only the exposed tools. Missing capability? Call add_tool_groups — alone, or batched with read-only tools (read_file/glob/grep/web_search/web_fetch); the read-only calls run in that same step and the new groups take effect on the next step. Do not batch it with write/execute tools, and keep calls that depend on the newly added groups in the next step.',
+            'Use only the exposed tools. Missing capability? Call add_tool_groups — alone, or batched with read-only tools (read_file/glob/grep/web_search/web_fetch); the read-only calls run in that same step and the new groups take effect on the next step. Write/execute tools batched with it are skipped (retry them on the next step), and calls that depend on the newly added groups belong in the next step.',
         ];
         if (remaining.length)
             lines.push(`Groups still available: ${remaining.join(', ')}.`);

package/dist/tools/resource-lock.js

@@ -122,7 +122,11 @@ export function resolveResourceLockRequests(capabilities, args) {
         return workspaceWrite();
     }
     if (keys.length === 0) {
-        return capabilities.effect === 'network' ? [] : workspaceWrite();
+        // 显式声明「无资源」(glob/grep 等读枚举、网络只读)即不锁:
+        // 读枚举容忍命令执行期间的瞬时不一致,换取 workspace 写锁期间的读不被压制。
+        if (capabilities.effect === 'network' || capabilities.effect === 'read')
+            return [];
+        return workspaceWrite();
     }
     const mode = modeFor(capabilities.effect);
     const requests = [];

package/dist/tools/ripgrep-client.js

@@ -32,10 +32,18 @@ export function resolveRgPath() {
     const probe = spawnSync(isWin ? 'rg.exe' : 'rg', ['--version'], { stdio: 'ignore', windowsHide: true });
     return probe.status === 0 ? (isWin ? 'rg.exe' : 'rg') : null;
 }
+// 异步树杀:spawnSync('taskkill') 会同步阻塞事件循环(扫树期间流式渲染/并行工具停摆)。
+// 两处调用都是 fire-and-forget(结果由 close 事件收口,finish 有 settled 守卫)。
 function killTree(child) {
     try {
         if (isWin && child.pid != null) {
-            spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+            const killer = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], {
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            killer.on('error', () => {
+                // 进程已退出或终止失败,尽力而为。
+            });
         }
         else {
             child.kill('SIGTERM');

package/dist/ui/batch.js

@@ -519,10 +519,11 @@ const CARET_NONE = '  ';
  *  曾为 4 空格——摘要行(`◆ 探索 …`)与工具调用行之间留白过大,工具名被推得过右(用户实测反馈);
  *  子批再叠 8 空格后层级被拉散。收成 2 空格后每层固定递进 2 列,层级仍清晰但不空旷。 */
 const ENTRY_INDENT = '  ';
-/** 子 agent 批摘要行的缩进(= 两层 entry 缩进)。
- *  子批摘要挂在父批的 entry 行之下,是第二层;硬编码会与 ENTRY_INDENT 脱钩,
- *  故由 ENTRY_INDENT 推得。 */
-export const SUB_BATCH_INDENT = ENTRY_INDENT + ENTRY_INDENT;
+/** 子 agent 批摘要行的缩进(= 三层 entry 缩进)。
+ *  子批摘要挂在父批的 entry 行之下,entry 行本身已带 2 空格;此前取两层(4)时子批
+ *  摘要与父 entry 行仅差 2 列,视觉上挤在同一层级(用户实测反馈)。取三层(6)后,
+ *  子批摘要比父 entry 行深 4 列,父子层级一眼可分;仍由 ENTRY_INDENT 推导,不脱钩。 */
+export const SUB_BATCH_INDENT = ENTRY_INDENT + ENTRY_INDENT + ENTRY_INDENT;
 /** 详情行缩进:5 空格(对齐 entry 行的 "  ▸ " 之后再右移一列,形成层次)。 */
 const DETAIL_INDENT = '     ';
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.6.9",
+  "version": "1.6.10",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 27 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {