@herbertgao/pi-extensions 2026.9.19 → 2026.10.0

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/mouse/layout.ts

@@ -1,8 +1,8 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { ThinkingPreviewBlock } from "../../feature/compact-thinking.ts";
 import { isCompactAssistantComponent } from "../compact-mode.ts";
-import { isMessageDisplayComponent } from "../message-display.ts";
 import { ToolGroupComponent } from "../tool/grouping.ts";
+import { isMessageDisplayComponent } from "../tool/message-display.ts";
 import { isToolExecutionComponent, stripTerminalSequencesPreservingLayout } from "./packets.ts";
 import { getScrollButtonWidget } from "./scroll.ts";
 
@@ -11,12 +11,17 @@ export type ComponentRowHit = {
 	row: number;
 	/** 内部工具命中时所属的展开 group；普通卡点击仍折叠整个 group。 */
 	group?: ToolGroupComponent;
+	/** compact 展开面板内的命中：外层面板，单击非提示区时收起它。 */
+	owner?: any;
 };
 
-/** 行内 [click to show more] 提示的命中列区间（1-based，含两端）。 */
+/** 行内 [click to show more] / [↑ Collapse] 提示的命中列区间（1-based，含两端）。 */
 export function collapsedHintHitbox(line: string): { startCol: number; endCol: number } | null {
 	const plain = stripTerminalSequencesPreservingLayout(line);
-	const match = /(\([^()\n]* \/ click\)|click to show more|to show more)(?=\)?\s*$)/.exec(plain);
+	const match =
+		/(\([^()\n]* \/ click\)|click to show more|to show more|↑ Collapse|to collapse)(?=\)?\s*$)/.exec(
+			plain,
+		);
 	if (!match?.[1]) return null;
 	const startCol = visibleWidth(plain.slice(0, match.index)) + 1;
 	return { startCol, endCol: startCol + visibleWidth(match[1]) - 1 };
@@ -119,11 +124,15 @@ export function componentAtLocalRow(
 		return { component, row: localRow };
 	}
 	if (isCompactAssistantComponent(component)) {
-		// 折叠：整行摘要。展开：先命中内部 thinking hint，其余仍归外层卡片。
+		// 折叠：整行摘要。展开：先命中面板内 thinking/工具卡/文本，其余（空行）仍归外层卡片。
 		if (component.expanded === true) {
 			const inner = nestedChildAtRow(component, localRow, width);
-			if (inner instanceof ThinkingPreviewBlock) {
-				return { component: inner, row: localRow };
+			if (inner) {
+				// 展开的 thinking 有自己的展开态：点它只收它自己，不收整块面板。
+				const ownExpandable = inner instanceof ThinkingPreviewBlock && inner.expanded === true;
+				return ownExpandable
+					? { component: inner, row: localRow }
+					: { component: inner, row: localRow, owner: component };
 			}
 		}
 		return { component, row: localRow };

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/mouse/packets.ts

@@ -1,12 +1,16 @@
 import type { ExpandedToolIoView, ToolIoSection } from "../tool/result.ts";
-
-/** SGR 鼠标协议包（code;col;row + M/m 终结符）。 */
-export type SgrMousePacket = {
-	code: number;
-	col: number;
-	row: number;
-	final: "M" | "m";
-};
+import { walkComponentTree } from "../../utils/component-tree.ts";
+export {
+	stripTerminalSequences,
+	stripTerminalSequencesPreservingLayout,
+} from "../../utils/ansi-text.ts";
+export {
+	parseSgrMousePackets,
+	isSgrLeftPress,
+	isSgrLeftRelease,
+	isSgrIdleMotion,
+	type SgrMousePacket,
+} from "../../utils/sgr-mouse.ts";
 
 /** Final painted placement of one outermost tool/group row after parent layout. */
 export type FrameToolPlacement = {
@@ -24,53 +28,6 @@ const TOOL_FRAME_MARKER_RE = /\x1b_cc:t(\d+):(\d+)\x07/g;
 const TOOL_VIEW_MARKER_RE = /\x1b_cc:v(\d+):([io])\x07/g;
 export const toolFrameMarker = (id: number, row: number) => `\x1b_cc:t${id}:${row}\x07`;
 
-/**
- * 解析整段终端输入为 SGR 鼠标包序列；数据必须完全由连续 SGR 包组成
- * （夹杂其他字节返回 null，交由常规输入链处理）。
- */
-export function parseSgrMousePackets(data: string): SgrMousePacket[] | null {
-	const pattern = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
-	const packets: SgrMousePacket[] = [];
-	let offset = 0;
-
-	for (const match of data.matchAll(pattern)) {
-		if (match.index !== offset) return null;
-		offset = match.index + match[0].length;
-		packets.push({
-			code: Number(match[1]),
-			col: Number(match[2]),
-			row: Number(match[3]),
-			final: match[4] as "M" | "m",
-		});
-	}
-
-	return packets.length > 0 && offset === data.length ? packets : null;
-}
-
-/** 是否为左键按下（排除修饰键、32 表示 motion 事件）。 */
-export function isSgrLeftPress(packet: SgrMousePacket): boolean {
-	const baseButton = packet.code & ~(4 | 8 | 16 | 32);
-	return packet.final === "M" && baseButton === 0 && (packet.code & 32) === 0;
-}
-
-/** 是否为左键松开。 */
-export function isSgrLeftRelease(packet: SgrMousePacket): boolean {
-	const baseButton = packet.code & ~(4 | 8 | 16 | 32);
-	return packet.final === "m" && baseButton === 0 && (packet.code & 32) === 0;
-}
-
-/** 仅剥离终端序列、保留原布局（换行/空白不动），用于命中区间计算。 */
-export function stripTerminalSequencesPreservingLayout(value: string): string {
-	return value
-		.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
-		.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
-}
-
-/** 剥离终端序列并折叠空白（用于纯文本比较）。 */
-export function stripTerminalSequences(value: string): string {
-	return stripTerminalSequencesPreservingLayout(value).replace(/\s+/g, " ").trim();
-}
-
 /** 工具执行组件识别（toolCallId + setExpanded + render）。 */
 export function isToolExecutionComponent(value: any): boolean {
 	return Boolean(
@@ -83,24 +40,13 @@ export function isToolExecutionComponent(value: any): boolean {
 }
 
 /** 深度收集组件树中的工具执行组件（含 getMountedRoots 分支）。 */
-export function collectToolComponents(component: any, tools: any[], seen = new Set<any>()): void {
-	if (!component || typeof component !== "object" || seen.has(component)) return;
-	seen.add(component);
-	if (isToolExecutionComponent(component)) {
-		tools.push(component);
-		return;
-	}
-	if (Array.isArray(component.children)) {
-		for (const child of component.children) collectToolComponents(child, tools, seen);
-	}
-	try {
-		const mounted = component.getMountedRoots?.();
-		if (Array.isArray(mounted)) {
-			for (const root of mounted) collectToolComponents(root, tools, seen);
+export function collectToolComponents(component: any, tools: any[]): void {
+	walkComponentTree(component, (value: any) => {
+		if (isToolExecutionComponent(value)) {
+			tools.push(value);
+			return false;
 		}
-	} catch {
-		// renderer 切换中的惰性 Proxy 可能暂时没有 mounted roots。
-	}
+	});
 }
 
 /** 剥离一行中的零宽帧/视图 marker。 */

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/mouse/scroll.ts

@@ -8,35 +8,39 @@ import {
 import { config } from "../../config/config.ts";
 import { isLazyProxyTui } from "../../utils/fullscreen-detect.ts";
 import { parseSgrMousePackets } from "./packets.ts";
+import {
+	OFFICIAL_SCROLL_TO_END_KEY,
+	patchRegistry,
+	SCROLL_BUTTON_STATE_SLOT,
+	TOOL_MOUSE_TUI_SLOT,
+} from "../../utils/patch-keys.ts";
 
 const ZENTUI_PAGE_UP_INPUT = /^\x1b\[5;9(?::[12])?~$|^\x1b\[57421;9(?::[12])?u$|^\x1b\[1;6A$/;
 const ZENTUI_PAGE_DOWN_INPUT = /^\x1b\[6;9(?::[12])?~$|^\x1b\[57422;9(?::[12])?u$|^\x1b\[1;6B$/;
 const SCROLL_BOTTOM_SHORTCUT = "ctrl+end";
 
-/**
- * 当前安装的 tui 宿主。宿主放本模块（滚动按钮/调度依赖它），
- * 由 mouse-interaction 经 setToolMouseTui 维护；跨模块一律经绑定/setter 访问。
- *
- * 状态镜像到 globalThis（Symbol 槽）：jiti 转译下经 re-export 链读取的
- * 模块级 let 绑定是初始值快照（死绑定，实测恒 null），函数调用才是活引用。
- * 跨模块读取一律用 getToolMouseTui()，避免拿到加载时的快照。
- */
-const TOOL_MOUSE_TUI_SLOT = Symbol.for("pi.ccstyle.tool-mouse-tui");
-(globalThis as any)[TOOL_MOUSE_TUI_SLOT] ??= null;
+patchRegistry.ensure(TOOL_MOUSE_TUI_SLOT, () => null);
 export function getToolMouseTui(): any {
-	return (globalThis as any)[TOOL_MOUSE_TUI_SLOT];
+	return patchRegistry.get(TOOL_MOUSE_TUI_SLOT);
 }
 export function setToolMouseTui(tui: any): void {
-	(globalThis as any)[TOOL_MOUSE_TUI_SLOT] = tui;
+	patchRegistry.install(TOOL_MOUSE_TUI_SLOT, tui);
 }
 
-// 滚动按钮状态同 toolMouseTui：镜像到 globalThis（Symbol 槽），跨模块读取
-// 一律用 getter（jiti 转译下模块级 let 绑定是初始值快照）。
-const SCROLL_BUTTON_STATE_SLOT = Symbol.for("pi.ccstyle.scroll-button-state");
-type ScrollButtonState = { visible: boolean; hovered: boolean; widget: any };
+type ScrollButtonState = {
+	visible: boolean;
+	hovered: boolean;
+	widget: any;
+	/** 按钮可见期间新落的 transcript 块数（消息 + 工具卡）。 */
+	newCount: number;
+};
 function scrollButtonState(): ScrollButtonState {
-	const host = globalThis as any;
-	return (host[SCROLL_BUTTON_STATE_SLOT] ??= { visible: false, hovered: false, widget: null });
+	return patchRegistry.ensure(SCROLL_BUTTON_STATE_SLOT, () => ({
+		visible: false,
+		hovered: false,
+		widget: null,
+		newCount: 0,
+	}));
 }
 export function getScrollButtonVisible(): boolean {
 	return scrollButtonState().visible;
@@ -47,8 +51,32 @@ export function getScrollButtonHovered(): boolean {
 export function getScrollButtonWidget(): any {
 	return scrollButtonState().widget;
 }
+export function getScrollButtonNewCount(): number {
+	return scrollButtonState().newCount;
+}
 export function setScrollButtonVisible(visible: boolean): void {
-	scrollButtonState().visible = visible;
+	const state = scrollButtonState();
+	state.visible = visible;
+	// 计数只在离开底部期间有效：跟随输出即清零，文案回到 Back to bottom。
+	if (!visible) state.newCount = 0;
+}
+
+/**
+ * 记账一块新落进 transcript 的内容（用户/助手消息、工具卡）。
+ * 仅在按钮可见（已滚动离开底部）时累加，并请求重绘让按钮文案立即更新。
+ */
+export function noteNewTranscriptItem(): void {
+	const state = scrollButtonState();
+	const tui = getToolMouseTui();
+	if (!state.visible || !tui) return;
+	// 提交新消息时官方可能直接跳回底部（不经过滚动输入）：先按实时跟随状态校正，
+	// 否则跟随期间的内容会被当成“离开底部时的新消息”计入。
+	if (isAtTranscriptBottom(tui)) {
+		hideScrollButton(tui);
+		return;
+	}
+	state.newCount += 1;
+	tui.requestRender?.();
 }
 
 /** 返回是否发生变化（调用方据此决定是否需要重渲染）。 */
@@ -67,15 +95,16 @@ export function resetScrollButtonState(): void {
 	scrollButtonState().visible = false;
 	scrollButtonState().hovered = false;
 	scrollButtonState().widget = null;
+	scrollButtonState().newCount = 0;
 	scrollButtonSyncScheduled = false;
 }
 
 let scrollButtonSyncScheduled = false;
 
+// 交互开关只取决于配置模式：原实现按 isLazyProxyTui(toolMouseTui) 分两分支，
+// 两分支恒真（0.84+ 惰性 Proxy 下判定不再影响开关），折叠为单条件。
 export function toolMouseInteractionActive(): boolean {
-	if (config.mode === "off") return false;
-	if (isLazyProxyTui(getToolMouseTui())) return true;
-	return true;
+	return config.mode !== "off";
 }
 
 /** 惰性 Proxy 官方 fullscreen（TuiAltScreen）判定。 */
@@ -83,13 +112,12 @@ export function fullscreenLazyTui(tui: any): boolean {
 	return isLazyProxyTui(tui) && tui.mode === "fullscreen";
 }
 
-const OFFICIAL_SCROLL_TO_END_KEY = Symbol.for("pi.ccstyle.official-scroll-to-end");
-
 /** 关掉 pi 0.85 Jump to latest overlay，避免和本仓库 dock 按钮叠两层。 */
 export function disableOfficialScrollToEnd(tui: any): void {
 	if (!tui) return;
 	const current = tui.scrollToEndIndicator;
 	if (typeof current !== "function") return;
+	// 原函数放 object 里，避免惰性 Proxy 对 function 属性再包一层。
 	if (!tui[OFFICIAL_SCROLL_TO_END_KEY]) {
 		tui[OFFICIAL_SCROLL_TO_END_KEY] = { original: current };
 	}
@@ -210,12 +238,19 @@ export function updateScrollButtonFromInput(tui: any, data: string): void {
 	if (matchesKey(data, "enter") || matchesKey(data, "return")) hideScrollButton(tui);
 }
 
+/** 无新内容时提示原文案；有新内容时换成累计条数。 */
+function scrollButtonText(): string {
+	const count = getScrollButtonNewCount();
+	const shortcut = formatShortcut(SCROLL_BOTTOM_SHORTCUT);
+	if (count <= 0) return `Back to bottom · ${shortcut}`;
+	return `${count} new message${count === 1 ? "" : "s"} · ${shortcut}`;
+}
+
 export function renderScrollButton(width: number, theme: any): string[] {
 	if (!getScrollButtonVisible() || !fullscreenLazyTui(getToolMouseTui())) return [];
-	const shortcut = formatShortcut(SCROLL_BOTTOM_SHORTCUT);
 	const label = theme.fg(
 		getScrollButtonHovered() ? "text" : "accent",
-		`[ ↓ Back to bottom · ${shortcut} ]`,
+		`[ ↓ ${scrollButtonText()} ]`,
 	);
 	const leftPad = Math.max(0, Math.floor((width - visibleWidth(label)) / 2));
 	return [`${" ".repeat(leftPad)}${truncateToWidth(label, width, "…")}`];

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/tool/codemode.ts

@@ -0,0 +1,303 @@
+/**
+ * codemode 的结果渲染：折叠态把子调用摊成工具组那样的树，最后一行用 └ 收尾。
+ *
+ * 数据来自 `result.details.calls`（CodemodeNestedCall[]，partial 更新里也有），所以运行中就能
+ * 看到子调用进度。两个坑：
+ *
+ * - 子调用不会单独成行：pi 会跳过带 `parentToolCallId` 的 tool_execution_start，进度只能在这里显示。
+ * - 输出以 "Script completed\nWall time …\nOutput:\n" 开头（pi 原生也切掉），行数统计与展开正文都得去掉它，
+ *   否则折叠摘要会多算 3 行。
+ */
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../../utils/ansi-text.ts";
+import { toolLoadingIcon } from "../../utils/tool-loading-icon.ts";
+import { sanitizeToolResultText } from "../../utils/tool-result-sanitize.ts";
+import { mcpToolTitle } from "./mcp-title.ts";
+import {
+	type ToolCallSummary,
+	humanizeToolLabel,
+	renderToolSummary,
+	toolCallSummary,
+} from "./names.ts";
+import { showMoreHintText } from "./show-more-hint.ts";
+import { headTruncateToWidth, toolViewportWidth } from "./result.ts";
+
+export const CODEMODE_TOOL_NAME = "codemode";
+
+/** 折叠态最多列几条子调用（与 pi 原生一致，更早的折叠成一行）。 */
+const COLLAPSED_CALL_LIMIT = 8;
+/** 折叠态正文缩进，与 `   ↳ …` 对齐。 */
+const INDENT = "   ";
+
+/** 脚本结果头；只有整块正文恰好等于它时才算头。 */
+const SCRIPT_HEADER = /^Script (completed|failed)\nWall time [\d.]+ seconds\nOutput:\n$/;
+
+export type CodemodeNestedCall = {
+	name?: unknown;
+	/** 紧凑 JSON；过长时 pi 会截断，截断后 JSON.parse 会失败。 */
+	args?: unknown;
+	status?: unknown;
+	durationMs?: unknown;
+	error?: unknown;
+	cost?: unknown;
+};
+
+export function codemodeCalls(result: any): CodemodeNestedCall[] {
+	const calls = result?.details?.calls;
+	return Array.isArray(calls) ? calls : [];
+}
+
+/** 去掉脚本头之后的输出正文（已清理终端转义）。 */
+export function codemodeOutputText(result: any): string {
+	const content = Array.isArray(result?.content) ? result.content : [];
+	const blocks = content
+		.filter((item: any) => item?.type === "text")
+		.map((item: any) => String(item?.text ?? ""));
+	if (blocks.length > 0 && SCRIPT_HEADER.test(blocks[0]!)) blocks.shift();
+	return sanitizeToolResultText(blocks.join("\n"), 16_384).trim();
+}
+
+export function codemodeOutputLineCount(result: any): number {
+	const text = codemodeOutputText(result).replace(/\n+$/, "");
+	return text ? text.split("\n").length : 0;
+}
+
+/** 汇总行片段（按重要度先后排列，渲染时从尾部丢以适配宽度）。 */
+export function codemodeSummaryParts(
+	calls: readonly CodemodeNestedCall[],
+	outputLines: number,
+	running: boolean,
+): string[] {
+	const total = calls.length;
+	const failed = calls.filter((call) => call?.status === "error").length;
+	const runningCount = calls.filter((call) => !call?.status || call?.status === "running").length;
+	const parts: string[] = [];
+	if (running) {
+		if (runningCount)
+			parts.push(`${runningCount} ${runningCount === 1 ? "call" : "calls"} running`);
+		const done = total - runningCount;
+		if (done) parts.push(`${done} done`);
+		if (failed) parts.push(`${failed} failed`);
+		return parts.length ? parts : ["running…"];
+	}
+	if (total) parts.push(`${total} ${total === 1 ? "call" : "calls"}`);
+	if (failed) parts.push(`${failed} failed`);
+	if (outputLines) parts.push(`${outputLines} ${outputLines === 1 ? "line" : "lines"} output`);
+	return parts.length ? parts : ["Done"];
+}
+
+/** 宽度不够时从尾部丢片段（先丢输出行数，再丢条数），不断词。 */
+function fitSummaryParts(parts: readonly string[], width: number): string {
+	const kept = [...parts];
+	while (kept.length > 1 && visibleWidth(kept.join(" · ")) > width) kept.pop();
+	const text = kept.join(" · ");
+	return visibleWidth(text) <= width ? text : headTruncateToWidth(text, width);
+}
+
+function formatDuration(ms: number): string {
+	return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+/** 与 pi 原生一致：不到 1 分显示两位有效数字。 */
+function formatCost(cost: number): string {
+	return `$${cost >= 0.01 ? cost.toFixed(2) : cost.toPrecision(2)}`;
+}
+
+/** 单次子调用的耗时/费用（纯文本，着色由调用方决定）。 */
+function callMeta(call: CodemodeNestedCall): string[] {
+	const out: string[] = [];
+	const duration = call?.durationMs;
+	if (typeof duration === "number" && Number.isFinite(duration) && duration >= 0) {
+		out.push(formatDuration(duration));
+	}
+	const cost = call?.cost;
+	if (typeof cost === "number" && Number.isFinite(cost) && cost > 0) out.push(formatCost(cost));
+	return out;
+}
+
+/** 截断的紧凑 JSON 里能恢复出的对象；complete 标记是否原本就完整。 */
+type ParsedCallArgs = { args: Record<string, unknown>; complete: boolean };
+
+/** 截断串尾部补闭合符号的候选：先试收字符串，再收数组与对象。 */
+const REPAIR_CLOSERS = ['"}', '"}]}', '"}}', "}", "]}"];
+
+/**
+ * 子调用参数：先直接解析；pi 从尾部截断过（超 200 字符）的串再补救一次——
+ * 逐字回退补上缺少的闭合符号，取最长能解析出的对象。截断保留的是开头字段，
+ * path/command/pattern 这类先出现的取得到；被切掉的尾部值本就无从恢复。
+ */
+function parseCallArgs(raw: string): ParsedCallArgs | undefined {
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return { args: parsed, complete: true };
+		}
+		return undefined;
+	} catch {
+		// 截断串：走补救
+	}
+	const body = raw.endsWith("...") ? raw.slice(0, -3) : raw;
+	if (!body.startsWith("{")) return undefined;
+	for (let end = body.length; end > 0; end--) {
+		for (const closer of REPAIR_CLOSERS) {
+			try {
+				const parsed = JSON.parse(body.slice(0, end) + closer);
+				if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+				// 空对象等于没恢复出字段，再短也只会更空
+				if (Object.keys(parsed).length === 0) return undefined;
+				return { args: parsed, complete: false };
+			} catch {
+				// 试下一个闭合符号 / 下一个长度
+			}
+		}
+	}
+	return undefined;
+}
+
+/** 子调用参数：能解析就复用字段链摘要，认不出（截断后也不成形）就贴原文。 */
+function callSummary(call: CodemodeNestedCall): ToolCallSummary {
+	const name = String(call?.name ?? "tool");
+	const title = mcpToolTitle({ toolName: name }) ?? humanizeToolLabel(name);
+	const raw = typeof call?.args === "string" ? call.args : "";
+	if (!raw) return { main: title, detail: "" };
+	const parsed = parseCallArgs(raw);
+	if (parsed) {
+		const summary = toolCallSummary(name, parsed.args, { title, variant: "default" });
+		// 截断串只恢复出部分字段：字段链认出来了才用，认不出仍旧贴原文，
+		// 免得把不完整的 JSON 当成完整入参摊开。
+		if (parsed.complete || summary.payload === undefined) return summary;
+	}
+	return { main: title, detail: "", payload: raw };
+}
+
+function statusIcon(status: unknown, theme: any): string {
+	switch (status) {
+		case "ok":
+			return theme.fg("success", "✓");
+		case "error":
+			return theme.fg("error", "✗");
+		case "cancelled":
+			return theme.fg("muted", "⊘");
+		default:
+			// 运行中：帧在 render() 内取，动画定时器只负责 requestRender
+			return theme.fg("accent", toolLoadingIcon());
+	}
+}
+
+function callRow(call: CodemodeNestedCall, theme: any, rowWidth: number): string {
+	const fg = theme.fg.bind(theme);
+	const prefix = `${INDENT}${fg("dim", "├")} ${statusIcon(call?.status, theme)} `;
+	// detail（read 的 offset/limit 等）与工具组行一样接在标题后
+	const summary = callSummary(call);
+	const detail = fg("dim", summary.detail);
+	const suffix = callMeta(call)
+		.map((text) => ` ${fg("dim", text)}`)
+		.join("");
+	const mainWidth = Math.max(
+		0,
+		rowWidth - visibleWidth(prefix) - visibleWidth(detail) - visibleWidth(suffix),
+	);
+	const row = `${prefix}${renderToolSummary(summary, mainWidth, fg)}${detail}${suffix}`;
+	return truncateToWidth(row, rowWidth, "");
+}
+
+/**
+ * 折叠态（含运行中的 partial 更新）的行：子调用全用 ├，最后一行用 └ 收汇总，
+ * 与工具组的树一致。
+ */
+export function codemodeCollapsedLines(options: {
+	result: any;
+	theme: any;
+	running: boolean;
+	isError: boolean;
+	width: number;
+	/** 鼠标悬停整卡时展开提示用 text 色，与其它折叠卡一致。 */
+	hovered?: boolean;
+}): string[] {
+	const { result, theme, running, isError } = options;
+	const fg = theme.fg.bind(theme);
+	const calls = codemodeCalls(result);
+	const rowWidth = toolViewportWidth(options.width);
+	const shown = calls.slice(-COLLAPSED_CALL_LIMIT);
+	const lines: string[] = [];
+	if (shown.length < calls.length) {
+		const hidden = calls.length - shown.length;
+		lines.push(
+			truncateToWidth(
+				`${INDENT}${fg("dim", "├")} ${fg("dim", `… ${hidden} earlier ${hidden === 1 ? "call" : "calls"}`)}`,
+				rowWidth,
+				"",
+			),
+		);
+	}
+	for (const call of shown) lines.push(callRow(call, theme, rowWidth));
+
+	const summary = codemodeSummaryParts(calls, codemodeOutputLineCount(result), running);
+	// 没有子调用时不画衔接符，避免孤零零一个 └
+	const prefix = shown.length > 0 ? `${INDENT}${fg("dim", "└")} ` : INDENT;
+	const hint = running ? "" : ` ${fg(options.hovered ? "text" : "dim", `· ${showMoreHintText()}`)}`;
+	const bodyWidth = Math.max(1, rowWidth - visibleWidth(prefix) - visibleWidth(hint));
+	const body = fg(isError ? "error" : "muted", fitSummaryParts(summary, bodyWidth));
+	lines.push(truncateToWidth(`${prefix}${body}${hint}`, rowWidth, ""));
+	return lines;
+}
+
+/** 展开态正文：全部子调用（含错误文本）+ 去掉脚本头的输出 + 全量输出路径。 */
+export function codemodeExpandedBody(result: any): string {
+	const parts: string[] = [];
+	const calls = codemodeCalls(result);
+	if (calls.length > 0) {
+		parts.push(
+			calls
+				.map((call) => {
+					const name = String(call?.name ?? "tool");
+					const raw = typeof call?.args === "string" ? call.args : "";
+					const meta = callMeta(call);
+					const head = [name, raw, ...meta].filter(Boolean).join(" ");
+					const error =
+						typeof call?.error === "string" && call.error
+							? `\n    ${call.error.split("\n").join("\n    ")}`
+							: "";
+					return `${head}${error}`;
+				})
+				.join("\n"),
+		);
+	}
+	const output = codemodeOutputText(result);
+	if (output) parts.push(output);
+	const full = result?.details?.fullOutputPath;
+	if (typeof full === "string" && full.trim()) parts.push(`Full output: ${full.trim()}`);
+	return parts.join("\n\n");
+}
+
+/**
+ * 折叠态结果组件。只有汇总行是展开入口，与 diff 卡一致；行本身很便宜，
+ * 不自己缓存（settled 卡另有整行 paint 缓存，运行中本就按帧重算）。hover 状态在
+ * render() 内取，才能跟鼠标 motion 的 requestRender 同步。
+ */
+export function createCodemodeResultComponent(options: {
+	result: any;
+	theme: any;
+	running: boolean;
+	isError: boolean;
+	/** 折叠态 hover 查询，与 diff 卡同一套（mouse/hover）。 */
+	isHovered?: () => boolean;
+}): any {
+	const { result, theme, running, isError } = options;
+	return {
+		render(width: number): string[] {
+			return codemodeCollapsedLines({
+				result,
+				theme,
+				running,
+				isError,
+				width,
+				hovered: options.isHovered?.() ?? false,
+			});
+		},
+		invalidate(): void {},
+		isCollapsedHintLine(plainLine: string): boolean {
+			return !running && /(click to show more|to show more)\s*$/.test(stripAnsi(plainLine));
+		},
+	};
+}