mocode-ai 1.2.0 → 1.2.2

package/dist/agent/core.js

@@ -554,7 +554,7 @@ export async function runAgentCore(opts) {
                             for (const tc of batch)
                                 hooks.onToolHeader?.(tc);
                             hooks.onToolStart?.(batch[0].name);
-                            const started = batch.map((tc) => executeToolOutcome(tc.name, tc.arguments, signal));
+                            const started = batch.map((tc) => executeToolOutcome(tc.name, tc.arguments, signal, { callId: tc.id }));
                             for (let k = 0; k < batch.length; k++) {
                                 const tc = batch[k];
                                 const outcome = await started[k];
@@ -627,6 +627,7 @@ export async function runAgentCore(opts) {
                             const started = entries.map((entry) => entry.denied
                                 ? Promise.resolve(entry.denied)
                                 : executeToolOutcome(entry.tc.name, entry.tc.arguments, signal, {
+                                    callId: entry.tc.id,
                                     onLockAcquired: (lockedArgs) => {
                                         entry.diff = readDiffContext(entry.tc, lockedArgs);
                                     },
@@ -715,6 +716,7 @@ export async function runAgentCore(opts) {
                             let diff = readDiffContext(tc, mutationParsed);
                             hooks.onToolStart?.(tc.name);
                             const outcome = await executeToolOutcome(tc.name, tc.arguments, signal, {
+                                callId: tc.id,
                                 onLockAcquired: (lockedArgs) => {
                                     if (mutationParsed)
                                         diff = readDiffContext(tc, lockedArgs);

package/dist/agent/index.js

@@ -7,6 +7,7 @@ import { Spinner } from '../ui/spinner.js';
 import { summarizeToolCall, summarizeToolResult, truncateDisplay, fmtElapsed, } from '../ui/render.js';
 import { renderFileChange } from '../ui/diff.js';
 import * as layout from '../ui/layout.js';
+import * as content from '../ui/content.js';
 import * as batch from '../ui/batch.js';
 import { beginTurn } from '../rollback/index.js';
 import { config } from '../config/index.js';
@@ -17,6 +18,27 @@ import { isToolErrorOutput } from '../tools/result.js';
 import { appendCurrentSessionTraceEvent } from '../session/index.js';
 /** 当前 turn 的 batch id(runAgent 内闭包变量;一条 turn 一轮 tool batch 结束即清空)。 */
 let currentBatchId = null;
+/** 当前活跃的 sub-agent 组容器批 id(同一轮并行派发的多个 sub-agent 合并到这一个顶层摘要行下)。
+ *  null 表示当前没有进行中的子 agent 组。 */
+let subAgentGroupId = null;
+/** sub-agent 组收口后,与后续内容(普通工具/正文)之间欠一条分隔空行。
+ *  由 flushToolBatch / onText 在合适位置补,尾部已空则不再叠。 */
+let subAgentGroupPendingSeparator = false;
+/** 派生子 agent 的工具名。它的调用要独占一批:子 agent 的实时工具明细会挂到这一行下面,
+ *  并行派发多个子 agent 时,每个子 agent 才有自己可归属的摘要行。 */
+const SUB_AGENT_TOOL = 'sub-agent';
+/** 缓冲尾部是否已经是空白行(去掉 ANSI 后无可见字符)。用于避免 sub-agent 分隔空行叠成两行。 */
+function isLastContentRowBlank() {
+    // 用 committedRows 而不是 totalRows：hasCurrent 那行是未提交的光标等待位，
+    // 永远空白，不能把它当作“已经有一条空行分隔”。
+    const committed = content.committedRows();
+    if (committed === 0)
+        return false;
+    const line = content.lineAt(committed - 1);
+    if (line === null)
+        return false;
+    return line.replace(/\x1b\[[0-9;]*m/g, '').trim().length === 0;
+}
 let turnFileChanges = [];
 function lineDelta(oldText, newText) {
     const before = oldText ? oldText.split('\n') : [];
@@ -68,20 +90,82 @@ function firstLineOf(ui) {
  *  重构后改为累积到 BatchRenderer,onToolBatchEnd 时统一打摘要行;
  *  展开/折叠由 BatchRenderer + 鼠标 release 决定,本函数不再直接写屏。 */
 function writeToolHeader(tc) {
-    // 改文件工具是 batch 屏障：先收尾之前的普通工具，确保 mutation 永远独占一批。
-    if (isMutationTool(tc.name))
+    if (tc.name === SUB_AGENT_TOOL) {
+        // sub-agent：同一轮并行派发的多个 sub-agent 合并进同一个「组容器批」——
+        // 顶层只有一个 ● 探索 N ... sub-agent N 摘要行,下面按 └─ sub-agent {...} 逐条
+        // 列出每个子 agent 调用,各自子批(实时工具)更深一层缩进。
+        // 注意：sub-agent header 到来时**不要** flushToolBatch,否则会把正在进行的组容器批收口。
+        if (subAgentGroupId == null) {
+            // 首个 sub-agent 调用前：若前面已经有一个普通工具批在跑，先收口它并补分隔空行，
+            // 避免普通批摘要行与 sub-agent 组摘要行粘在一起。
+            if (currentBatchId)
+                flushToolBatch();
+            // 首个 sub-agent 调用：建组容器批(顶层)。label 缺省=「探索」,entries 累计各 sub-agent 调用。
+            subAgentGroupId = batch.beginBatch(undefined, { groupParent: true });
+            batch.recordCall(subAgentGroupId, tc.name, summarizeToolCall(tc.name, tc.arguments), tc.id);
+            batch.bindCall(tc.id, subAgentGroupId);
+            batch.showLiveBatch(subAgentGroupId, layout);
+            // 立即展开第一组 └─ sub-agent 行(运行态不锚定视口),让子 agent 调用马上可见。
+            batch.expandBatch(subAgentGroupId, layout, true);
+        }
+        else {
+            // 同一轮并行派发的后续 sub-agent：向组追加 entry,实时刷新进度。
+            batch.recordCall(subAgentGroupId, tc.name, summarizeToolCall(tc.name, tc.arguments), tc.id);
+            batch.bindCall(tc.id, subAgentGroupId);
+            // 组已展开:追加新的 └─ sub-agent 行(插到已渲染 entry 之后),并刷新顶层摘要行计数。
+            batch.refreshBatchExpanded(subAgentGroupId, layout);
+            batch.showLiveBatch(subAgentGroupId, layout);
+        }
+        return;
+    }
+    // sub-agent 组还在跑但普通/mutation 工具先来了：收口 sub-agent 组，并补一条分隔空行。
+    if (subAgentGroupId) {
         flushToolBatch();
-    if (!currentBatchId)
-        currentBatchId = batch.beginBatch();
-    batch.recordCall(currentBatchId, tc.name, summarizeToolCall(tc.name, tc.arguments));
-    // 第一条工具开始时立即落摘要；后续调用加入同一 batch，并原地刷新计数。
-    batch.showLiveBatch(currentBatchId, layout);
+    }
+    if (isMutationTool(tc.name)) {
+        // mutation 永远独占一批（diff 要紧跟调用行）。先收口当前普通批。
+        if (currentBatchId)
+            flushToolBatch();
+        const id = batch.beginBatch();
+        currentBatchId = id;
+        batch.bindCall(tc.id, id);
+        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments));
+        batch.showLiveBatch(id, layout);
+    }
+    else {
+        // 普通工具合并到 currentBatchId；同轮并行或连续无正文的工具轮次共享一个摘要行。
+        const id = currentBatchId ??= batch.beginBatch();
+        // 结果按 tool_call id 归位：并行执行时 currentBatchId 会漂移，只按“当前批”回填会漏填，
+        // 摘要行就永远停在 ◇（用户实测：子 agent 跑完主侧菱形没变成实心圆）。
+        batch.bindCall(tc.id, id);
+        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments));
+        // 第一条工具开始时立即落摘要；后续调用加入同一 batch，并原地刷新计数。
+        batch.showLiveBatch(id, layout);
+    }
 }
 /** 渲染工具结果:mutation 成功走 diff 块(行号 + 语法高亮);其余走一行 preview。
  *  同 writeToolHeader,改为累积到 BatchRenderer(只缓存字符串,不写屏)。 */
 function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
-    if (!currentBatchId)
+    // 优先按 tool_call id 反查所属批（并行 / sub-agent 组时 currentBatchId 已不是它）。
+    const batchId = batch.batchIdForCall(tc.id) ?? currentBatchId;
+    if (!batchId)
         return;
+    if (tc.name === SUB_AGENT_TOOL) {
+        // sub-agent 调用只是组容器批的一个 entry：结果回填到对应 entry 即可,
+        // 无需独立批。全部 entry 完成后收口组容器批(落完成态 + 开放点击展开),
+        // 并与后续内容约定一条分隔空行。
+        const preview = summarizeToolResult(tc.name, output);
+        batch.recordResult(batchId, tc.name, preview, null, output, isToolErrorOutput(output), tc.id);
+        if (batch.isBatchComplete(batchId)) {
+            batch.endBatch(batchId, layout);
+            subAgentGroupId = null;
+            subAgentGroupPendingSeparator = true;
+        }
+        else {
+            batch.showLiveBatch(batchId, layout);
+        }
+        return;
+    }
     let diff = null;
     if ((tc.name === 'edit_file' || tc.name === 'write_file') && parsed && !isToolErrorOutput(output)) {
         const oldText = tc.name === 'edit_file' ? String(parsed.old_string ?? '') : preWriteOld;
@@ -102,16 +186,42 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
         });
     }
     const preview = diff ? '' : summarizeToolResult(tc.name, output);
-    batch.recordResult(currentBatchId, tc.name, preview, diff, output, isToolErrorOutput(output));
-    batch.showLiveBatch(currentBatchId, layout);
+    batch.recordResult(batchId, tc.name, preview, diff, output, isToolErrorOutput(output));
+    batch.showLiveBatch(batchId, layout);
     // mutation 结果（成功 diff 或错误输出）立即可见，并阻止后续普通工具并入这一批。
     if (isMutationTool(tc.name))
-        flushToolBatch(true);
+        finishStandaloneBatch(batchId, true);
+}
+/** 收尾一个独占批（mutation / sub-agent）。按 id 收尾而不是按 currentBatchId：
+ *  同一轮里 mutation 与 sub-agent 混排时，后者的 header 已经把前者切走，
+ *  只认 currentBatchId 会漏掉 diff 展开、把摘要永久留在未完成态。endBatch 幂等。 */
+function finishStandaloneBatch(id, expandSingleEntry) {
+    if (currentBatchId === id)
+        currentBatchId = null;
+    batch.endBatch(id, layout);
+    if (expandSingleEntry)
+        batch.expandSingleEntryFully(id, layout);
+    // mutation 独占批收尾:分隔空行由 flushToolBatch 负责(见 subAgentGroupPendingSeparator);
+    // 不再有 sub-agent 独占批——sub-agent 已合并进组容器批。
 }
 /** 将跨 LLM 工具轮次累计的调用写入内容区；正文开始或整个 turn 收尾时才切批。 */
 function flushToolBatch(expandSingleEntry = false) {
-    if (!currentBatchId)
+    if (!currentBatchId) {
+        // 异常路径:组容器批尚未收口(理论上最后一个 sub-agent 结果时已收口),这里补收口。
+        if (subAgentGroupId) {
+            const id = subAgentGroupId;
+            subAgentGroupId = null;
+            batch.endBatch(id, layout);
+            subAgentGroupPendingSeparator = true;
+        }
+        // 组 / 工具块与后续内容之间补一条分隔空行(尾部已空则不叠,避免空两行)。
+        if (subAgentGroupPendingSeparator) {
+            if (!isLastContentRowBlank())
+                layout.contentWrite('\n');
+            subAgentGroupPendingSeparator = false;
+        }
         return;
+    }
     const id = currentBatchId;
     currentBatchId = null;
     batch.endBatch(id, layout);
@@ -120,6 +230,7 @@ function flushToolBatch(expandSingleEntry = false) {
     // 普通批：endBatch 留了 1 个 hasCurrent 空行，break 一次把它提交为分隔空行。
     // mutation 自动展开：expandSingleEntryFully 自己补 separator (\n)，这里不能再补 \n，
     // 不然 diff 后面就会出现两条空白行。
+    subAgentGroupPendingSeparator = false;
     if (!expandSingleEntry)
         layout.contentWrite('\n');
 }
@@ -144,6 +255,8 @@ onContextUpdate) {
     beginTurn(truncateDisplay(firstLineOf(userInput), 40));
     layout.contentMode(); // 防御性:运行态光标归输入框光标位供 IME 锚定(enterRunningMode 已置,这里兜底)
     currentBatchId = null; // 新 turn 清旧 batch id(防上 turn 残留)
+    subAgentGroupId = null;
+    subAgentGroupPendingSeparator = false;
     turnFileChanges = [];
     // spinner:状态行最前面转圈(思考中 / 生成 / 执行 工具时,状态栏 lead 位显帧 + 文字)。
     // 经 setStatus 注入状态行(spinnerFrame + statusText),composeStatus 把帧 + 文字放 lead 位;
@@ -164,9 +277,11 @@ onContextUpdate) {
         onText: (s) => {
             // 纯空白 chunk 在视觉上不是正文：既不切 batch，也不写入 markdown 缓冲。
             // 部分兼容后端会在连续工具轮次间流出 " " / "\n"，若据此切批会漏掉首个工具。
-            if (currentBatchId && s.trim().length === 0)
+            // sub-agent 独占批不占 currentBatchId，但同样处在“工具块刚结束”的边界上。
+            const inToolBlock = currentBatchId !== null || subAgentGroupId !== null || subAgentGroupPendingSeparator;
+            if (inToolBlock && s.trim().length === 0)
                 return;
-            const followsToolBatch = currentBatchId !== null;
+            const followsToolBatch = inToolBlock;
             // batch 收尾已经统一留了一条空白行。部分后端会把下一段正文以 \n / \n\n
             // 开头发来；去掉这些“边界换行”，避免与 UI 分隔叠成两条空白行。
             const visible = followsToolBatch ? s.replace(/^(?:[ \t]*\r?\n)+/, '') : s;

package/dist/agent/spawn.js

@@ -1,9 +1,10 @@
-// 子 agent 封装:runAgentCore + 静默 hooks。独立 history / 可受限工具子集 / 低步数上限。
+// 子 agent 封装:runAgentCore + (TUI 激活时)实时渲染 hooks。独立 history / 可受限工具子集 / 低步数上限。
 // 供 task 工具(主 agent 派生子任务)调用——子 agent 的最终摘要回灌主 history。
 //
 // 与主 agent 的区别:
-//  - 不写主屏(layout.contentWrite):中间过程(流式正文 / 工具头 / diff)缓冲到内部字符串,
-//    结束返回给 task 工具(task 把它当 tool 结果回灌主 history,主 agent 据此继续)。
+//  - 主屏渲染可选:全屏 TUI 激活时(layout.isTuiActive()),把子 agent 内部工具调用实时写入
+//    主内容区并复用 batch 折叠机制(运行态逐条展开,执行完自动折叠回单行摘要,鼠标可点开查看);
+//    TUI 未激活(host 嵌入 / 非 TTY)时保持纯静默——中间过程只缓冲进 transcript,不写主屏。
 //  - 独立 history:不共享主对话,避免子任务的工具噪声污染主上下文。
 //  - 紧凑系统提示:不复制主 agent 的 memory/skills/项目快照；由 context 传入已知事实。
 //  - 工具子集:写任务默认继承主 Agent 工具（仅禁止递归 task）；只读模式按安全语义移除写工具。
@@ -15,8 +16,13 @@ import { chatTools } from '../llm/index.js';
 import { buildMocodeCorePrompt, config, isSubAgentEnabled } from '../config/index.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
 import { ui } from '../ui/theme.js';
+import * as layout from '../ui/layout.js';
+import { isTuiActive } from '../ui/layout.js';
+import * as batch from '../ui/batch.js';
+import { isToolErrorOutput } from '../tools/result.js';
 import { runAgentCore } from './core.js';
 import { summarizeToolCall, summarizeToolResult, truncateDisplay } from '../ui/render.js';
+import { t } from '../i18n/index.js';
 import { createContextState } from '../session/compact.js';
 import { inOverlay, mergeSubAgentChangeSet } from '../agents/coordinator.js';
 /** 子 agent 系统提示后缀:角色与约束。 */
@@ -84,6 +90,61 @@ export async function spawnAgent(opts) {
         buf.push(s);
         transcript += s;
     };
+    // 主屏实时渲染(子 agent 透明化):TUI 激活时把子 agent 内部步骤实时写入主内容区,
+    // 复用 batch 折叠机制(mouse 点击摘要行可展开/收起)。TUI 未激活(host/非 TTY)时
+    // 保持纯静默——只缓冲 transcript,不写屏,兼容嵌入宿主。
+    const live = isTuiActive();
+    let liveBatchId = null;
+    const liveLayout = () => ({
+        contentWrite: (s) => layout.contentWrite(s),
+        contentReplaceLine: (absIdx, line) => layout.contentReplaceLine(absIdx, line),
+        contentInsertAfter: (after, lines, keepViewport) => layout.contentInsertAfter(after, lines, keepViewport),
+        contentDeleteFrom: (startIdx, n) => layout.contentDeleteFrom(startIdx, n),
+        totalRows: () => layout.totalRows(),
+        repaintViewport: () => layout.repaintViewport(),
+        isScrolled: () => layout.isScrolled(),
+    });
+    /** 本批是否挂在主侧调用行下(挂上了就由主侧负责分隔空行,自己不能往 buffer 末尾追加)。 */
+    let nested = false;
+    const ensureLiveBatch = () => {
+        if (!live || liveBatchId)
+            return;
+        // 主侧 sub-agent 组容器批 = 父批;本子 agent 的工具批挂在其下并更深一层缩进,
+        // 与同组其它子 agent 各归各的 └─ sub-agent 行(通过 groupChildIndex 定锚点)。
+        const parentId = batch.batchIdForCall(opts.callId) ?? undefined;
+        nested = parentId != null;
+        const childIndex = parentId ? batch.getGroupChildIndex(opts.callId) : undefined;
+        liveBatchId = batch.beginBatch(t('subagent.running'), {
+            parentId,
+            indent: parentId ? '        ' : undefined,
+            groupChildIndex: childIndex,
+            running: true,
+        });
+        batch.showLiveBatch(liveBatchId, liveLayout());
+        // 默认折叠:只显示一行「子 Agent 运行中 · glob X  read_file Y」,不展开明细;
+        // 用户点击摘要行后才展开看具体工具调用。
+    };
+    const finishLiveBatch = (status) => {
+        if (!live || !liveBatchId)
+            return;
+        const id = liveBatchId;
+        liveBatchId = null;
+        if (status)
+            batch.setBatchLabel(id, status === 'complete'
+                ? t('subagent.complete')
+                : status === 'failed' ? t('subagent.failed') : t('subagent.running'));
+        // 收尾:清除运行态标志,摘要行图标从「运行中 ◐」切回完成态 ●。
+        batch.setBatchRunning(id, false);
+        batch.endBatch(id, liveLayout());
+        // 子 agent 完成后自动折叠:endBatch 登记了点击,但默认保持展开态;
+        // 这里显式折叠回单行摘要,让执行完的批自动收起(用户可再点开)。
+        if (status === 'complete' && batch.isExpanded(id))
+            batch.toggleBatch(id, liveLayout());
+        // 嵌套批的分隔空行由主侧 flushToolBatch 统一补;这里再写会往 buffer 末尾插孤儿空行
+        // (并行子 agent 各写一条,块尾堆出空白)。
+        if (!nested)
+            layout.contentWrite('\n');
+    };
     let lastChar = '';
     const hooks = {
         onText: (s) => {
@@ -101,11 +162,24 @@ export async function spawnAgent(opts) {
         onToolHeader: (tc) => {
             const summary = summarizeToolCall(tc.name, tc.arguments);
             writeBuf(`  ● ${tc.name}  ${summary}\n`);
+            // 实时写入主内容区:子 agent 的每次工具调用累计到摘要行计数。
+            ensureLiveBatch();
+            if (liveBatchId) {
+                batch.recordCall(liveBatchId, tc.name, summary);
+                // 默认折叠,只刷新摘要行计数(glob/read_file 数量),不展开明细列表。
+                batch.showLiveBatch(liveBatchId, liveLayout());
+            }
         },
         onToolResult: (tc, output) => {
             const preview = summarizeToolResult(tc.name, output);
             if (preview)
                 writeBuf(`  ↳ ${preview}\n`);
+            if (liveBatchId) {
+                // 子 agent 批无 diff(写任务走 overlay,最终由主 agent 合并);空 preview 用占位
+                // 标记 entry 已完成,避免折叠后摘要仍显示"运行中"。
+                batch.recordResult(liveBatchId, tc.name, preview || t('toolSummary.noOutput'), null, output, isToolErrorOutput(output));
+                batch.showLiveBatch(liveBatchId, liveLayout());
+            }
         },
         onTextEnd: () => {
             if (lastChar && lastChar !== '\n') {
@@ -113,16 +187,30 @@ export async function spawnAgent(opts) {
                 lastChar = '\n';
             }
         },
-        onToolBatchEnd: () => writeBuf('\n'),
+        onToolBatchEnd: () => {
+            writeBuf('\n');
+            // 子 agent 一轮工具调用结束:仍在运行(可能还有后续轮次),仅推进实时摘要,
+            // 不折叠——等 onDone 整体完成才自动收起。
+            if (liveBatchId)
+                batch.showLiveBatch(liveBatchId, liveLayout());
+        },
         onNoReply: () => writeBuf(`${ui.dim}(无回复)${ui.reset}\n`),
-        onMaxSteps: () => writeBuf(`  ● 达到最大步数(${maxSteps}),子 agent 停止。\n`),
+        onMaxSteps: () => {
+            writeBuf(`  ● 达到最大步数(${maxSteps}),子 agent 停止。\n`);
+            finishLiveBatch('failed');
+        },
         onDone: (elapsedMs, usage) => {
             const tok = usage && usage.totalTokens
                 ? `  · ${usage.totalTokens} tokens${usage.cachedTokens ? ` ↻${usage.cachedTokens} cached` : ''}`
                 : '';
             writeBuf(`  ✻ 子 agent 耗时 ${(elapsedMs / 1000).toFixed(1)}s${tok}\n`);
+            finishLiveBatch('complete');
+        },
+        onAbort: () => {
+            // 中断:子 agent 未完成,收尾批(不折叠——用户可能想看中断前做了什么)。
+            finishLiveBatch('aborted');
         },
-        // onStepStart / onChatDone / onToolStart / onToolDone / onAbort:子 agent 静默,无需 spinner / 中断渲染。
+        // onStepStart / onChatDone / onToolStart / onToolDone:子 agent 静默,无需 spinner 渲染。
         // abort 还原(history 还原 + 模式还原)由 core 的 abortRestore 处理,hooks 只管展示。
     };
     // 每个子 agent 独享统计/预算状态。不能保存再恢复模块级单例：多个 task 并发时

package/dist/config/index.js

@@ -84,7 +84,7 @@ const DEFAULT_VOICE = `## Voice
 - Give technical recommendations with brief trade-off reasoning when choices exist.
 - Focus on useful information. Avoid unnecessary greetings, apologies, repetition, or filler.
 - Match the user's style and language while staying task-focused.
-- For long operations, briefly state the plan and expected result. Avoid step-by-step narration.
+- Work quietly: jump straight into tool calls without announcing them; reserve visible text for the final answer and truly important mid-task findings. No step-by-step narration.
 - State assumptions and ask when uncertain. Do not guess.`;
 /** 解析用户自定义声音:persona.md 文件优先(项目级 > 全局),其次 env MOCODE_PERSONA。无则返回 ''。 */
 function readPersonaFile() {
@@ -287,7 +287,7 @@ ${buildCodegraphSection()}
 ${buildWorkDisciplineSection(inferModelFamily(config.model))}
 
 ## Tool policy
-- During tool-calling turns, stay silent unless something important enough must reach the user — otherwise just call the tool and let it run.
+- Silent Execution: invoke tools directly without preamble. Output visible text ONLY for the final answer and critical mid-task findings. Strictly no step-by-step narration (no "let me…", "让我先…", "now checking…" between calls).
 - Go directly to a known path or symbol; use discovery tools only when the location is unknown.
 - Edit against a FRESH read: before any edit_file/write_file, call read_file on the exact path and copy both its latest hash and the exact target text. Never reconstruct old_string from a grep/summary/diff — those lose whitespace and indentation and cause edit failures.
 - A read_file hash from before a compaction, session resume, edit conflict, or external change is STALE and will be rejected — re-read rather than reuse an old hash.

package/dist/i18n/index.js

@@ -209,6 +209,9 @@ const zhCN = {
     'task.interrupted': '子 agent 被中断，未完成。',
     'task.noSummary': '子 agent 完成但未返回文本摘要（可能只调了工具或达到步数上限）。',
     'task.summaryTruncated': '…（子 agent 摘要已截断 {count} 字符）',
+    'subagent.running': '子 Agent 运行中',
+    'subagent.complete': '子 Agent 完成',
+    'subagent.failed': '子 Agent 失败',
     'subagent.status': '子 Agent：{state}',
     'subagent.stateOn': '开启',
     'subagent.stateOff': '关闭',
@@ -461,6 +464,9 @@ const en = {
     'task.interrupted': 'The sub-agent was interrupted before completion.',
     'task.noSummary': 'The sub-agent completed without a text summary (it may only have used tools or reached its step limit).',
     'task.summaryTruncated': '…(sub-agent summary truncated by {count} characters)',
+    'subagent.running': 'Sub-agent running',
+    'subagent.complete': 'Sub-agent complete',
+    'subagent.failed': 'Sub-agent failed',
     'subagent.status': 'Sub-agent: {state}',
     'subagent.stateOn': 'enabled',
     'subagent.stateOff': 'disabled',

package/dist/repl/index.js

@@ -276,9 +276,12 @@ function readPlanStatusFromNotes() {
         if (!title)
             return null;
         const total = (section.match(/^\s*-\s*\[[ xX]\]\s*\d+\./gm) || []).length;
-        const done = (section.match(/^\s*-\s*\[[xX]\]\s*\d+\./gm) || []).length;
-        const current = section.match(/^\s*-\s*\[ \]\s*\d+\.\s*(.+)$/m)?.[1].trim();
-        const summary = `plan: ${title} (${done}/${total})`;
+        const currentMatch = section.match(/^\s*-\s*\[ \]\s*(\d+)\.\s*(.+)$/m);
+        const current = currentMatch?.[2].trim();
+        // 括号进度 = 「当前执行到的步骤序号/总数」(执行第 1 步显示 1/3),与 `▸ 当前步` 后缀自洽;
+        // 旧语义 done/total 会永远慢一拍(执行第 2 步显示 1/3)。全勾选时显示 total/total(通常已自动结算为 Done,chip 消失)。
+        const activeNo = currentMatch ? Number(currentMatch[1]) : total;
+        const summary = `plan: ${title} (${activeNo}/${total})`;
         // mtime 让“相同内容被重写为一项新计划”也能重新出现，而不被旧轮次误抑制。
         const fingerprint = `${sessionId}\0${fs.statSync(p).mtimeMs}\0${section}`;
         return { fingerprint, summary: current ? `${summary} ▸ ${current}` : summary };