mocode-ai 1.6.4 → 1.6.6

package/dist/tools/builtins/session-search.js

@@ -0,0 +1,33 @@
+import { config } from '../../config/index.js';
+import { searchArchiveIndex } from '../../session/retention.js';
+// ---------- session_search ----------
+// episodic 层入口:跨会话搜索已归档会话(首条用户消息 + 摘要,BM25)。
+// 已 purge(正文已删)的会话同样可命中——meta+摘要永久保留。需要整段恢复时,
+// 未 purge 的会话仍可用 --resume <id> 从 archive 取回(见 retention loadArchivedSession)。
+export const sessionSearchTool = {
+    name: 'session_search',
+    description: 'Search archived past sessions in this workspace by keyword (BM25 over the first user message and the session summary). Returns session id, date, and summary. Use to recall what was decided or done in earlier conversations.',
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Keywords describing the past session' },
+            limit: { type: 'integer', description: 'Number of sessions to return, default 10' },
+        },
+        required: ['query'],
+    },
+    async execute(args) {
+        const query = String(args.query ?? '').trim();
+        if (!query)
+            return '错误:缺少 query。';
+        const limit = typeof args.limit === 'number' ? args.limit : 10;
+        const hits = searchArchiveIndex(config.sessionDir, query, limit);
+        if (hits.length === 0)
+            return `(无匹配的归档会话:query="${query}")`;
+        return hits
+            .map((h) => {
+            const status = h.purgedAt ? ' [正文已清除,仅摘要]' : '';
+            return `# ${h.id} · ${h.createdAt}${status}\n${h.summary || h.firstUser}`;
+        })
+            .join('\n\n---\n\n');
+    },
+};

package/dist/tools/builtins/task.js

@@ -81,6 +81,8 @@ export const subAgentTool = {
             retryable: false,
             output,
             usage: result.usage,
+            // P4 闸3:只归属本子 agent 树真实改动;tool-runtime 允许工具自报覆盖整轮快照。
+            changedFiles: result.changedFiles ?? [],
         };
         return outcome;
     },

package/dist/tools/constants.js

@@ -18,6 +18,14 @@ export const MAX_HISTORY_RESULT = 8000;
 export const MAX_SKILL_RESULT = 64000;
 /** 微压缩时旧工具结果截到的存根长度(字符)。 */
 export const MAX_OLD_TOOL_STUB = 600;
+// ── 磁盘侧治理(见 session/store.ts)──────────────────────────────────────
+/** trace.jsonl 单文件大小上限(字节):超过即把整份 gzip 轮转为 trace.N.jsonl.gz 并清空。
+ *  trace 是纯诊断数据,可激进轮转;512KB 约含千余条事件。 */
+export const MAX_TRACE_BYTES = 512 * 1024;
+/** 保留的历史 trace 轮转份数(trace.1 .. trace.N),更老的硬删。 */
+export const MAX_TRACE_ROTATIONS = 3;
+/** rollback snapshots 压缩前滚动窗口:无论是否 compact,仅保留最近 N 个 user turn 的快照。 */
+export const MAX_SNAPSHOT_TURNS = 50;
 // ── 上下文压缩摘要(见 session/compact.ts defaultSummarize)────────────────
 /** 摘要输入单条消息封顶:逐条封顶保证每轮对话都有代表,替代整段中截(会切掉中间整轮)。
  *  转录总量超 SUMMARY_TRANSCRIPT_WINDOW_RATIO 时,这些封顶会被等比缩小重拼。 */

package/dist/tools/read-dedup.js

@@ -0,0 +1,62 @@
+const MAX_RANGES_PER_PATH = 5;
+const MAX_PATHS = 200;
+export class ReadDedup {
+    /** Map 保序:超容量时删最老(第一个)key。 */
+    entries = new Map();
+    currentStep = 0;
+    /** model-turn 每步调用:钉住 step(指针消息里展示 "since step K")。 */
+    beginStep(step) {
+        this.currentStep = step;
+    }
+    /** trim 变更 history 内容后调用:所有存活条目失活(其内容可能已不在 context)。 */
+    markContextChanged() {
+        for (const list of this.entries.values())
+            for (const e of list)
+                e.hot = false;
+    }
+    touch(path) {
+        let list = this.entries.get(path);
+        if (list) {
+            // LRU:命中路径挪到末尾。
+            this.entries.delete(path);
+        }
+        else {
+            list = [];
+            if (this.entries.size >= MAX_PATHS) {
+                const oldest = this.entries.keys().next().value;
+                if (oldest !== undefined)
+                    this.entries.delete(oldest);
+            }
+        }
+        this.entries.set(path, list);
+        return list;
+    }
+    /** 记录一次实际返回的读取(全量返回之后调用)。 */
+    record(path, startLine, endLine, hash) {
+        const list = this.touch(path);
+        list.push({ startLine, endLine, hash, step: this.currentStep, hot: true });
+        while (list.length > MAX_RANGES_PER_PATH)
+            list.shift();
+    }
+    /**
+     * 查询重复读命中:存在 hot 条目,其行区间覆盖请求区间、hash 相同。
+     * 无命中返 null(调用方照常全量返回)。
+     */
+    findUnchanged(path, startLine, endLine, hash) {
+        const list = this.entries.get(path);
+        if (!list)
+            return null;
+        // 从新到旧找。
+        for (let i = list.length - 1; i >= 0; i--) {
+            const e = list[i];
+            if (e.hot && e.hash === hash && e.startLine <= startLine && e.endLine >= endLine) {
+                return { step: e.step, hash };
+            }
+        }
+        return null;
+    }
+}
+/** 每用户 turn 一个 scope。 */
+export function createReadDedup() {
+    return new ReadDedup();
+}

package/dist/tools/tool-runtime.js

@@ -292,6 +292,7 @@ export class ToolRuntime {
                         callId: opts?.callId,
                         allowedToolNames: opts?.allowedToolNames,
                         delegation: opts?.delegation,
+                        readDedup: opts?.readDedup,
                     });
                 }
                 finally {

package/dist/ui/batch.js

@@ -72,6 +72,8 @@ export function reset() {
     expandedBatches.clear();
     callToBatch.clear();
     groupChildIndexByCall.clear();
+    // 复位外部暂停态(兜底:面板异常退出未走 cleanup 时,避免暂停泄漏到后续 turn)。
+    _sweepSuspended = false;
     // 扫光心跳随运行态批自停:batch 全清后 hasRunningBatch 必为 false。
     syncSweepTimer();
 }
@@ -82,6 +84,12 @@ export function reset() {
  *  opts.groupChildIndex:本批作为组子批时在父 entries 中的序号(插入锚点用)。 */
 export function beginBatch(label, opts) {
     const id = `b${++_idCounter}`;
+    const parentId = opts?.parentId && batches.has(opts.parentId) ? opts.parentId : undefined;
+    const parent = parentId ? batches.get(parentId) : undefined;
+    // 缩进未显式给定时按父层级自动推导:组容器批的子批 = 两层 entry 缩进;
+    // 普通子 agent 批下再嵌套 = 父批缩进 + 两层(树状逐层加深)。
+    const indent = opts?.indent ??
+        (parent ? (parent.groupParent ? SUB_BATCH_INDENT : (parent.indent ?? '') + SUB_BATCH_INDENT) : undefined);
     batches.set(id, {
         id,
         summaryAbsIdx: -1,
@@ -90,8 +98,8 @@ export function beginBatch(label, opts) {
         renderedCount: 0,
         startedAt: Date.now(),
         label,
-        indent: opts?.indent,
-        parentId: opts?.parentId && batches.has(opts.parentId) ? opts.parentId : undefined,
+        indent,
+        parentId,
         groupParent: opts?.groupParent ?? false,
         groupChildIndex: opts?.groupChildIndex,
         running: opts?.running ?? false,
@@ -123,7 +131,8 @@ export function recordCall(id, name, callSummary, callId) {
     // 已完成的累计探索后又追加工具：恢复进行中，待新结果返回再完成。
     b.finishedAt = undefined;
     b.entries.push({ name, callSummary, resultSummary: '', diffBlock: null });
-    if (callId && b.groupParent)
+    // 对所有批登记:普通批内的 sub-agent 调用(子 agent 嵌套派生)同样要靠它定位锚点。
+    if (callId)
         groupChildIndexByCall.set(callId, b.entries.length - 1);
     // 新增 entry = 本批重新「在飞」→ 扫光心跳起(此前收口时可能已停)。
     syncSweepTimer();
@@ -149,8 +158,8 @@ export function recordResult(id, name, resultSummary, diffBlock, fullOutput, fai
     const b = batches.get(id);
     if (!b || b.entries.length === 0)
         return;
-    // 组容器批:优先按 callId 定位 entry,防止多个同名 sub-agent 结果互相填错位置。
-    if (callId && b.groupParent) {
+    // 优先按 callId 定位 entry,防止多个同名工具(并行调用 / 嵌套 sub-agent)结果互相填错。
+    if (callId) {
         const idx = groupChildIndexByCall.get(callId);
         if (idx != null && idx < b.entries.length && !isEntryDone(b.entries[idx])) {
             const e = b.entries[idx];
@@ -227,6 +236,12 @@ let _sweepTimer = null;
  * 存 layout 而不自己 import 判断 TUI 是否激活,是沿用「agent 侧注入」的既有形态。
  */
 let _sweepLayout = null;
+/**
+ * 扫光被外部暂停(介入面板 ask_human 期间):摘要行已在内容区底部,而菜单同样从
+ * contentBottom 向上展开,心跳若继续逐帧重画该行会写进菜单区、把「◇ 正在探索」
+ * 泄漏到选项之间(用户截图实证)。暂停只冻结心跳,不清状态;resumeSweep 后立即恢复。
+ */
+let _sweepSuspended = false;
 /**
  * 批是否「在飞」(需要扫光与实时耗时)。判据是**已收口即落定**:
  * `endBatch` 必设 finishedAt,故先看它 —— 否则任何「endBatch 了但 running 标志残留」
@@ -250,7 +265,7 @@ function hasLiveBatch() {
 }
 /** 扫光可用性:TUI(非 TTY 输出纯文本,不能塞动画转义)+ 有在飞批 + 有可写回的 layout。 */
 function sweepEnabled() {
-    return ui.isTTY && _sweepLayout != null && hasLiveBatch();
+    return !_sweepSuspended && ui.isTTY && _sweepLayout != null && hasLiveBatch();
 }
 /**
  * 同步扫光心跳开关(建批/收批时调)。心跳随最后一个运行态批结束自停,不常驻空转。
@@ -295,6 +310,28 @@ export function syncSweepTimer() {
         return timer;
     })();
 }
+/**
+ * 暂停扫光心跳(介入面板进入时调):syncSweepTimer 经 sweepEnabled 判定立即清 timer;
+ * 暂停期间 showLiveBatch/endBatch 再调 syncSweepTimer 也不会重启。幂等:重复挂起不抖状态。
+ */
+export function suspendSweep() {
+    if (_sweepSuspended)
+        return;
+    _sweepSuspended = true;
+    syncSweepTimer();
+}
+/** 恢复扫光(介入面板退出时调):若仍有在飞批则心跳立即重建;无在飞批则保持停止。幂等。 */
+export function resumeSweep() {
+    if (!_sweepSuspended)
+        return;
+    _sweepSuspended = false;
+    syncSweepTimer();
+}
+/** 测试钩子:扫光当前是否处于外部暂停态(介入面板泄漏回归用)。 */
+export const __sweepTest = {
+    isSuspended: () => _sweepSuspended,
+    timerActive: () => _sweepTimer !== null,
+};
 /**
  * 计算本帧高亮带覆盖的字符区间 `[start, end)`(纯函数,导出供帧推进/带宽测试)。
  *
@@ -544,16 +581,16 @@ export function endBatch(id, layout) {
         absLineToBatchId.set(b.summaryAbsIdx, b.id);
         return;
     }
-    // 子批尚未落盘(组容器折叠期间被隐藏 / 折叠后才新建)。绝不能 contentWrite 到 buffer 末尾:
-    // 那会在正文区留下一条游离的子 agent 摘要行,父批再展开时就变成「多出来的第三条」。
+    // 子批尚未落盘(父批折叠期间被隐藏 / 折叠后才新建)。绝不能 contentWrite 到 buffer 末尾:
+    // 那会在正文区留下一条游离的子批摘要行,父批再展开时就变成「多出来的第三条」。
     if (b.parentId) {
         const parent = batches.get(b.parentId);
-        if (parent?.groupParent) {
+        if (parent) {
             // 父批折叠中:不渲染,等 expand() 统一恢复(那时会用最新状态重建摘要行)。
             if (!expandedBatches.has(parent.id) || parent.summaryAbsIdx < 0)
                 return;
-            // 父批已展开:插到自己的 └─ sub-agent 行下方。
-            const anchor = findParentEntryAbsLine(parent.id, b.groupChildIndex ?? 0) ?? parent.summaryAbsIdx;
+            // 父批已展开:插到对应的内部 sub-agent entry 行下方。
+            const anchor = childBatchAnchor(parent, b.groupChildIndex);
             layout.contentInsertAfter(anchor, [sanitizeRow(buildSummaryLine(b))]);
             b.summaryAbsIdx = anchor + 1;
             absLineToBatchId.set(b.summaryAbsIdx, b.id);
@@ -584,29 +621,15 @@ export function showLiveBatch(id, layout) {
         // 让「子 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)) {
+            // 父批(组容器批或普通子 agent 批)折叠时,子批摘要行先不渲染;
+            // 等父批展开时由 expand 统一恢复,避免摘要残留/重复行。
+            if (!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);
-            }
+            // 父批已展开:插到本批对应的内部 sub-agent entry 行下方(按真实登记位置,
+            // 不用固定偏移——兄弟内容会把后续行整体下移);找不到 entry 时退化到父批块末。
+            const anchor = childBatchAnchor(parent, b.groupChildIndex);
             layout.contentInsertAfter(anchor, [sanitizeRow(summary)], false);
             b.summaryAbsIdx = anchor + 1;
             absLineToBatchId.set(b.summaryAbsIdx, b.id); // 运行态同样开放点击(endBatch 幂等重登)
@@ -687,43 +710,17 @@ export function refreshBatchExpanded(id, layout) {
     const newEntries = b.entries.slice(b.renderedCount);
     const lines = buildExpandedLines(b, b.indent ?? '', b.renderedCount);
     // 实时追加:不锚定视口,让新明细行自然出现在屏底。
-    // 组容器批的 entry 与子批摘要行交错,新 entry 必须插在当前块末尾,
-    // 不能简单用 summaryAbsIdx+renderedCount(否则 entry 会插到前一个子批摘要行之前)。
-    // 块末还必须计入已渲染 entry 的二层展开明细行(toggleEntry 把明细插在 entry 行下方,
-    // 会把后续 entry 行整体下移;运行态可交互后这条路径高频,漏算会插错位)。
+    // 锚点必须是本批已渲染块的真实最末行——不能简单用 summaryAbsIdx+renderedCount:
+    // ①toggleEntry 展开的二层明细行会把后续行下移;
+    // ②挂在内部 sub-agent entry 下的嵌套子批(摘要 + 其展开内容)也在本批块内。
+    // 组容器批与普通子 agent 批走同一计算。
     let anchor = b.summaryAbsIdx + b.renderedCount;
     for (const j of b.expandedEntries) {
         if (j < b.renderedCount) {
             anchor += buildEntryDetailLines(b.entries[j], entryDetailIndent(b.indent ?? '')).length;
         }
     }
-    if (b.groupParent) {
-        let maxIdx = anchor;
-        for (const [idx, target] of absLineToEntry) {
-            if (target.batchId !== b.id)
-                continue;
-            // entry 行自身(含其二层明细)的块末位置
-            const end = b.expandedEntries.has(target.entryIndex)
-                ? idx + buildEntryDetailLines(b.entries[target.entryIndex], entryDetailIndent(b.indent ?? '')).length
-                : idx;
-            if (end > maxIdx)
-                maxIdx = end;
-        }
-        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.indent ?? '')).length;
-                    }
-                }
-                if (childEnd > maxIdx)
-                    maxIdx = childEnd;
-            }
-        }
-        anchor = maxIdx;
-    }
+    anchor = blockEndAbsIdx(b, anchor);
     layout.contentInsertAfter(anchor, lines, false);
     // 登记新增明细行的点击命中(按实际插入位置)
     for (let i = 0; i < newEntries.length; i++) {
@@ -761,15 +758,15 @@ function expand(b, layout, live = false) {
         absLineToEntry.set(b.summaryAbsIdx + 1 + i, { batchId: b.id, entryIndex: i });
         b.entries[i].renderedDigest = entryLineDigest(b.entries[i]); // 记指纹,供运行态结果回填原位刷新
     }
-    // 组容器批展开时:把之前被折叠隐藏的子批摘要行重新插回对应 entry 下方,
+    // 展开时:把之前被折叠隐藏的子批摘要行重新插回对应的内部 sub-agent entry 下方,
     // 否则子批摘要行会留在父批摘要行之后、造成明细重复/错位。
-    if (b.groupParent) {
+    // 组容器批与普通子 agent 批同一路径(嵌套孙批保持折叠,逐层展开)。
+    {
         const children = [...batches.values()]
             .filter((x) => x.parentId === b.id)
-            .sort((a, b) => (a.groupChildIndex ?? 0) - (b.groupChildIndex ?? 0));
+            .sort((x, y) => (x.groupChildIndex ?? 0) - (y.groupChildIndex ?? 0));
         for (const child of children) {
-            const entryAbs = findParentEntryAbsLine(b.id, child.groupChildIndex ?? 0);
-            const anchor = entryAbs ?? b.summaryAbsIdx + b.renderedCount;
+            const anchor = childBatchAnchor(b, child.groupChildIndex);
             const summary = buildSummaryLine(child, true);
             layout.contentInsertAfter(anchor, [sanitizeRow(summary)], !live);
             child.summaryAbsIdx = anchor + 1;
@@ -784,6 +781,75 @@ function findParentEntryAbsLine(parentId, entryIndex) {
     }
     return null;
 }
+/** 子批挂到父批(组容器批或普通子 agent 批)时的插入锚点:
+ *  优先取该子批对应的内部 sub-agent entry 真实行;未登记则退化到父批已渲染块末。 */
+function childBatchAnchor(parent, childIndex) {
+    if (childIndex != null) {
+        const entryAbs = findParentEntryAbsLine(parent.id, childIndex);
+        if (entryAbs != null)
+            return entryAbs;
+    }
+    let end = parent.summaryAbsIdx + parent.renderedCount;
+    for (const j of parent.expandedEntries) {
+        end += buildEntryDetailLines(parent.entries[j], entryDetailIndent(parent.indent ?? '')).length;
+    }
+    return blockEndAbsIdx(parent, end);
+}
+/** 批已渲染块的真实最末绝对行:把直接挂在本批下的子批(摘要行;若子批展开,
+ *  还含其明细行与再嵌套子批)全部计入,递归得到整棵树的块末。 */
+function blockEndAbsIdx(b, initial) {
+    let maxIdx = initial;
+    for (const child of batches.values()) {
+        if (child.parentId !== b.id || child.summaryAbsIdx < 0)
+            continue;
+        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.indent ?? '')).length;
+            }
+            childEnd = blockEndAbsIdx(child, childEnd);
+        }
+        if (childEnd > maxIdx)
+            maxIdx = childEnd;
+    }
+    return maxIdx;
+    return maxIdx;
+}
+/** 折叠父批的所有直接子批(递归):返回这些子批在 buffer 中占据的总行数。
+ *  未落盘子批(父批折叠期间新建)在 buffer 无对应行,只清状态不计数,避免多删相邻正文。 */
+function foldChildren(parentId) {
+    let count = 0;
+    for (const child of batches.values()) {
+        if (child.parentId !== parentId)
+            continue;
+        if (child.summaryAbsIdx < 0) {
+            child.renderedCount = 0;
+            child.expandedEntries.clear();
+            expandedBatches.delete(child.id);
+            foldChildren(child.id);
+            continue;
+        }
+        count += 1; // 子批摘要行本身
+        if (expandedBatches.has(child.id)) {
+            count += child.renderedCount;
+            for (const j of child.expandedEntries) {
+                count += buildEntryDetailLines(child.entries[j], entryDetailIndent(child.indent ?? '')).length;
+            }
+            count += foldChildren(child.id);
+            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);
+        }
+    }
+    return count;
+}
 /** mutation 独占 batch 收尾后立即展示其调用概要和 diff。 */
 export function expandSingleEntryFully(id, layout) {
     const b = batches.get(id);
@@ -815,38 +881,9 @@ function collapse(b, layout) {
     for (const i of b.expandedEntries) {
         lineCount += buildEntryDetailLines(b.entries[i], entryDetailIndent(b.indent ?? '')).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.indent ?? '')).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);
-            }
-        }
-    }
+    // 折叠时:递归移除挂在本批下的整棵子批树(子批摘要行 + 已展开明细),
+    // 否则父批再次展开后子批摘要/明细仍残留,出现重复行。组容器批与普通子 agent 批同一路径。
+    lineCount += foldChildren(b.id);
     layout.contentDeleteFrom(b.summaryAbsIdx + 1, lineCount);
     expandedBatches.delete(b.id);
     b.renderedCount = 0;
@@ -867,11 +904,10 @@ 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 子批工具列表。
+    // sub-agent entry(组容器批的顶层调用,或子 agent 内部嵌套派生)对应一个子批:
+    // 点击 entry 行优先展开/折叠该 entry 自身详情(子 agent 返回的完整文本输出);
+    // 只有没有自身详情时,才 fallback 到 toggle 对应子批的工具列表。
+    if (b.entries[entryIndex]?.name === 'sub-agent') {
         const details = buildEntryDetailLines(b.entries[entryIndex], entryDetailIndent(b.indent ?? ''));
         if (details.length === 0) {
             const child = [...batches.values()].find((x) => x.parentId === batchId && x.groupChildIndex === entryIndex);

package/dist/ui/composer.js

@@ -344,22 +344,6 @@ export async function promptComposer(opts = {}) {
         }
         return rows.length - 1;
     }
-    /** 上下移动一行(按展示行)。 */
-    function moveVertically(delta, extend) {
-        const rows = dispRows();
-        const idx = cursorDispIdx(rows);
-        const target = Math.max(0, Math.min(rows.length - 1, idx + delta));
-        const r = rows[target];
-        if (!r)
-            return;
-        // 保持视觉列:当前光标视觉列 → 目标展示行同列
-        const curRow = rows[idx];
-        const curText = curRow ? curRow.text : '';
-        const curOff = cur.col - (curRow ? curRow.start : 0);
-        const vis = displayWidth([...curText].slice(0, Math.max(0, curOff)).join(''));
-        const charCol = visColToCharCol(r.text, vis);
-        moveTo({ line: r.li, col: r.start + charCol }, extend);
-    }
     function moveByPage(delta, extend) {
         const rows = dispRows();
         const visible = Math.max(1, textRowCount());
@@ -716,10 +700,12 @@ export async function promptComposer(opts = {}) {
                 }
                 return;
             case 'up':
-                moveVertically(-1, extend);
+                // ↑ 始终跳到全文最前(Shift 扩展选区)
+                moveTo({ line: 0, col: 0 }, extend);
                 return;
             case 'down':
-                moveVertically(1, extend);
+                // ↓ 始终跳到全文最后(Shift 扩展选区)
+                moveTo({ line: lines.length - 1, col: lineLen(lines.length - 1) }, extend);
                 return;
             case 'home':
                 if (key.ctrl) {