mocode-ai 0.6.7 → 0.6.9

package/dist/rollback/index.js

@@ -1,46 +1,199 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { config } from '../config/index.js';
 import { truncateDisplay } from '../ui/render.js';
 import { toText } from '../context/utils.js';
 let turnIdCounter = 0;
 let currentTurnId = 0;
+let sequenceCounter = 0;
 let turns = [];
 let snapshots = [];
-const MUTATION_TOOLS = new Set(['write_file', 'edit_file']);
-/** 规整成 cwd 相对路径(快照存相对,跨 /resume 同项目可识别;resolve 已归一 ./ 和 ..)。 */
+const rootDir = () => path.resolve(process.cwd());
+function isInside(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+/** 规整成 cwd 相对路径；所有持久化快照均使用此格式。 */
 function toRel(p) {
     try {
-        const rel = path.relative(process.cwd(), path.resolve(p));
-        return rel === '' ? p : rel;
+        const rel = path.relative(rootDir(), path.resolve(p));
+        return rel === '' ? '.' : rel;
     }
     catch {
         return p;
     }
 }
-/** agent:runAgent 入口调——开新轮次。firstLine 已由调用方截断到 40。 */
+/** 防止损坏/篡改的 snapshots.json 在恢复时写出工作区。 */
+function safeFullPath(rel) {
+    const root = rootDir();
+    const full = path.resolve(root, rel);
+    return full !== root && isInside(root, full) ? full : null;
+}
+function readState(full) {
+    try {
+        const stat = lstatSync(full);
+        const mode = stat.mode & 0o777;
+        if (stat.isSymbolicLink()) {
+            return { kind: 'symlink', data: readlinkSync(full), mode };
+        }
+        if (stat.isDirectory())
+            return { kind: 'directory', mode };
+        if (stat.isFile()) {
+            return { kind: 'file', data: readFileSync(full).toString('base64'), mode };
+        }
+    }
+    catch {
+        // 不存在或不可读均按 missing；工具若最终也不可读，不会产生伪变化。
+    }
+    return { kind: 'missing' };
+}
+function sameState(a, b) {
+    return a.kind === b.kind && a.data === b.data && a.mode === b.mode;
+}
+function stateFromSnapshot(snapshot) {
+    if (snapshot.kind) {
+        return { kind: snapshot.kind, data: snapshot.before ?? undefined, mode: snapshot.mode };
+    }
+    // v1 向后兼容：before 是 UTF-8 文本，null 表示原文件不存在。
+    if (snapshot.before === null)
+        return { kind: 'missing' };
+    return {
+        kind: 'file',
+        data: Buffer.from(snapshot.before, 'utf8').toString('base64'),
+    };
+}
+function snapshotFromState(rel, state, sequence, op, createdParents = []) {
+    return {
+        turnId: currentTurnId,
+        path: rel,
+        before: state.data ?? null,
+        kind: state.kind,
+        encoding: state.kind === 'file' ? 'base64' : undefined,
+        mode: state.mode,
+        sequence,
+        ops: [op],
+        createdParents: createdParents.length > 0 ? createdParents : undefined,
+    };
+}
+/** 同轮同路径只保留最早的 before；后续实际改动仅合并工具名。 */
+function addSnapshot(next) {
+    if (next.turnId <= 0)
+        return;
+    const existingIndex = snapshots.findIndex((item) => item.turnId === next.turnId && item.path === next.path);
+    if (existingIndex < 0) {
+        snapshots.push(next);
+        return;
+    }
+    const existing = snapshots[existingIndex];
+    const existingSequence = existing.sequence ?? Number.MAX_SAFE_INTEGER;
+    const nextSequence = next.sequence ?? Number.MAX_SAFE_INTEGER;
+    const ops = new Set([...(existing.ops ?? []), ...(next.ops ?? [])]);
+    if (nextSequence < existingSequence) {
+        snapshots[existingIndex] = { ...next, ops: [...ops] };
+    }
+    else {
+        existing.ops = [...ops];
+    }
+}
+function missingParents(full) {
+    const root = rootDir();
+    const result = [];
+    let current = path.dirname(full);
+    while (current !== root && isInside(root, current)) {
+        if (existsSync(current))
+            break;
+        result.push(toRel(current));
+        current = path.dirname(current);
+    }
+    return result;
+}
+/** agent 主轮入口调用；子 agent 共享当前 turnId，不另开轮次。 */
 export function beginTurn(firstLine) {
     turnIdCounter += 1;
     currentTurnId = turnIdCounter;
     turns.push({ turnId: currentTurnId, firstLine });
 }
-/** tools/registry:write_file/edit_file 执行前调——记 before 快照(在 tool.execute 之前读)。 */
-export function recordMutation(p) {
-    const rel = toRel(p);
-    let before;
-    try {
-        before = readFileSync(path.resolve(p), 'utf8');
+/** 单路径工具执行前捕获，不立即记账；失败/no-op 不应出现在 rollback 中。 */
+export function beginPathMutation(p) {
+    const full = path.resolve(p);
+    return {
+        path: toRel(full),
+        before: readState(full),
+        sequence: ++sequenceCounter,
+        createdParents: missingParents(full),
+    };
+}
+/** 单路径工具执行后提交，仅当磁盘状态确实变化时写入事务日志。 */
+export function endPathMutation(capture, op) {
+    const full = safeFullPath(capture.path);
+    if (!full)
+        return;
+    const after = readState(full);
+    if (!sameState(capture.before, after)) {
+        addSnapshot(snapshotFromState(capture.path, capture.before, capture.sequence, op, capture.createdParents));
     }
-    catch {
-        before = null; // 文件不存在(新建)
+    // write_file 会递归创建父目录；即使最终写文件失败，这些目录也是本轮真实副作用。
+    for (const parentRel of capture.createdParents) {
+        const parent = safeFullPath(parentRel);
+        if (parent && readState(parent).kind !== 'missing') {
+            addSnapshot(snapshotFromState(parentRel, { kind: 'missing' }, capture.sequence, op));
+        }
+    }
+}
+function isWorkspaceExcluded(full) {
+    const base = path.basename(full).toLowerCase();
+    // Git 元数据必须永久排除以保护 index；依赖树/代码索引是可再生运行时状态，
+    // 扫描它们既昂贵，也可能把后台 daemon 的写入误判成模型改动。
+    if (base === '.git' || base === '.codegraph' || base === 'node_modules')
+        return true;
+    const sessionDir = path.resolve(config.sessionDir);
+    return isInside(sessionDir, full);
+}
+function scanWorkspace() {
+    const entries = new Map();
+    const walk = (dir) => {
+        let children;
+        try {
+            children = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const child of children) {
+            const full = path.join(dir, child.name);
+            if (isWorkspaceExcluded(full))
+                continue;
+            const state = readState(full);
+            if (state.kind === 'missing')
+                continue;
+            const rel = toRel(full);
+            entries.set(rel, state);
+            if (state.kind === 'directory')
+                walk(full);
+        }
+    };
+    walk(rootDir());
+    return entries;
+}
+/** run_command/MCP 前调用。不跟随 symlink，并排除 .git、会话快照、依赖树与代码索引。 */
+export function beginWorkspaceMutation() {
+    return { sequence: ++sequenceCounter, entries: scanWorkspace() };
+}
+/** 不透明工具执行后比较整个工作区，把实际变化压入当前轮事务日志。 */
+export function endWorkspaceMutation(capture, op) {
+    const after = scanWorkspace();
+    const paths = new Set([...capture.entries.keys(), ...after.keys()]);
+    for (const rel of paths) {
+        const beforeState = capture.entries.get(rel) ?? { kind: 'missing' };
+        const afterState = after.get(rel) ?? { kind: 'missing' };
+        if (sameState(beforeState, afterState))
+            continue;
+        addSnapshot(snapshotFromState(rel, beforeState, capture.sequence, op));
     }
-    snapshots.push({ turnId: currentTurnId, path: rel, before });
 }
-/** 列出当前可回滚的轮次(1-based 序号由调用方显示)。 */
 export function listTurns() {
     return turns.slice();
 }
-/** history 里第 (n+1) 条 user 消息的下标(= 截断点);无则 history.length。 */
 function findCutoffIndex(n, history) {
     let seen = 0;
     for (let i = 0; i < history.length; i++) {
@@ -53,156 +206,195 @@ function findCutoffIndex(n, history) {
     return history.length;
 }
 /**
- * 规划回滚到第 n 轮(1-based):算截断点 + 被删轮次里涉及的文件改动(按 path 去重)。
- * 调用方据 changes 逐 path 问保留 / 撤销;snapshotAvailable=false 的项无法撤销。
+ * 规划回滚到第 n 轮。changes 只来自已确认发生磁盘差异的事务快照，
+ * 因此失败/no-op 工具不会被误报；子 agent、run_command、MCP 变化同样可见。
  */
 export function planRollback(n, history) {
     const cutoffTurnId = turns[n - 1]?.turnId ?? 0;
     const cutoffIndex = findCutoffIndex(n, history);
     const order = [];
     const map = new Map();
-    for (let i = cutoffIndex; i < history.length; i++) {
-        const tcs = history[i].tool_calls;
-        if (!Array.isArray(tcs))
+    const ensure = (rel) => {
+        let change = map.get(rel);
+        if (!change) {
+            change = { path: rel, ops: [], snapshotAvailable: true };
+            map.set(rel, change);
+            order.push(rel);
+        }
+        return change;
+    };
+    for (const snapshot of snapshots) {
+        if (snapshot.turnId <= cutoffTurnId)
             continue;
-        for (const tc of tcs) {
-            const name = tc?.function?.name ?? '';
-            if (!MUTATION_TOOLS.has(name))
-                continue;
-            const argRaw = tc?.function?.arguments ?? '';
-            let p = '';
-            try {
-                p = String(JSON.parse(argRaw).path ?? '');
-            }
-            catch {
-                p = '';
-            }
-            if (!p)
-                continue;
-            const rel = toRel(p);
-            let fc = map.get(rel);
-            if (!fc) {
-                fc = { path: rel, ops: [], snapshotAvailable: false };
-                map.set(rel, fc);
-                order.push(rel);
-            }
-            fc.ops.push(name);
+        const change = ensure(snapshot.path);
+        for (const op of snapshot.ops ?? ['file_change']) {
+            if (!change.ops.includes(op))
+                change.ops.push(op);
         }
     }
-    const changes = order.map((rel) => {
-        const fc = map.get(rel);
-        fc.snapshotAvailable = snapshots.some((s) => s.turnId > cutoffTurnId && s.path === rel);
-        return fc;
-    });
-    return { n, cutoffIndex, cutoffTurnId, changes };
+    return {
+        n,
+        cutoffIndex,
+        cutoffTurnId,
+        changes: order.map((rel) => map.get(rel)),
+    };
 }
-/**
- * 执行回滚:原地截断 history 到 cutoffIndex + 按选择恢复文件 + 裁剪 turns/snapshots。
- * revertPaths 为选「撤销」的相对路径集合。返回删除消息数 + 撤销文件列表。
- */
-export function applyRollback(plan, history, revertPaths) {
-    const deletedMsgs = history.length - plan.cutoffIndex;
-    history.length = plan.cutoffIndex; // 原地截断(保 history[0] system + 可能的 index-1 摘要)
-    const revertedFiles = [];
-    for (const rel of revertPaths) {
-        // turnId > cutoff 的最小 turnId 快照 = 所选轮末状态
-        let pick = null;
-        for (const s of snapshots) {
-            if (s.path !== rel)
-                continue;
-            if (s.turnId <= plan.cutoffTurnId)
-                continue;
-            if (!pick || s.turnId < pick.turnId)
-                pick = s;
+function depth(rel) {
+    return rel.split(/[\\/]+/).length;
+}
+function restoreSnapshot(snapshot) {
+    const full = safeFullPath(snapshot.path);
+    if (!full)
+        return false;
+    const state = stateFromSnapshot(snapshot);
+    try {
+        if (state.kind === 'missing') {
+            rmSync(full, { recursive: true, force: true });
+            for (const parentRel of snapshot.createdParents ?? []) {
+                const parent = safeFullPath(parentRel);
+                if (!parent)
+                    continue;
+                try {
+                    rmdirSync(parent);
+                }
+                catch {
+                    // 仅删除本轮创建且当前为空的父目录；非空/已不存在均保持。
+                }
+            }
+            return true;
         }
-        if (!pick)
-            continue; // 无快照(不应发生:repl 已据 snapshotAvailable 过滤)
-        const full = path.resolve(rel);
-        try {
-            if (pick.before === null) {
-                unlinkSync(full);
+        if (state.kind === 'directory') {
+            const current = readState(full);
+            if (current.kind !== 'missing' && current.kind !== 'directory') {
+                rmSync(full, { recursive: true, force: true });
+            }
+            mkdirSync(full, { recursive: true });
+        }
+        else {
+            mkdirSync(path.dirname(full), { recursive: true });
+            rmSync(full, { recursive: true, force: true });
+            if (state.kind === 'file') {
+                writeFileSync(full, Buffer.from(state.data ?? '', 'base64'));
             }
             else {
-                writeFileSync(full, pick.before, 'utf8');
+                symlinkSync(state.data ?? '', full);
             }
-            revertedFiles.push(rel);
         }
-        catch {
-            // 恢复失败不阻断回滚(文件可能被外部删 / 锁)
+        if (state.mode !== undefined && state.kind !== 'symlink')
+            chmodSync(full, state.mode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 执行回滚：恢复工作树快照并截断对话/事务；从不调用 Git。 */
+export function applyRollback(plan, history, revertPaths) {
+    const deletedMsgs = history.length - plan.cutoffIndex;
+    history.length = plan.cutoffIndex;
+    const picks = new Map();
+    for (const snapshot of snapshots) {
+        if (snapshot.turnId <= plan.cutoffTurnId || !revertPaths.has(snapshot.path))
+            continue;
+        const existing = picks.get(snapshot.path);
+        if (!existing ||
+            snapshot.turnId < existing.turnId ||
+            (snapshot.turnId === existing.turnId &&
+                (snapshot.sequence ?? Number.MAX_SAFE_INTEGER) <
+                    (existing.sequence ?? Number.MAX_SAFE_INTEGER))) {
+            picks.set(snapshot.path, snapshot);
         }
     }
-    // 裁剪:保 turnId ≤ cutoff(删掉被回滚掉的轮次及其快照)
-    turns = turns.filter((t) => t.turnId <= plan.cutoffTurnId);
-    snapshots = snapshots.filter((s) => s.turnId <= plan.cutoffTurnId);
+    const selected = [...picks.values()];
+    // 先深到浅删除本轮新建项，再浅到深恢复原目录/文件。
+    const removals = selected
+        .filter((item) => stateFromSnapshot(item).kind === 'missing')
+        .sort((a, b) => depth(b.path) - depth(a.path));
+    const restores = selected
+        .filter((item) => stateFromSnapshot(item).kind !== 'missing')
+        .sort((a, b) => depth(a.path) - depth(b.path));
+    const revertedFiles = [];
+    for (const snapshot of [...removals, ...restores]) {
+        if (restoreSnapshot(snapshot))
+            revertedFiles.push(snapshot.path);
+    }
+    turns = turns.filter((turn) => turn.turnId <= plan.cutoffTurnId);
+    snapshots = snapshots.filter((snapshot) => snapshot.turnId <= plan.cutoffTurnId);
+    currentTurnId = turns.at(-1)?.turnId ?? 0;
     return { deletedMsgs, revertedFiles };
 }
-/** compact 摘要成功后调:按存活轮次数裁剪(M = 新 history 里 user 消息数)。 */
 export function pruneAfterCompaction(history) {
-    const m = history.filter((msg) => msg.role === 'user').length;
-    turns = m >= turns.length ? turns : turns.slice(-m);
-    const alive = new Set(turns.map((t) => t.turnId));
-    snapshots = snapshots.filter((s) => alive.has(s.turnId));
+    const count = history.filter((message) => message.role === 'user').length;
+    turns = count >= turns.length ? turns : turns.slice(-count);
+    const alive = new Set(turns.map((turn) => turn.turnId));
+    snapshots = snapshots.filter((snapshot) => alive.has(snapshot.turnId));
 }
-/** /clear 调:清空全部状态。 */
 export function resetState() {
     turns = [];
     snapshots = [];
     turnIdCounter = 0;
     currentTurnId = 0;
+    sequenceCounter = 0;
 }
-/**
- * 无 snapshots 文件时(/resume 旧会话)从 history 重建 turns(扫 user 消息,1..M,
- * 无快照 → 那些轮次的文件改动不可撤销)。turnIdCounter = M,后续新轮次从 M+1 续。
- */
 export function rebuildFromHistory(history) {
-    const out = [];
-    for (let i = 0; i < history.length; i++) {
-        if (history[i].role !== 'user')
+    const rebuilt = [];
+    for (const message of history) {
+        if (message.role !== 'user')
             continue;
-        const first = toText(history[i].content).split('\n')[0] ?? '';
-        out.push({ turnId: out.length + 1, firstLine: truncateDisplay(first, 40) });
+        const first = toText(message.content).split('\n')[0] ?? '';
+        rebuilt.push({
+            turnId: rebuilt.length + 1,
+            firstLine: truncateDisplay(first, 40),
+        });
     }
-    turns = out;
+    turns = rebuilt;
     snapshots = [];
-    turnIdCounter = out.length;
+    turnIdCounter = rebuilt.length;
     currentTurnId = 0;
+    sequenceCounter = 0;
 }
 function snapshotsPath(id) {
-    // 新式目录,回退旧式文件
-    const newPath = path.join(config.sessionDir, id, 'snapshots.json');
-    if (existsSync(newPath))
-        return newPath;
+    const current = path.join(config.sessionDir, id, 'snapshots.json');
+    if (existsSync(current))
+        return current;
     return path.join(config.sessionDir, `${id}.snapshots.json`);
 }
-/** 随 saveSession 调:把 turns + snapshots 落盘(turns 为空则跳过,不写空文件)。 */
 export function persistSnapshots(id) {
-    if (turns.length === 0)
-        return;
+    const dir = path.join(config.sessionDir, id);
+    const current = path.join(dir, 'snapshots.json');
+    const legacy = path.join(config.sessionDir, `${id}.snapshots.json`);
     try {
-        const dir = path.join(config.sessionDir, id);
+        if (turns.length === 0) {
+            // 全量回滚后不能保留旧快照，否则 /resume 可能重新加载已删除轮次。
+            if (existsSync(current))
+                unlinkSync(current);
+            if (existsSync(legacy))
+                unlinkSync(legacy);
+            return;
+        }
         mkdirSync(dir, { recursive: true });
-        writeFileSync(path.join(dir, 'snapshots.json'), JSON.stringify({ version: 1, turns, snapshots }), 'utf8');
+        writeFileSync(current, JSON.stringify({ version: 2, turns, snapshots }), 'utf8');
+        // 迁移后的旧式扁平快照不再需要，避免磁盘上残留已回滚内容。
+        if (existsSync(legacy))
+            unlinkSync(legacy);
     }
     catch {
-        // 落盘失败不阻断(回滚仅失去跨重启能力)
+        // 落盘失败不阻断会话；只失去跨重启回滚能力。
     }
 }
-/**
- * /resume / --resume 加载会话后调:读回 turns + snapshots。成功返 true(状态已覆盖);
- * 失败 / 无文件返 false,调用方应改调 rebuildFromHistory(history) 兜底。
- */
 export function loadSnapshots(id) {
-    const p = snapshotsPath(id);
-    if (!existsSync(p))
+    const snapshotFile = snapshotsPath(id);
+    if (!existsSync(snapshotFile))
         return false;
     try {
-        const rec = JSON.parse(readFileSync(p, 'utf8'));
-        if (!rec || !Array.isArray(rec.turns) || !Array.isArray(rec.snapshots)) {
+        const record = JSON.parse(readFileSync(snapshotFile, 'utf8'));
+        if (!record || !Array.isArray(record.turns) || !Array.isArray(record.snapshots)) {
             return false;
         }
-        turns = rec.turns;
-        snapshots = rec.snapshots;
-        turnIdCounter = turns.reduce((mx, t) => Math.max(mx, t.turnId), 0);
+        turns = record.turns;
+        snapshots = record.snapshots;
+        turnIdCounter = turns.reduce((max, turn) => Math.max(max, turn.turnId), 0);
+        sequenceCounter = snapshots.reduce((max, snapshot) => Math.max(max, snapshot.sequence ?? 0), 0);
         currentTurnId = 0;
         return true;
     }

package/dist/session/persist.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { config } from '../config/index.js';
 import { truncateDisplay } from '../ui/render.js';
@@ -44,7 +44,7 @@ function firstUserOf(history) {
 function sessionPath(id) {
     return path.join(config.sessionDir, id, 'session.json');
 }
-/** 保存会话到磁盘(history.length<=1 时跳过写盘,只返 meta)。 */
+/** 保存会话到磁盘。全新且只有 system 的会话不创建文件；已有会话即使回滚为空也必须覆盖旧记录。 */
 export function saveSession(history, id) {
     const meta = {
         id,
@@ -52,12 +52,18 @@ export function saveSession(history, id) {
         model: config.model,
         firstUser: history.length > 1 ? firstUserOf(history) : '',
     };
-    if (history.length <= 1)
-        return meta; // 仅 system,不落盘
+    const currentPath = sessionPath(id);
+    const legacyPath = path.join(config.sessionDir, `${id}.json`);
+    if (history.length <= 1 && !existsSync(currentPath) && !existsSync(legacyPath)) {
+        return meta;
+    }
     const dir = path.join(config.sessionDir, id);
     mkdirSync(dir, { recursive: true });
     const record = { ...meta, history };
-    writeFileSync(sessionPath(id), JSON.stringify(record), 'utf8');
+    writeFileSync(currentPath, JSON.stringify(record), 'utf8');
+    // 一旦写入新式目录，删除旧式扁平副本，避免已回滚消息仍残留在磁盘。
+    if (existsSync(legacyPath))
+        unlinkSync(legacyPath);
     return meta;
 }
 /** 加载会话;不存在 / 损坏返 null(不抛)。优先新式目录,回退旧式文件。 */

package/dist/tools/builtins/ask-human.js

@@ -1,5 +1,6 @@
 import { promptIntervention } from '../../ui/intervention.js';
 import { sendState } from '../../pet/bridge.js';
+import { t } from '../../i18n/index.js';
 /** 把单个选项元素安全地转成 {label, detail}。LLM 有时传对象而不是字符串,这里提取可读字段。 */
 function optionToChoice(o) {
     if (o === null || o === undefined)
@@ -148,11 +149,11 @@ export const askHumanTool = {
             detail: context,
         });
         if (result.action === 'cancelled') {
-            return '用户取消了选择。请考虑是否有不依赖用户输入的替代方案,或换个角度重新提问。';
+            return t('askHuman.cancelled');
         }
         if (result.action === 'submitted') {
-            return `用户回答:${result.value ?? ''}`;
+            return t('askHuman.submitted', { value: result.value ?? '' });
         }
-        return `用户选择:${result.value ?? ''}`;
+        return t('askHuman.selected', { value: result.value ?? '' });
     },
 };

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

@@ -1,6 +1,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { MAX_OUTPUT } from '../constants.js';
 import { getSandboxRoot, filterEnv, isCommandDenied } from '../../sandbox/index.js';
+import { t } from '../../i18n/index.js';
 const OUTPUT_HEAD_LIMIT = Math.floor(MAX_OUTPUT * 0.4);
 const OUTPUT_TAIL_LIMIT = MAX_OUTPUT - OUTPUT_HEAD_LIMIT;
 /** 有界采集：短输出逐字保留；超限后保留 head+tail，避免构建/测试错误只出现在尾部时被丢弃。 */
@@ -21,7 +22,7 @@ class BoundedCommandOutput {
         if (this.total <= MAX_OUTPUT)
             return this.head + this.tail;
         const removed = this.total - MAX_OUTPUT;
-        return `${this.head}\n...(输出已截断 ${removed} 字符,保留开头与结尾)...\n${this.tail}`;
+        return `${this.head}\n${t('command.outputTruncated', { count: removed })}\n${this.tail}`;
     }
 }
 // ---------- run_command ----------
@@ -73,7 +74,7 @@ export const runCommandTool = {
             // abort(用户 Ctrl+C,经 executeTool ctx.signal 透传)→ 杀子进程树 + 返[已中断]
             const onAbort = () => {
                 killTree();
-                finish(`[已中断]\n${output.render().trim()}`);
+                finish(`${t('command.interrupted')}\n${output.render().trim()}`);
             };
             const finish = (s) => {
                 if (finished)
@@ -88,14 +89,14 @@ export const runCommandTool = {
             };
             child.stdout.on('data', onChunk);
             child.stderr.on('data', onChunk);
-            child.on('error', (e) => finish(`执行失败: ${e.message}`));
+            child.on('error', (e) => finish(t('command.executionFailed', { message: e.message })));
             child.on('close', (code) => {
                 const result = output.render().trim();
-                finish(`[退出码 ${code}]\n${result || '(无输出)'}`);
+                finish(`${t('command.exitCode', { code: code ?? 'null' })}\n${result || t('toolSummary.noOutput')}`);
             });
             timer = setTimeout(() => {
                 killTree();
-                finish(`[超时,已终止]\n${output.render().trim()}`);
+                finish(`${t('command.timedOut')}\n${output.render().trim()}`);
             }, timeout);
             // 外部 abort signal:已 aborted 即时杀(防御;agent 循环顶检查通常会先拦),否则挂监听
             if (ctx?.signal) {

package/dist/tools/builtins/task.js

@@ -1,5 +1,6 @@
 import { spawnAgent } from '../../agent/spawn.js';
 import { MAX_OUTPUT } from '../constants.js';
+import { t } from '../../i18n/index.js';
 // ---------- task ----------
 // 派生子 agent 执行独立子任务。子 agent 有独立 history(不污染主对话),
 // 可受限工具子集 + 低步数上限,最终摘要回灌主 history 供主 agent 继续。
@@ -36,7 +37,7 @@ export const taskTool = {
     async execute(args, ctx) {
         const prompt = String(args.prompt ?? '');
         if (!prompt)
-            return '错误:缺少 prompt(子任务指令)。';
+            return t('task.missingPrompt');
         const tools = Array.isArray(args.tools)
             ? args.tools.map((t) => String(t))
             : undefined;
@@ -46,16 +47,16 @@ export const taskTool = {
         // 透传主 agent 的 abort signal:主 Ctrl+C 树杀子 agent(chat abort + 工具 abort)。
         const result = await spawnAgent({ prompt, tools, maxSteps, signal: ctx?.signal });
         if (!result.completed) {
-            return '子 agent 被中断,未完成。';
+            return t('task.interrupted');
         }
         if (!result.summary) {
-            return '子 agent 完成但未返回文本摘要(可能只调了工具或达到步数上限)。';
+            return t('task.noSummary');
         }
         // 摘要可能很长,截到 MAX_OUTPUT 保主 history 不爆。
         const summary = result.summary;
         if (summary.length > MAX_OUTPUT) {
             return (summary.slice(0, MAX_OUTPUT) +
-                `\n\n…(子 agent 摘要已截断 ${summary.length - MAX_OUTPUT} 字符)`);
+                `\n\n${t('task.summaryTruncated', { count: summary.length - MAX_OUTPUT })}`);
         }
         return summary;
     },