mocode-ai 1.2.0 → 1.2.2

package/dist/ui/batch.js

@@ -14,6 +14,12 @@
 import { ui } from './theme.js';
 import { t } from '../i18n/index.js';
 import { truncateAnsi } from './render.js';
+/** entry 是否已拿到结果。历史回放构造的 entry 无 done 字段,退化按内容判定。 */
+function isEntryDone(e) {
+    return e.done === true || !!e.resultSummary || !!e.diffBlock || !!e.failed;
+}
+/** 子 agent 运行中的专属图标:与完成态的实心 ● 区分,也区别于父层「探索」运行态的 ◇。 */
+const RUNNING_GLYPH = '◐';
 const batches = new Map();
 /** 绝对行索引 → 所属 batch id(仅记录 summary 行;用于鼠标点击反查)。
  *  buffer 行数变化时本表可能漂移——但只在 insertAfter/deleteFrom 后由本模块同步更新,
@@ -23,6 +29,13 @@ const absLineToBatchId = new Map();
 const absLineToEntry = new Map();
 /** 已展开第一层工具列表的 batch id。 */
 const expandedBatches = new Set();
+/** tool_call id → 所属 batch(主侧每次 onToolHeader 都登记)。
+ *  结果按 id 归位(并行时 currentBatchId 会漂移,按 id 查才不串批);
+ *  子 agent 建批时据此反查父批,把子批摘要行插到父批正下方。reset() 统一清理。 */
+const callToBatch = new Map();
+/** sub-agent 组:tool_call id → 在组容器批 entries 中的序号。
+ *  spawn.ts 建子批时据此把子批摘要行插到正确的 └─ sub-agent 行下方。reset() 统一清理。 */
+const groupChildIndexByCall = new Map();
 /** 展开时完整输出的最大行数;超出截断,避免巨型输出撑爆 viewport。 */
 const MAX_EXPAND_LINES = 200;
 /** 自洽行允许的最大显示宽(= 终端 cols)。buffer 行超 cols 会被终端 auto-wrap,
@@ -59,57 +72,125 @@ export function reset() {
     absLineToBatchId.clear();
     absLineToEntry.clear();
     expandedBatches.clear();
+    callToBatch.clear();
+    groupChildIndexByCall.clear();
 }
-/** 新建一个 batch(在 agent 拿到第一条 onToolHeader 时调)。返回 id。 */
-export function beginBatch() {
+/** 新建一个 batch(在 agent 拿到第一条 onToolHeader 时调)。返回 id。
+ *  label 可选:自定义摘要行标签(子 agent 批用),缺省按完成态取 agent.tools*。
+ *  opts.indent/parentId:子批嵌套渲染(摘要行缩进 + 插到父批下方)。
+ *  opts.groupParent:组容器批(并行 sub-agent 共享顶层摘要行)。
+ *  opts.groupChildIndex:本批作为组子批时在父 entries 中的序号(插入锚点用)。 */
+export function beginBatch(label, opts) {
     const id = `b${++_idCounter}`;
-    batches.set(id, { id, summaryAbsIdx: -1, entries: [], expandedEntries: new Set(), startedAt: Date.now() });
+    batches.set(id, {
+        id,
+        summaryAbsIdx: -1,
+        entries: [],
+        expandedEntries: new Set(),
+        renderedCount: 0,
+        startedAt: Date.now(),
+        label,
+        indent: opts?.indent,
+        parentId: opts?.parentId && batches.has(opts.parentId) ? opts.parentId : undefined,
+        groupParent: opts?.groupParent ?? false,
+        groupChildIndex: opts?.groupChildIndex,
+        running: opts?.running ?? false,
+    });
     return id;
 }
-/** 记一条工具调用(在 onToolHeader 时调,与 setEntryResult 配对;entries 顺序 = agent 调用顺序)。 */
-export function recordCall(id, name, callSummary) {
+/** 登记 tool_call id → 所属 batch。结果回填按 id 归位(并行时 currentBatchId 会漂移),
+ *  子 agent 也据此反查父批。 */
+export function bindCall(callId, batchId) {
+    if (callId)
+        callToBatch.set(callId, batchId);
+}
+/** tool_call id → 所属 batch id;未登记返 null。 */
+export function batchIdForCall(callId) {
+    if (!callId)
+        return null;
+    const id = callToBatch.get(callId);
+    return id && batches.has(id) ? id : null;
+}
+/** 记一条工具调用(在 onToolHeader 时调,与 setEntryResult 配对;entries 顺序 = agent 调用顺序)。
+ *  callId 可选:组容器批据此把 sub-agent 调用归到 entries 的固定序号(供子批插入锚点反查)。 */
+export function recordCall(id, name, callSummary, callId) {
     const b = batches.get(id);
     if (!b)
         return;
     // 已完成的累计探索后又追加工具：恢复进行中，待新结果返回再完成。
     b.finishedAt = undefined;
     b.entries.push({ name, callSummary, resultSummary: '', diffBlock: null });
+    if (callId && b.groupParent)
+        groupChildIndexByCall.set(callId, b.entries.length - 1);
+}
+/** 查询某 sub-agent 调用在所属组容器批 entries 中的序号(供 spawn.ts 建子批时定锚点)。 */
+export function getGroupChildIndex(callId) {
+    if (!callId)
+        return 0;
+    const v = groupChildIndexByCall.get(callId);
+    return v == null ? 0 : v;
+}
+/** 批是否所有 entry 都已拿到结果(空批视为完成)。 */
+export function isBatchComplete(id) {
+    const b = batches.get(id);
+    if (!b)
+        return false;
+    return b.entries.length > 0 && b.entries.every(isEntryDone);
 }
 /** 记一条工具结果(diff 块或单行 preview);agent 在 onToolResult 时调,匹配最后一条未填的 entry。
- *  fullOutput:工具原始完整输出(纯文本),展开时显示;mutation 工具的 diff 块已自含无需传。 */
-export function recordResult(id, name, resultSummary, diffBlock, fullOutput, failed = false) {
+ *  fullOutput:工具原始完整输出(纯文本),展开时显示;mutation 工具的 diff 块已自含无需传。
+ *  callId:组容器批用,直接把结果填到对应 entry(避免多个 sub-agent 同名时反向匹配错位)。 */
+export function recordResult(id, name, resultSummary, diffBlock, fullOutput, failed = false, callId) {
     const b = batches.get(id);
     if (!b || b.entries.length === 0)
         return;
+    // 组容器批:优先按 callId 定位 entry,防止多个同名 sub-agent 结果互相填错位置。
+    if (callId && b.groupParent) {
+        const idx = groupChildIndexByCall.get(callId);
+        if (idx != null && idx < b.entries.length && !isEntryDone(b.entries[idx])) {
+            const e = b.entries[idx];
+            e.resultSummary = resultSummary;
+            e.diffBlock = diffBlock;
+            e.fullOutput = fullOutput;
+            e.failed = failed;
+            e.done = true;
+            if (b.entries.every(isEntryDone))
+                b.finishedAt = Date.now();
+            return;
+        }
+    }
     // 反向找最后一条同名的 entry 填结果;同名工具一批多次调用时正向遍历更安全——用 lastIndexOf 同名回退
     for (let i = b.entries.length - 1; i >= 0; i--) {
-        if (b.entries[i].name === name && !b.entries[i].resultSummary) {
+        if (b.entries[i].name === name && !isEntryDone(b.entries[i])) {
             b.entries[i].resultSummary = resultSummary;
             b.entries[i].diffBlock = diffBlock;
             b.entries[i].fullOutput = fullOutput;
             b.entries[i].failed = failed;
-            if (b.entries.every((e) => e.resultSummary || e.diffBlock || e.failed))
+            b.entries[i].done = true;
+            if (b.entries.every(isEntryDone))
                 b.finishedAt = Date.now();
             return;
         }
     }
     // 兜底:无匹配则填最后一条
     const last = b.entries[b.entries.length - 1];
-    if (!last.resultSummary) {
+    if (!isEntryDone(last)) {
         last.resultSummary = resultSummary;
         last.diffBlock = diffBlock;
         last.fullOutput = fullOutput;
         last.failed = failed;
-        if (b.entries.every((e) => e.resultSummary || e.diffBlock || e.failed))
+        last.done = true;
+        if (b.entries.every(isEntryDone))
             b.finishedAt = Date.now();
     }
 }
 // ── 摘要行文本生成 ──
 /** 把 entry 列表压缩成一行摘要。 */
 function buildSummaryLine(record, live = false) {
+    const prefix = record.indent ?? '';
     const entries = record.entries;
     if (entries.length === 0) {
-        return `  ${ui.dim}│${ui.reset} ${ui.bold}${ui.accent}◇${ui.reset} ${ui.dim}No tools${ui.reset}`;
+        return `${prefix}  ${ui.dim}│${ui.reset} ${ui.bold}${ui.accent}◇${ui.reset} ${ui.dim}No tools${ui.reset}`;
     }
     // N>1:同类合并 "read_file 3, glob 1, grep 1"
     const counts = new Map();
@@ -118,15 +199,31 @@ function buildSummaryLine(record, live = false) {
     const parts = [];
     for (const [n, c] of counts)
         parts.push(`${n} ${c}`);
-    const completed = entries.filter((e) => e.resultSummary || e.diffBlock || e.failed).length;
+    const completed = entries.filter(isEntryDone).length;
     const failedCount = entries.filter((e) => e.failed).length;
     // 工具本身完成就立即显示完成态，不等待整轮正文流完/onDone。
     // 单项失败不代表整批失败：执行中优先展示进度；完成后区分部分失败与全部失败。
     const finished = completed >= entries.length;
     const allFailed = finished && failedCount === entries.length;
     const partiallyFailed = finished && failedCount > 0 && !allFailed;
-    const symbol = !finished ? '◇' : allFailed ? '×' : partiallyFailed ? '!' : '●';
-    const color = !finished ? ui.accent : allFailed ? ui.red : partiallyFailed ? ui.yellow : ui.green;
+    const symbol = record.running
+        ? RUNNING_GLYPH
+        : !finished
+            ? '◇'
+            : allFailed
+                ? '×'
+                : partiallyFailed
+                    ? '!'
+                    : '●';
+    const color = record.running
+        ? ui.accent
+        : !finished
+            ? ui.accent
+            : allFailed
+                ? ui.red
+                : partiallyFailed
+                    ? ui.yellow
+                    : ui.green;
     const label = !finished
         ? t('agent.toolsRunning')
         : allFailed
@@ -137,7 +234,8 @@ function buildSummaryLine(record, live = false) {
     const elapsed = record.finishedAt
         ? `  ${elapsedMs < 100 ? '<0.1s' : `${(elapsedMs / 1000).toFixed(1)}s`}`
         : '';
-    return `  ${ui.bold}${color}${symbol}${ui.reset} ${label}${progress}${elapsed}  ${ui.dim}${parts.join('  ')}${ui.reset}`;
+    const displayLabel = record.label ?? label;
+    return `${prefix}  ${ui.bold}${color}${symbol}${ui.reset} ${displayLabel}${progress}${elapsed}  ${ui.dim}${parts.join('  ')}${ui.reset}`;
 }
 // ── 展开/折叠 ──
 /** 把 batch 的详情行展开成自洽行数组(供 layout.contentInsertAfter 走 mid-buffer 插入)。
@@ -177,13 +275,13 @@ function buildEntryDetailLines(e, indent = '      ') {
     }
     return lines;
 }
-/** 第一层只展示有哪些调用及其简短结果，不展开完整输出。 */
-function buildExpandedLines(entries) {
+/** 第一层只展示有哪些调用及其简短结果，不展开完整输出。extraIndent 供子批嵌套加深缩进。 */
+function buildExpandedLines(entries, extraIndent = '') {
     return entries.map((e, index) => {
         const result = e.resultSummary ? `  ${ui.gray}↳ ${e.resultSummary}${ui.reset}` : '';
         const branch = index === entries.length - 1 ? '└─' : '├─';
         const failure = e.failed ? `${ui.red}×${ui.reset} ` : '';
-        return sanitizeRow(`    ${ui.dim}${branch}${ui.reset} ${failure}${ui.accent}${e.name}${ui.reset}  ${ui.dim}${e.callSummary}${ui.reset}${result}`);
+        return sanitizeRow(`${extraIndent}    ${ui.dim}${branch}${ui.reset} ${failure}${ui.accent}${e.name}${ui.reset}  ${ui.dim}${e.callSummary}${ui.reset}${result}`);
     });
 }
 function entryDetailIndent(entries, index) {
@@ -201,6 +299,22 @@ export function endBatch(id, layout) {
         absLineToBatchId.set(b.summaryAbsIdx, b.id);
         return;
     }
+    // 子批尚未落盘(组容器折叠期间被隐藏 / 折叠后才新建)。绝不能 contentWrite 到 buffer 末尾:
+    // 那会在正文区留下一条游离的子 agent 摘要行,父批再展开时就变成「多出来的第三条」。
+    if (b.parentId) {
+        const parent = batches.get(b.parentId);
+        if (parent?.groupParent) {
+            // 父批折叠中:不渲染,等 expand() 统一恢复(那时会用最新状态重建摘要行)。
+            if (!expandedBatches.has(parent.id) || parent.summaryAbsIdx < 0)
+                return;
+            // 父批已展开:插到自己的 └─ sub-agent 行下方。
+            const anchor = findParentEntryAbsLine(parent.id, b.groupChildIndex ?? 0) ?? parent.summaryAbsIdx;
+            layout.contentInsertAfter(anchor, [sanitizeRow(buildSummaryLine(b))]);
+            b.summaryAbsIdx = anchor + 1;
+            absLineToBatchId.set(b.summaryAbsIdx, b.id);
+            return;
+        }
+    }
     const summary = buildSummaryLine(b);
     // 写摘要行(以 \n 收尾;contentWrite 会 breakRow 让其成为完整物理行)
     layout.contentWrite(summary + '\n');
@@ -217,6 +331,37 @@ export function showLiveBatch(id, layout) {
         return;
     const summary = buildSummaryLine(b, true);
     if (b.summaryAbsIdx < 0) {
+        // 子批:摘要行插到父批已渲染块的正下方(而非 buffer 末尾),
+        // 让「子 agent 的工具明细」始终跟在自己的父调用行下——并行派发时才不串行。
+        const parent = b.parentId ? batches.get(b.parentId) : undefined;
+        if (parent && parent.summaryAbsIdx >= 0 && layout.contentInsertAfter) {
+            // 组容器父批处于折叠态时,子批摘要行先不渲染;等父批展开时由 expand 统一恢复,
+            // 避免子批摘要残留在父批明细区、再次展开后出现重复行。
+            if (parent.groupParent && !expandedBatches.has(parent.id)) {
+                b.summaryAbsIdx = -1;
+                return;
+            }
+            let anchor;
+            if (parent.groupParent && b.groupChildIndex != null && expandedBatches.has(parent.id)) {
+                // 组容器已展开:子 agent 工具批插到第 groupChildIndex 个 └─ sub-agent 行下方。
+                // 不能用固定偏移 summaryAbsIdx+1+childIndex——前面兄弟子批的内容会把它后面的
+                // entry 行整体下移,固定偏移会错位;用 absLineToEntry 登记的真实绝对索引。
+                let entryAbs = parent.summaryAbsIdx + 1 + b.groupChildIndex;
+                for (const [idx, target] of absLineToEntry) {
+                    if (target.batchId === parent.id && target.entryIndex === b.groupChildIndex) {
+                        entryAbs = idx;
+                        break;
+                    }
+                }
+                anchor = entryAbs;
+            }
+            else {
+                anchor = parent.summaryAbsIdx + (expandedBatches.has(parent.id) ? parent.renderedCount : 0);
+            }
+            layout.contentInsertAfter(anchor, [sanitizeRow(summary)], false);
+            b.summaryAbsIdx = anchor + 1;
+            return;
+        }
         layout.contentWrite(summary + '\n');
         b.summaryAbsIdx = Math.max(0, layout.totalRows() - 2);
         // 首条摘要通过增量 contentWrite 落屏时，markdown→普通内容的边界可能只更新了
@@ -241,6 +386,61 @@ export function findBatchByAbsLine(absLine) {
 export function isExpanded(id) {
     return expandedBatches.has(id);
 }
+/** 展开 batch 第一层(逐条工具调用)。供子 agent 实时运行态:执行中逐条展示。
+ *  live=true 时不锚定视口(实时输出跟随底部),区别于鼠标点击展开(保持视口不跳)。 */
+export function expandBatch(id, layout, live = false) {
+    const b = batches.get(id);
+    if (b && !expandedBatches.has(id))
+        expand(b, layout, live);
+}
+/**
+ * 展开态下**追加渲染**新增的明细行(子 agent 逐条追加工具时用)。
+ * 只插入 entries[renderedCount, ...) 中尚未渲染的条目,绝不重建——运行态下
+ * 并行多个批时,重建会按 entries.length 删除,误删其它子 agent 的批行。
+ * 未展开则 no-op。
+ */
+export function refreshBatchExpanded(id, layout) {
+    const b = batches.get(id);
+    if (!b || !expandedBatches.has(id))
+        return;
+    if (b.summaryAbsIdx < 0)
+        return; // 摘要行未落盘(父组容器折叠中):无处可挂,等展开时统一渲染
+    if (b.entries.length <= b.renderedCount)
+        return;
+    const newEntries = b.entries.slice(b.renderedCount);
+    const lines = buildExpandedLines(newEntries, b.indent ?? '');
+    // 实时追加:不锚定视口,让新明细行自然出现在屏底。
+    // 组容器批的 entry 与子批摘要行交错,新 entry 必须插在当前块末尾,
+    // 不能简单用 summaryAbsIdx+renderedCount(否则 entry 会插到前一个子批摘要行之前)。
+    let anchor = b.summaryAbsIdx + b.renderedCount;
+    if (b.groupParent) {
+        let maxIdx = b.summaryAbsIdx;
+        for (const [idx, target] of absLineToEntry) {
+            if (target.batchId === b.id && idx > maxIdx)
+                maxIdx = idx;
+        }
+        for (const child of batches.values()) {
+            if (child.parentId === b.id && child.summaryAbsIdx >= 0) {
+                let childEnd = child.summaryAbsIdx;
+                if (expandedBatches.has(child.id)) {
+                    childEnd += child.renderedCount;
+                    for (const j of child.expandedEntries) {
+                        childEnd += buildEntryDetailLines(child.entries[j], entryDetailIndent(child.entries, j)).length;
+                    }
+                }
+                if (childEnd > maxIdx)
+                    maxIdx = childEnd;
+            }
+        }
+        anchor = maxIdx;
+    }
+    layout.contentInsertAfter(anchor, lines, false);
+    // 登记新增明细行的点击命中(按实际插入位置)
+    for (let i = 0; i < newEntries.length; i++) {
+        absLineToEntry.set(anchor + 1 + i, { batchId: b.id, entryIndex: b.renderedCount + i });
+    }
+    b.renderedCount = b.entries.length;
+}
 /**
  * 切换 batch 展开/折叠;无变化时 no-op。
  * 折叠:从 buffer 删详情行(mid-buffer delete);
@@ -259,13 +459,38 @@ export function toggleBatch(id, layout) {
         expand(b, layout);
     }
 }
-function expand(b, layout) {
-    const lines = buildExpandedLines(b.entries);
-    layout.contentInsertAfter(b.summaryAbsIdx, lines);
+function expand(b, layout, live = false) {
+    if (b.summaryAbsIdx < 0)
+        return; // 摘要行未落盘时展开会把明细插到 buffer 头部
+    const lines = buildExpandedLines(b.entries, b.indent ?? '');
+    layout.contentInsertAfter(b.summaryAbsIdx, lines, !live);
     expandedBatches.add(b.id);
+    b.renderedCount = b.entries.length;
     for (let i = 0; i < b.entries.length; i++) {
         absLineToEntry.set(b.summaryAbsIdx + 1 + i, { batchId: b.id, entryIndex: i });
     }
+    // 组容器批展开时:把之前被折叠隐藏的子批摘要行重新插回对应 entry 下方,
+    // 否则子批摘要行会留在父批摘要行之后、造成明细重复/错位。
+    if (b.groupParent) {
+        const children = [...batches.values()]
+            .filter((x) => x.parentId === b.id)
+            .sort((a, b) => (a.groupChildIndex ?? 0) - (b.groupChildIndex ?? 0));
+        for (const child of children) {
+            const entryAbs = findParentEntryAbsLine(b.id, child.groupChildIndex ?? 0);
+            const anchor = entryAbs ?? b.summaryAbsIdx + b.renderedCount;
+            const summary = buildSummaryLine(child, true);
+            layout.contentInsertAfter(anchor, [sanitizeRow(summary)], !live);
+            child.summaryAbsIdx = anchor + 1;
+            absLineToBatchId.set(child.summaryAbsIdx, child.id);
+        }
+    }
+}
+function findParentEntryAbsLine(parentId, entryIndex) {
+    for (const [idx, target] of absLineToEntry) {
+        if (target.batchId === parentId && target.entryIndex === entryIndex)
+            return idx;
+    }
+    return null;
 }
 /** mutation 独占 batch 收尾后立即展示其调用概要和 diff。 */
 export function expandSingleEntryFully(id, layout) {
@@ -285,12 +510,47 @@ export function expandSingleEntryFully(id, layout) {
     absLineToEntry.set(b.summaryAbsIdx + 1, { batchId: id, entryIndex: 0 });
 }
 function collapse(b, layout) {
-    let lineCount = b.entries.length;
+    // 只删除实际渲染的明细行(renderedCount),而非 entries.length——运行态下
+    // entries 可能多于已渲染行,按 entries.length 会多删并行批量子 agent 的行。
+    let lineCount = b.renderedCount;
     for (const i of b.expandedEntries) {
         lineCount += buildEntryDetailLines(b.entries[i], entryDetailIndent(b.entries, i)).length;
     }
+    // 组容器批折叠时:一并移除嵌套子批的摘要行(及其已展开详情),
+    // 否则父批再次展开后子批摘要仍残留在明细区,出现重复行。
+    if (b.groupParent) {
+        const children = [...batches.values()].filter((x) => x.parentId === b.id);
+        for (const child of children) {
+            // 未落盘的子批(父批折叠期间新建)在 buffer 里没有对应行,计进 lineCount 会多删相邻正文。
+            if (child.summaryAbsIdx < 0) {
+                child.renderedCount = 0;
+                child.expandedEntries.clear();
+                expandedBatches.delete(child.id);
+                continue;
+            }
+            lineCount += 1; // 子批摘要行本身
+            if (expandedBatches.has(child.id)) {
+                // 子批自身展开时,它的第一层明细行(renderedCount)也在父批块内,必须一并计入,
+                // 否则删少了会留下孤儿明细行。
+                lineCount += child.renderedCount;
+                for (const j of child.expandedEntries) {
+                    lineCount += buildEntryDetailLines(child.entries[j], entryDetailIndent(child.entries, j)).length;
+                }
+                child.expandedEntries.clear();
+                expandedBatches.delete(child.id);
+            }
+            child.renderedCount = 0;
+            absLineToBatchId.delete(child.summaryAbsIdx);
+            child.summaryAbsIdx = -1;
+            for (const [idx, target] of absLineToEntry) {
+                if (target.batchId === child.id)
+                    absLineToEntry.delete(idx);
+            }
+        }
+    }
     layout.contentDeleteFrom(b.summaryAbsIdx + 1, lineCount);
     expandedBatches.delete(b.id);
+    b.renderedCount = 0;
     b.expandedEntries.clear();
     for (const [idx, target] of absLineToEntry) {
         if (target.batchId === b.id)
@@ -301,11 +561,27 @@ function collapse(b, layout) {
 export function findEntryByAbsLine(absLine) {
     return absLineToEntry.get(absLine) ?? null;
 }
-/** 第二层：只展开/折叠某一个工具的完整输出。 */
+/** 第二层：只展开/折叠某一个工具的完整输出。
+ *  特殊地，组容器批(groupParent)下的 sub-agent entry 行点击时，
+ *  切换的是对应子 Agent 批(child batch)的展开/折叠，而不是 entry 自身详情。 */
 export function toggleEntry(batchId, entryIndex, layout) {
     const b = batches.get(batchId);
     if (!b || !expandedBatches.has(batchId))
         return;
+    // 组容器批的 entry 对应一个子 Agent 批；点击 entry 行应展开/折叠该 entry
+    // 自身的详情（即子 agent 返回的完整文本输出）。子 agent 的工具调用列表由点击
+    // 子批自己的摘要行（● 子 Agent 完成 ...）来控制。
+    if (b.groupParent) {
+        // 如果该 sub-agent entry 没有可展开的详情，fallback 到 toggle 子批工具列表。
+        const details = buildEntryDetailLines(b.entries[entryIndex], entryDetailIndent(b.entries, entryIndex));
+        if (details.length === 0) {
+            const child = [...batches.values()].find((x) => x.parentId === batchId && x.groupChildIndex === entryIndex);
+            if (child) {
+                toggleBatch(child.id, layout);
+            }
+            return;
+        }
+    }
     let headerIdx = -1;
     for (const [idx, target] of absLineToEntry) {
         if (target.batchId === batchId && target.entryIndex === entryIndex)
@@ -369,7 +645,19 @@ export function shiftBatchesAfter(absIdx, delta) {
             b.summaryAbsIdx = Math.max(0, b.summaryAbsIdx + delta);
     }
 }
-// ── history 回放支持 ──
+/** 更新 batch 摘要行标签(子 agent 批:运行中→完成/失败)。 */
+export function setBatchLabel(id, label) {
+    const b = batches.get(id);
+    if (b)
+        b.label = label;
+}
+/** 设置/清除运行态标志:running=true 时摘要行用「运行中」专属图标,收尾时置 false。 */
+export function setBatchRunning(id, running) {
+    const b = batches.get(id);
+    if (b)
+        b.running = running;
+}
+/** history 回放支持 ── */
 /** 把已构造好的 BatchEntry[] 落成可切换摘要行(用于 renderHistory 回放)。
  *  含 mutation(write_file/edit_file)时整批展开；普通批次保留与实时 flushToolBatch 相同的空行边界。 */
 export function writeSummaryOnly(entries, layout) {

package/dist/ui/layout.js

@@ -10,6 +10,11 @@ import { renderMarkdown } from './markdown.js';
 import { t } from '../i18n/index.js';
 // ── 内部状态 ──
 let active = false;
+/** 是否处于全屏 TUI(alt screen)激活态。非 TTY / 嵌入宿主(host)下为 false。
+ *  子 agent 等异步路径据此判断能否把中间过程实时写入主内容区。 */
+export function isTuiActive() {
+    return active;
+}
 // ── 裸 console 防御:第三方库(如 openai SDK)可能用 console.log 直写 stdout,
 // 在 RUNNING 态会落到光标所在的底栏输入框,污染输入。进入 TUI 后把 console.*
 // 劫持到 contentWrite,统一进内容区(运行态下 contentWrite 末尾会把真光标归位输入框),
@@ -587,8 +592,12 @@ export function rewindContent(rowsToRewind) {
  *
  * 续写位(contentRow):若原写头在插入点之后,前移 lines.length,保持相对位置;
  * 若原写头 ≤ after,不变(新行在写头之后)。非 TTY 直接调 content.insertAfter。
+ *
+ * keepViewport:鼠标点击展开时 true(视口锚定原位,详情在下方展开,屏幕不跳);
+ * 子 agent 实时嵌套渲染时传 false —— 那是"新内容"而非"回看展开",必须跟随屏底,
+ * 否则每插一行就把视口冻住 1 行,子 agent 跑起来后主内容区看着像卡住不动。
  */
-export function contentInsertAfter(after, lines) {
+export function contentInsertAfter(after, lines, keepViewport = true) {
     if (!active || lines.length === 0)
         return;
     const g = getGeo();
@@ -616,7 +625,7 @@ export function contentInsertAfter(after, lines) {
     // 而不是自动跳到展开内容底部(用户体验:点击摘要行,视口不动,详情在下方展开)。
     // 关键:插入点绝对行 = after;插入前视口尾行绝对行 = totalBefore - 1;
     // 插入后要让原视口尾行仍在屏底 → scrollOffset = 插入后新增的、在原视口尾行之后的行数。
-    if (!scrolled && after < totalBefore) {
+    if (keepViewport && !scrolled && after < totalBefore) {
         // 插入点在原缓冲内(非追加到末尾),计算需要滚动的偏移量
         const insertedAfterViewport = after >= (totalBefore - g.contentBottom);
         if (insertedAfterViewport) {

package/package.json

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