mocode-ai 1.4.2 → 1.4.3

package/dist/tools/registry.js

@@ -1,260 +1,52 @@
+import { ToolRuntime } from './tool-runtime.js';
 // 注意:不顶层 import builtins——会构成 registry → builtins → task(sub-agent) → agent/spawn
 // → agent/core → registry 的模块循环。官方默认工具包由 builtins/index.ts 经 installBuiltinTools 自注册。
-import { beginPathMutation, beginWorkspaceMutation, endPathMutation, endWorkspaceMutation, getCurrentTurnMutationState, } from '../rollback/index.js';
-import { enforceSandbox } from '../sandbox/index.js';
-import { resolveResourceLockRequests, toolResourceLockManager } from './resource-lock.js';
-import { validateToolArguments } from './validation.js';
-import { t } from '../i18n/index.js';
-import { isToolErrorOutput } from './result.js';
 /**
- * 可扩展工具注册表。数组实例始终稳定，使已经持有 tools 引用的 agent/LLM 能看到运行时新增工具。
- * 扩展按 source 替换，MCP 重连或配置刷新不会累积旧工具。
- *
- * 官方默认工具包不顶层 import——由装配方经 installBuiltinTools() 注入(见 builtins/index.ts 自注册)。
- * 这是「framework 与 coding preset 分离」的装配缝:@mocode/tool-system 不含 builtin,builtin 是可替换默认包。
- * 未 install 时 tools 为空数组;install 后 rebuild 合并 builtin + 已注册扩展。
- */
-const extensions = new Map();
-let builtinTools = [];
-export const tools = [];
-/** 名字 → 工具 的 O(1) 索引，与 tools 数组在每次 rebuild 时同步重建；findTool 走此索引。 */
-let toolIndex = buildToolIndex(tools);
-function buildToolIndex(list) {
-    return new Map(list.map((tool) => [tool.name, tool]));
-}
-/**
- * 装配官方默认工具包(coding preset)。幂等:重复 install 覆盖上次,不累积。
- * 由 builtins/index.ts 在模块初始化时调用;入口(CLI/stdio host/eval/测试)只需 import builtins 即完成装配。
+ * 默认工具运行时。现有模块级 API 均为薄委托；新调用方可创建独立 ToolRuntime。
+ * 官方默认工具包不顶层 import，由 builtins/index.ts 经 installBuiltinTools() 注入。
  */
+export const defaultToolRuntime = new ToolRuntime();
+/** 稳定数组引用；defaultToolRuntime 重建时仅原地 splice。 */
+export const tools = defaultToolRuntime.tools;
+/** 装配官方默认工具包(coding preset)。幂等:重复 install 覆盖上次,不累积。 */
 export function installBuiltinTools(list) {
-    builtinTools = list;
-    rebuildTools();
+    defaultToolRuntime.installBuiltinTools(list);
 }
 export function registerToolsExtension(sourceOrAdditions, maybeAdditions) {
-    const source = typeof sourceOrAdditions === 'string' ? sourceOrAdditions : 'external';
-    const additions = typeof sourceOrAdditions === 'string' ? (maybeAdditions ?? []) : sourceOrAdditions;
-    extensions.set(source, additions);
-    const rejected = additions
-        .filter((tool) => builtinTools.some((builtin) => builtin.name === tool.name))
-        .map((tool) => tool.name);
-    rebuildTools();
-    return rejected;
+    return typeof sourceOrAdditions === 'string'
+        ? defaultToolRuntime.registerToolsExtension(sourceOrAdditions, maybeAdditions ?? [])
+        : defaultToolRuntime.registerToolsExtension(sourceOrAdditions);
 }
 export function clearToolsExtension(source) {
-    if (extensions.delete(source))
-        rebuildTools();
+    defaultToolRuntime.clearToolsExtension(source);
 }
-function rebuildTools() {
-    const names = new Set();
-    const next = [];
-    for (const tool of [...builtinTools, ...Array.from(extensions.values()).flat()]) {
-        if (names.has(tool.name))
-            continue;
-        names.add(tool.name);
-        next.push(tool);
-    }
-    tools.splice(0, tools.length, ...next);
-    toolIndex = buildToolIndex(next);
-}
-const DEFAULT_CAPABILITIES = Object.freeze({
-    effect: 'unknown',
-    concurrency: 'serial',
-});
 export function findTool(name) {
-    return toolIndex.get(name);
+    return defaultToolRuntime.findTool(name);
 }
 /** 缺少声明或找不到工具时返回保守能力，绝不把未知扩展并发执行。 */
 export function getToolCapabilities(toolOrName) {
-    const tool = typeof toolOrName === 'string' ? findTool(toolOrName) : toolOrName;
-    return tool?.capabilities ?? DEFAULT_CAPABILITIES;
+    return defaultToolRuntime.getToolCapabilities(toolOrName);
 }
 export function getToolResourceKeys(toolOrName, args) {
-    const capabilities = getToolCapabilities(toolOrName);
-    try {
-        return capabilities.resources?.(args) ?? [];
-    }
-    catch {
-        return [];
-    }
+    return defaultToolRuntime.getToolResourceKeys(toolOrName, args);
 }
 /** resource-locked write 是可生成文件 diff/按路径记 rollback 的文件 mutation。 */
 export function isFileMutationCapabilities(capabilities) {
-    return capabilities.effect === 'write' && capabilities.concurrency === 'resource-locked';
+    return defaultToolRuntime.isFileMutationCapabilities(capabilities);
 }
-/** 按工具名判定(兼容入口);热路径请直接复用已解析的 capabilities 走 isFileMutationCapabilities。 */
+/** 按工具名判定(兼容入口);热路径请直接复用已解析的 capabilities。 */
 export function isFileMutationTool(name) {
-    return isFileMutationCapabilities(getToolCapabilities(name));
-}
-function isStructuredOutcome(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.status === 'string' &&
-        typeof value.code === 'string' &&
-        typeof value.retryable === 'boolean' &&
-        typeof value.output === 'string');
-}
-function normalizeOutcome(value, durationMs, changedFiles) {
-    if (isStructuredOutcome(value)) {
-        return {
-            ...value,
-            durationMs: value.durationMs ?? durationMs,
-            changedFiles: value.changedFiles ?? changedFiles,
-        };
-    }
-    const failed = isToolErrorOutput(value);
-    return {
-        status: failed ? 'error' : 'success',
-        code: failed ? 'EXECUTION_ERROR' : 'OK',
-        // Legacy string errors carry no transient classification and are never retried blindly.
-        retryable: false,
-        output: value,
-        changedFiles,
-        durationMs,
-    };
-}
-function terminalOutcome(status, code, output, startedAt, changedFiles = []) {
-    return {
-        status,
-        code,
-        retryable: false,
-        output,
-        changedFiles,
-        durationMs: Date.now() - startedAt,
-    };
-}
-function isTransientExecutionError(error) {
-    if (!error || typeof error !== 'object')
-        return false;
-    const value = error;
-    if (value.name === 'AbortError' || value.name === 'APIUserAbortError')
-        return false;
-    if (value.status === 408 || value.status === 429 || (typeof value.status === 'number' && value.status >= 500))
-        return true;
-    if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED', 'EPIPE'].includes(value.code ?? ''))
-        return true;
-    return (value.name === 'APIConnectionError' ||
-        value.name === 'APIConnectionTimeoutError' ||
-        (typeof value.message === 'string' && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(value.message)));
-}
-function executionErrorOutcome(name, error, startedAt, changedFiles) {
-    const transient = isTransientExecutionError(error);
-    const value = error;
-    const timeout = transient &&
-        (value?.code === 'ETIMEDOUT' ||
-            value?.name === 'APIConnectionTimeoutError' ||
-            (error instanceof Error && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(error.message)));
-    return {
-        status: 'error',
-        code: timeout ? 'TIMEOUT' : transient ? 'NETWORK_ERROR' : 'EXECUTION_ERROR',
-        retryable: transient,
-        output: t('toolError.execution', {
-            name,
-            message: error instanceof Error ? error.message : String(error),
-        }),
-        changedFiles,
-        durationMs: Date.now() - startedAt,
-    };
-}
-/** Execute one tool call while holding its declared locks and capturing rollback state. */
-async function executeToolOnce(tool, args, signal, opts) {
-    const startedAt = Date.now();
-    const capabilities = getToolCapabilities(tool);
-    let mutationVersionBefore;
-    let capturedPath;
-    try {
-        const requests = resolveResourceLockRequests(capabilities, args);
-        return await toolResourceLockManager.withLocks(requests, signal, async () => {
-            opts?.onLockAcquired?.(args);
-            const mutationBefore = getCurrentTurnMutationState();
-            mutationVersionBefore = mutationBefore.version;
-            // Transactional tools own their full write-set capture inside ChangeSet commit.
-            const pathCapture = !capabilities.delegatesResourceLocks &&
-                isFileMutationCapabilities(capabilities) &&
-                typeof args.path === 'string' &&
-                args.path
-                ? beginPathMutation(args.path)
-                : null;
-            capturedPath = pathCapture?.path;
-            // 工作区快照是异步的:它遍历整棵工作树,同步实现会在每次 run_command/MCP 调用前后
-            // 阻塞事件循环数秒(TUI 完全冻结)。await 让 spinner / 走时 / 键鼠在扫描期间继续工作。
-            const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown' ? await beginWorkspaceMutation() : null;
-            let raw;
-            try {
-                raw = await tool.execute(args, {
-                    signal,
-                    callId: opts?.callId,
-                    allowedToolNames: opts?.allowedToolNames,
-                    delegation: opts?.delegation,
-                });
-            }
-            finally {
-                if (pathCapture)
-                    endPathMutation(pathCapture, tool.name);
-                if (workspaceCapture)
-                    await endWorkspaceMutation(workspaceCapture, tool.name);
-            }
-            const mutationAfter = getCurrentTurnMutationState();
-            const changedFiles = mutationAfter.version !== mutationBefore.version
-                ? pathCapture
-                    ? mutationAfter.changedFiles.filter((item) => item.path === pathCapture.path).map((item) => item.path)
-                    : mutationAfter.changedFiles.map((item) => item.path)
-                : [];
-            if (signal?.aborted) {
-                const aborted = terminalOutcome('aborted', 'ABORTED', String(isStructuredOutcome(raw) ? raw.output : raw), startedAt, changedFiles);
-                return isStructuredOutcome(raw) ? { ...aborted, usage: raw.usage } : aborted;
-            }
-            return normalizeOutcome(raw, Date.now() - startedAt, changedFiles);
-        });
-    }
-    catch (error) {
-        const mutationAfter = getCurrentTurnMutationState();
-        const changedFiles = mutationVersionBefore !== undefined && mutationAfter.version !== mutationVersionBefore
-            ? capturedPath
-                ? mutationAfter.changedFiles.filter((item) => item.path === capturedPath).map((item) => item.path)
-                : mutationAfter.changedFiles.map((item) => item.path)
-            : [];
-        if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
-            return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt, changedFiles);
-        }
-        return executionErrorOutcome(tool.name, error, startedAt, changedFiles);
-    }
+    return defaultToolRuntime.isFileMutationTool(name);
 }
 /**
  * 结构化工具调度入口。永不抛错；旧字符串工具在此归一化为 ToolOutcome。
  * 权限仍由 Agent 在展示工具头之前预检，保持现有交互时序。
  */
 export async function executeToolOutcome(name, argsRaw, signal, opts) {
-    const startedAt = Date.now();
-    if (signal?.aborted) {
-        return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt);
-    }
-    const tool = findTool(name);
-    if (!tool) {
-        return terminalOutcome('error', 'UNKNOWN_TOOL', t('toolError.unknown', { name }), startedAt);
-    }
-    let parsed;
-    try {
-        parsed = argsRaw.trim() ? JSON.parse(argsRaw) : {};
-    }
-    catch {
-        return terminalOutcome('error', 'INVALID_JSON', t('toolError.invalidJson', { name, arguments: argsRaw }), startedAt);
-    }
-    const validation = validateToolArguments(tool, parsed);
-    if (!validation.valid) {
-        const hint = opts?.argumentErrorHint?.trim();
-        const message = hint
-            ? `错误:工具 ${name} 参数无效: ${validation.message}\n${hint}`
-            : `错误:工具 ${name} 参数无效: ${validation.message}`;
-        return terminalOutcome('error', validation.code, message, startedAt);
-    }
-    const args = parsed;
-    const sandboxError = enforceSandbox(name, args);
-    if (sandboxError) {
-        return terminalOutcome('denied', 'SANDBOX_DENIED', sandboxError, startedAt);
-    }
-    return executeToolOnce(tool, args, signal, opts);
+    return defaultToolRuntime.executeToolOutcome(name, argsRaw, signal, opts);
 }
 /** 字符串兼容入口：现有调用方、TUI 和 LLM history 无需同步迁移。 */
 export async function executeTool(name, argsRaw, signal, opts) {
-    return (await executeToolOutcome(name, argsRaw, signal, opts)).output;
+    return defaultToolRuntime.executeTool(name, argsRaw, signal, opts);
 }
+export { ToolRuntime } from './tool-runtime.js';

package/dist/tools/router.js

@@ -86,7 +86,7 @@ function parseDecision(raw, available, previousGroups, startedAt) {
  */
 export async function routeToolGroups(request) {
     const startedAt = Date.now();
-    const availableGroups = getAvailableToolRouteGroups();
+    const availableGroups = getAvailableToolRouteGroups(request.tools, request.gateAllows);
     const available = new Set(availableGroups);
     const previousGroups = (request.previousGroups ?? []).filter((group) => available.has(group));
     if (availableGroups.length === 0) {
@@ -98,7 +98,7 @@ Select the minimum sufficient set of capability groups for the user's NEXT agent
 Always-available common tools: ${COMMON_TOOL_NAMES.join(', ')}.
 
 Available groups:
-${toolRouteCatalog(availableGroups)}
+${request.tools ? toolRouteCatalog(availableGroups, request.tools) : toolRouteCatalog(availableGroups)}
 
 Routing rules:
 - You MUST call ${ROUTER_TOOL_NAME} exactly once and emit no prose.
@@ -125,7 +125,9 @@ Routing rules:
         { role: 'user', content: user },
     ];
     try {
-        const result = await chat(messages, {}, request.signal, [routeSelectorTool(availableGroups)]);
+        const result = await (request.transport ?? chat)(messages, {}, request.signal, [
+            routeSelectorTool(availableGroups),
+        ]);
         const call = result.toolCalls.find((toolCall) => toolCall.name === ROUTER_TOOL_NAME);
         const parsed = call ? parseDecision(call.arguments, available, previousGroups, startedAt) : null;
         if (parsed)

package/dist/tools/tool-runtime.js

@@ -0,0 +1,267 @@
+import { beginPathMutation as defaultBeginPathMutation, beginWorkspaceMutation as defaultBeginWorkspaceMutation, endPathMutation as defaultEndPathMutation, endWorkspaceMutation as defaultEndWorkspaceMutation, getCurrentTurnMutationState as defaultGetCurrentTurnMutationState, } from '../rollback/index.js';
+import { enforceSandbox as defaultEnforceSandbox } from '../sandbox/index.js';
+import { t } from '../i18n/index.js';
+import { resolveResourceLockRequests as defaultResolveResourceLockRequests, toolResourceLockManager, } from './resource-lock.js';
+import { isToolErrorOutput } from './result.js';
+import { validateToolArguments } from './validation.js';
+const DEFAULT_CAPABILITIES = Object.freeze({
+    effect: 'unknown',
+    concurrency: 'serial',
+});
+const DEFAULT_DEPENDENCIES = {
+    enforceSandbox: defaultEnforceSandbox,
+    resolveResourceLockRequests: defaultResolveResourceLockRequests,
+    resourceLockManager: toolResourceLockManager,
+    beginPathMutation: defaultBeginPathMutation,
+    endPathMutation: defaultEndPathMutation,
+    beginWorkspaceMutation: defaultBeginWorkspaceMutation,
+    endWorkspaceMutation: defaultEndWorkspaceMutation,
+    getCurrentTurnMutationState: defaultGetCurrentTurnMutationState,
+};
+function buildToolIndex(list) {
+    return new Map(list.map((tool) => [tool.name, tool]));
+}
+function isStructuredOutcome(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.status === 'string' &&
+        typeof value.code === 'string' &&
+        typeof value.retryable === 'boolean' &&
+        typeof value.output === 'string');
+}
+function normalizeOutcome(value, durationMs, changedFiles) {
+    if (isStructuredOutcome(value)) {
+        return {
+            ...value,
+            durationMs: value.durationMs ?? durationMs,
+            changedFiles: value.changedFiles ?? changedFiles,
+        };
+    }
+    const failed = isToolErrorOutput(value);
+    return {
+        status: failed ? 'error' : 'success',
+        code: failed ? 'EXECUTION_ERROR' : 'OK',
+        retryable: false,
+        output: value,
+        changedFiles,
+        durationMs,
+    };
+}
+function terminalOutcome(status, code, output, startedAt, changedFiles = []) {
+    return {
+        status,
+        code,
+        retryable: false,
+        output,
+        changedFiles,
+        durationMs: Date.now() - startedAt,
+    };
+}
+function isTransientExecutionError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const value = error;
+    if (value.name === 'AbortError' || value.name === 'APIUserAbortError')
+        return false;
+    if (value.status === 408 || value.status === 429 || (typeof value.status === 'number' && value.status >= 500))
+        return true;
+    if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED', 'EPIPE'].includes(value.code ?? ''))
+        return true;
+    return (value.name === 'APIConnectionError' ||
+        value.name === 'APIConnectionTimeoutError' ||
+        (typeof value.message === 'string' && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(value.message)));
+}
+function executionErrorOutcome(name, error, startedAt, changedFiles) {
+    const transient = isTransientExecutionError(error);
+    const value = error;
+    const timeout = transient &&
+        (value?.code === 'ETIMEDOUT' ||
+            value?.name === 'APIConnectionTimeoutError' ||
+            (error instanceof Error && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(error.message)));
+    return {
+        status: 'error',
+        code: timeout ? 'TIMEOUT' : transient ? 'NETWORK_ERROR' : 'EXECUTION_ERROR',
+        retryable: transient,
+        output: t('toolError.execution', {
+            name,
+            message: error instanceof Error ? error.message : String(error),
+        }),
+        changedFiles,
+        durationMs: Date.now() - startedAt,
+    };
+}
+/** Instance-scoped tool registry and executor. Builtins are installed explicitly to avoid a registry/builtins cycle. */
+export class ToolRuntime {
+    /** Stable array identity: rebuilds always splice so existing consumers observe registration changes. */
+    tools = [];
+    extensions = new Map();
+    installedBuiltinTools = [];
+    toolIndex = buildToolIndex(this.tools);
+    dependencies;
+    constructor(dependencies = {}) {
+        this.dependencies = { ...DEFAULT_DEPENDENCIES, ...dependencies };
+    }
+    /** The currently installed builtin list, retained by reference for compatibility with the global registry. */
+    get builtinTools() {
+        return this.installedBuiltinTools;
+    }
+    installBuiltinTools(list) {
+        this.installedBuiltinTools = list;
+        this.rebuildTools();
+    }
+    registerToolsExtension(sourceOrAdditions, maybeAdditions) {
+        const source = typeof sourceOrAdditions === 'string' ? sourceOrAdditions : 'external';
+        const additions = typeof sourceOrAdditions === 'string' ? (maybeAdditions ?? []) : sourceOrAdditions;
+        this.extensions.set(source, additions);
+        const rejected = additions
+            .filter((tool) => this.installedBuiltinTools.some((builtin) => builtin.name === tool.name))
+            .map((tool) => tool.name);
+        this.rebuildTools();
+        return rejected;
+    }
+    clearToolsExtension(source) {
+        if (this.extensions.delete(source))
+            this.rebuildTools();
+    }
+    findTool(name) {
+        return this.toolIndex.get(name);
+    }
+    /** 缺少声明或找不到工具时返回保守能力，绝不把未知扩展并发执行。 */
+    getToolCapabilities(toolOrName) {
+        const tool = typeof toolOrName === 'string' ? this.findTool(toolOrName) : toolOrName;
+        return tool?.capabilities ?? DEFAULT_CAPABILITIES;
+    }
+    getToolResourceKeys(toolOrName, args) {
+        const capabilities = this.getToolCapabilities(toolOrName);
+        try {
+            return capabilities.resources?.(args) ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** resource-locked write 是可生成文件 diff/按路径记 rollback 的文件 mutation。 */
+    isFileMutationCapabilities(capabilities) {
+        return capabilities.effect === 'write' && capabilities.concurrency === 'resource-locked';
+    }
+    /** 按工具名判定(兼容入口);热路径请直接复用已解析的 capabilities。 */
+    isFileMutationTool(name) {
+        return this.isFileMutationCapabilities(this.getToolCapabilities(name));
+    }
+    /** 结构化工具调度入口。永不抛错；旧字符串工具在此归一化为 ToolOutcome。 */
+    async executeToolOutcome(name, argsRaw, signal, opts) {
+        const startedAt = Date.now();
+        if (signal?.aborted) {
+            return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt);
+        }
+        const tool = this.findTool(name);
+        if (!tool) {
+            return terminalOutcome('error', 'UNKNOWN_TOOL', t('toolError.unknown', { name }), startedAt);
+        }
+        let parsed;
+        try {
+            parsed = argsRaw.trim() ? JSON.parse(argsRaw) : {};
+        }
+        catch {
+            return terminalOutcome('error', 'INVALID_JSON', t('toolError.invalidJson', { name, arguments: argsRaw }), startedAt);
+        }
+        const validation = validateToolArguments(tool, parsed);
+        if (!validation.valid) {
+            const hint = opts?.argumentErrorHint?.trim();
+            const message = hint
+                ? `错误:工具 ${name} 参数无效: ${validation.message}\n${hint}`
+                : `错误:工具 ${name} 参数无效: ${validation.message}`;
+            return terminalOutcome('error', validation.code, message, startedAt);
+        }
+        const args = parsed;
+        try {
+            const sandboxError = this.dependencies.enforceSandbox(name, args);
+            if (sandboxError) {
+                return terminalOutcome('denied', 'SANDBOX_DENIED', sandboxError, startedAt);
+            }
+            return await this.executeToolOnce(tool, args, signal, opts);
+        }
+        catch (error) {
+            return executionErrorOutcome(name, error, startedAt, []);
+        }
+    }
+    /** 字符串兼容入口：现有调用方、TUI 和 LLM history 无需同步迁移。 */
+    async executeTool(name, argsRaw, signal, opts) {
+        return (await this.executeToolOutcome(name, argsRaw, signal, opts)).output;
+    }
+    rebuildTools() {
+        const names = new Set();
+        const next = [];
+        for (const tool of [...this.installedBuiltinTools, ...Array.from(this.extensions.values()).flat()]) {
+            if (names.has(tool.name))
+                continue;
+            names.add(tool.name);
+            next.push(tool);
+        }
+        this.tools.splice(0, this.tools.length, ...next);
+        this.toolIndex = buildToolIndex(next);
+    }
+    /** Execute one tool call while holding its declared locks and capturing rollback state. */
+    async executeToolOnce(tool, args, signal, opts) {
+        const startedAt = Date.now();
+        const capabilities = this.getToolCapabilities(tool);
+        let mutationVersionBefore;
+        let capturedPath;
+        try {
+            const requests = this.dependencies.resolveResourceLockRequests(capabilities, args);
+            return await this.dependencies.resourceLockManager.withLocks(requests, signal, async () => {
+                opts?.onLockAcquired?.(args);
+                const mutationBefore = this.dependencies.getCurrentTurnMutationState();
+                mutationVersionBefore = mutationBefore.version;
+                const pathCapture = !capabilities.delegatesResourceLocks &&
+                    this.isFileMutationCapabilities(capabilities) &&
+                    typeof args.path === 'string' &&
+                    args.path
+                    ? this.dependencies.beginPathMutation(args.path)
+                    : null;
+                capturedPath = pathCapture?.path;
+                const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown'
+                    ? await this.dependencies.beginWorkspaceMutation()
+                    : null;
+                let raw;
+                try {
+                    raw = await tool.execute(args, {
+                        signal,
+                        callId: opts?.callId,
+                        allowedToolNames: opts?.allowedToolNames,
+                        delegation: opts?.delegation,
+                    });
+                }
+                finally {
+                    if (pathCapture)
+                        this.dependencies.endPathMutation(pathCapture, tool.name);
+                    if (workspaceCapture)
+                        await this.dependencies.endWorkspaceMutation(workspaceCapture, tool.name);
+                }
+                const mutationAfter = this.dependencies.getCurrentTurnMutationState();
+                const changedFiles = mutationAfter.version !== mutationBefore.version
+                    ? pathCapture
+                        ? mutationAfter.changedFiles.filter((item) => item.path === pathCapture.path).map((item) => item.path)
+                        : mutationAfter.changedFiles.map((item) => item.path)
+                    : [];
+                if (signal?.aborted) {
+                    const aborted = terminalOutcome('aborted', 'ABORTED', String(isStructuredOutcome(raw) ? raw.output : raw), startedAt, changedFiles);
+                    return isStructuredOutcome(raw) ? { ...aborted, usage: raw.usage } : aborted;
+                }
+                return normalizeOutcome(raw, Date.now() - startedAt, changedFiles);
+            });
+        }
+        catch (error) {
+            const mutationAfter = this.dependencies.getCurrentTurnMutationState();
+            const changedFiles = mutationVersionBefore !== undefined && mutationAfter.version !== mutationVersionBefore
+                ? capturedPath
+                    ? mutationAfter.changedFiles.filter((item) => item.path === capturedPath).map((item) => item.path)
+                    : mutationAfter.changedFiles.map((item) => item.path)
+                : [];
+            if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
+                return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt, changedFiles);
+            }
+            return executionErrorOutcome(tool.name, error, startedAt, changedFiles);
+        }
+    }
+}

package/dist/ui/layout-internal/content-write.js

@@ -492,6 +492,10 @@ export function isLastContentRowBlank() {
 export function normalizeMutationBoundary() {
     if (!state.active || !ui.isTTY)
         return;
+    // 空缓冲(turn 首工具且此前无任何内容)不归一:normalizeTrailingBlankRows 会凭空
+    // push 一条空行,导致屏顶多一条空白(首条摘要前多一空行)。
+    if (content.committedRows() === 0 && content.currentRowRaw() === null)
+        return;
     if (state.mdActive)
         commitMd();
     const totalBefore = content.totalRows();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {
@@ -20,9 +20,12 @@
   },
   "scripts": {
     "start": "tsx src/index.ts",
-    "build": "tsc -p tsconfig.build.json",
+    "build": "npm run build --workspace @mocode/protocol && npm run build --workspace @mocode/runtime && tsc -p tsconfig.build.json",
+    "build:electron": "npm run build && npm run check:electron-boundary && npm run typecheck --workspace mocode-work && npm run build --workspace mocode-work && npm run typecheck --workspace mocode-pet-app && npm run build --workspace mocode-pet-app && npm run smoke:runtime-host",
     "test": "tsc -p tsconfig.test-build.json && node --test --experimental-test-isolation=none \"dist-tests/tests/*.test.js\"",
-    "typecheck": "tsc --noEmit && tsc -p tests/tsconfig.json && tsc -p evals/tsconfig.json",
+    "typecheck": "npm run typecheck --workspace @mocode/protocol && npm run typecheck --workspace @mocode/runtime && tsc --noEmit && tsc -p tests/tsconfig.json && tsc -p evals/tsconfig.json",
+    "check:electron-boundary": "npm run check:electron-boundary --workspace @mocode/runtime",
+    "smoke:runtime-host": "npm run smoke:host --workspace @mocode/runtime",
     "lint": "eslint .",
     "lint:check": "eslint .",
     "lint:fix": "eslint . --fix",
@@ -43,6 +46,7 @@
     "ws": "8.21.0"
   },
   "devDependencies": {
+    "@mocode/protocol": "0.0.0",
     "@types/node": "^22.0.0",
     "@types/ws": "8.5.13",
     "eslint": "^9.39.5",