@herbertgao/pi-extensions 2026.8.1 → 2026.8.3

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/compact-mode.ts

@@ -1,43 +1,45 @@
 /**
  * Compact mode：每条含 toolCall 的 assistant message 折叠为一条逐步累加的摘要行
- * （`Thought for 8s, bash×2, read×2`），edit/write 独立单行（`✓ write <path> (+25 -0)`），
+ * （`Ran for 8s, bash×2, read×2`），edit/write 独立单行（`✓ write <path> (+25 -0)`），
  * 普通工具折叠时不显示独立行；展开（Ctrl+O / fullscreen 点击）在单个工具卡中恢复
  * compact-thinking/Pi 原生或专用 renderer。edit/write 折叠时显示统计，展开时显示 rich diff。
+ * Agent/Task 族：调用只进摘要计数，tool 卡始终折叠（避免 pending→完成高度闪动）。
+ * 底部 Agents/Tasks 面板由 pi-subagents/pi-tasks 独立 widget 负责，不经 tool 卡外置。
  *
- * 统计口径与 utils/agent-summary.ts 对齐：read 按非空路径去重、bash 按调用计数、
- * 其他工具按首次出现顺序计数；edit/write 不进入摘要。思考时长复用
- * compact-thinking 的 completedDurations/activeThinking 与持久化 entry（只读查询），
- * 不建立第二套计时器。最终 agent summary 仍由 feature/agent-summary.ts 独占。
+ * 工具计数：read 按非空路径去重、其余按调用计数（首次出现顺序）；edit/write 不进摘要。
+ * 时长 = 回合流逝挂钟；进行中 Running...，结束 Ran for。
+ * abort/error/length 状态行挂在摘要外层，避免被折叠吞掉。
+ * 最终 agent 回合摘要由 feature/agent-summary 独占（bash/read/edit/write/other）。
  *
  * 补丁生命周期遵循仓库既有模式：Symbol 所有权、dispose 仅恢复仍由本安装持有的
  * 方法、重入守卫防止 /reload 后残留闭包递归。
  */
-import { AssistantMessageComponent, ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
-import * as PiTui from "@earendil-works/pi-tui";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { config, getToolDisplayConfig } from "../config/config.ts";
 import {
-	animateCompactThinkingText,
-	formatThoughtDuration,
-	styleCompactThinkingText,
-} from "../feature/compact-thinking.ts";
+	AssistantMessageComponent,
+	ToolExecutionComponent,
+	type Theme,
+} from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth, Box } from "@earendil-works/pi-tui";
+import { config, getToolDisplayConfig } from "../config/config.ts";
 import { toolLoadingIcon } from "../utils/tool-loading-icon.ts";
 import { sanitizeToolResultText } from "../utils/tool-result-sanitize.ts";
+import { refreshTranscriptComponent } from "./transcript-refresh.ts";
 import { getMessageDisplayTheme } from "./message-display.ts";
 import { showMoreHintText } from "./show-more-hint.ts";
 import {
 	countEditDiffStats,
 	countWriteDiffStats,
 	isRichDiffComponent,
-} from "./tool-diff/diff-renderer.ts";
-import { renderRichToolResult } from "./tool-diff/index.ts";
-import type { WriteExecutionMetadataStore } from "./tool-diff/write-execution.ts";
+} from "./tool/diff/diff-renderer.ts";
+import { renderRichToolResult } from "./tool/diff/index.ts";
+import type { WriteExecutionMetadataStore } from "./tool/diff/write-execution.ts";
 import {
 	insetComponent,
 	oneLine,
 	renderExpandedToolResult,
 	scheduleAnimation,
-} from "./tool-result.ts";
+} from "./tool/result.ts";
+import { paddedBackgroundRow, stripBackgroundAnsi } from "./tool/grouping.ts";
 
 /** compact 渲染层对 compact-thinking 的只读查询面（不建第二套计时器）。 */
 export type CompactThinkingQuery = {
@@ -48,6 +50,7 @@ export type CompactThinkingQuery = {
 };
 
 const COMPACT_MODE_PATCH_KEY = Symbol.for("pi.ccstyle.compact-mode-patch");
+const COMPACT_THINKING_OWNER_KEY = Symbol.for("pi.ccstyle.compact-thinking-owner");
 const COMPACT_THINKING_PATCH_KEY = Symbol.for("pi.ccstyle.compact-thinking-update");
 const PROTOTYPE_ORIGINAL_KEY = Symbol.for("pi.ccstyle.prototype-original");
 const ASSISTANT_SET_EXPANDED_DESCRIPTION = "pi.ccstyle.compact-assistant-set-expanded";
@@ -57,29 +60,118 @@ const ASSISTANT_SET_EXPANDED_KEY = Symbol.for(ASSISTANT_SET_EXPANDED_DESCRIPTION
 const ASSISTANT_TOGGLE_ROUND_KEY = Symbol.for(ASSISTANT_TOGGLE_ROUND_DESCRIPTION);
 const ASSISTANT_REENTRY_KEY = Symbol.for(ASSISTANT_REENTRY_DESCRIPTION);
 
-const Box = (PiTui as any).Box;
 const EDIT_WRITE_TOOLS = new Set(["edit", "write"]);
 
+type CompactThinkingTheme = Pick<Theme, "fg" | "italic" | "bold">;
+
+/** 与 compact-thinking 主渲染器共用的静态文字样式。 */
+export function styleCompactThinkingText(
+	text: string,
+	theme: CompactThinkingTheme | undefined,
+	bold = false,
+): string {
+	if (!theme) return text;
+	const colored = typeof theme.fg === "function" ? theme.fg("thinkingText", text) : text;
+	const weighted = bold && typeof theme.bold === "function" ? theme.bold(colored) : colored;
+	return typeof theme.italic === "function" ? theme.italic(weighted) : weighted;
+}
+
+/** 与 compact-thinking 主渲染器共用的活动思考扫光动画。 */
+export function animateCompactThinkingText(
+	text: string,
+	theme: CompactThinkingTheme | undefined,
+	animationFrame: number,
+	boldBase = false,
+): string {
+	if (!theme) return text;
+	const characters = Array.from(text);
+	if (characters.length === 0) return "";
+	const highlightWidth = Math.max(1, Math.min(5, Math.ceil(characters.length * 0.28)));
+	const start = (animationFrame % (characters.length + highlightWidth)) - highlightWidth;
+	const end = start + highlightWidth;
+	const before = characters.slice(0, Math.max(0, start)).join("");
+	const highlighted = characters
+		.slice(Math.max(0, start), Math.min(characters.length, end))
+		.join("");
+	const after = characters.slice(Math.max(0, end)).join("");
+	const highlightedColored =
+		highlighted && typeof theme.fg === "function" ? theme.fg("text", highlighted) : highlighted;
+	const highlightedWeighted =
+		highlightedColored && typeof theme.bold === "function"
+			? theme.bold(highlightedColored)
+			: highlightedColored;
+	const highlightedText =
+		highlightedWeighted && typeof theme.italic === "function"
+			? theme.italic(highlightedWeighted)
+			: highlightedWeighted;
+
+	return (
+		styleCompactThinkingText(before, theme, boldBase) +
+		highlightedText +
+		styleCompactThinkingText(after, theme, boldBase)
+	);
+}
+
+function formatThoughtDuration(durationMs: number) {
+	if (durationMs < 1_000) {
+		return `${Math.max(1, Math.round(durationMs))}ms`;
+	}
+
+	const totalSeconds = Math.max(1, Math.round(durationMs / 1_000));
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (minutes === 0) return `${seconds}s`;
+	return seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
+}
+
+export { formatThoughtDuration };
+
+/** assistant stopReason → 外层状态文案（与 Pi 原生口径对齐）。 */
+export function messageStopStatus(message: any): string | undefined {
+	const reason = message?.stopReason;
+	if (reason === "aborted") {
+		return message.errorMessage && message.errorMessage !== "Request was aborted"
+			? String(message.errorMessage)
+			: "Operation aborted";
+	}
+	if (reason === "error") {
+		return `Error: ${message.errorMessage || "Unknown error"}`;
+	}
+	if (reason === "length") {
+		return "Response was truncated before completion.";
+	}
+	return undefined;
+}
+
+function roundStopStatus(messages: Iterable<any>): string | undefined {
+	for (const message of messages) {
+		const status = messageStopStatus(message);
+		if (status) return status;
+	}
+	return undefined;
+}
+
 /**
  * 逐条 assistant message 的摘要文本（无工具计数时可为空串）：
- * 思考时长在前，工具按消息内首次出现顺序排列；read 按非空路径去重。
+ * 时长 = max(thinking query, durationFloorMs 挂钟)；工具首次出现顺序；read 路径去重。
  */
 function buildMessagesSummary(
 	messages: Iterable<any>,
 	query?: CompactThinkingQuery,
-	thinkingActiveOverride?: boolean,
+	runningActiveOverride?: boolean,
+	durationFloorMs?: number,
 ): string {
 	const parts: string[] = [];
 	const counts = new Map<string, number>();
 	const readPaths = new Set<string>();
 	const durationTimestamps = new Set<number>();
 	let durationMs = 0;
-	let thinkingActive = false;
+	let runningActive = false;
 
 	for (const message of messages) {
 		if (typeof message?.timestamp === "number" && !durationTimestamps.has(message.timestamp)) {
 			durationTimestamps.add(message.timestamp);
-			if (query?.isMessageThinkingActive?.(message.timestamp)) thinkingActive = true;
+			if (query?.isMessageThinkingActive?.(message.timestamp)) runningActive = true;
 			const value = query?.getMessageThinkingDurationMs(message.timestamp);
 			if (typeof value === "number" && Number.isFinite(value) && value > 0) durationMs += value;
 		}
@@ -101,18 +193,28 @@ function buildMessagesSummary(
 		}
 	}
 
-	thinkingActive = thinkingActiveOverride ?? thinkingActive;
-	if (thinkingActive) {
-		parts.push(
-			durationMs > 0 ? `Thinking... · ${formatThoughtDuration(durationMs)}` : "Thinking...",
-		);
-	} else if (durationMs > 0) parts.push(`Thought for ${formatThoughtDuration(durationMs)}`);
+	if (
+		typeof durationFloorMs === "number" &&
+		Number.isFinite(durationFloorMs) &&
+		durationFloorMs > durationMs
+	) {
+		durationMs = durationFloorMs;
+	}
+
+	runningActive = runningActiveOverride ?? runningActive;
+	if (runningActive) {
+		parts.push(durationMs > 0 ? `Running... · ${formatThoughtDuration(durationMs)}` : "Running...");
+	} else if (durationMs > 0) parts.push(`Ran for ${formatThoughtDuration(durationMs)}`);
 	for (const [name, count] of counts) parts.push(`${name}×${count}`);
 	return parts.join(", ");
 }
 
-export function buildMessageSummary(message: any, query?: CompactThinkingQuery): string {
-	return buildMessagesSummary([message], query);
+export function buildMessageSummary(
+	message: any,
+	query?: CompactThinkingQuery,
+	durationFloorMs?: number,
+): string {
+	return buildMessagesSummary([message], query, undefined, durationFloorMs);
 }
 
 function fallbackTheme(): any {
@@ -127,7 +229,101 @@ function themeOf(): any {
 	return getMessageDisplayTheme() ?? fallbackTheme();
 }
 
-function expandedToolCard(theme: any): any {
+/** RGB → HSL（h∈[0,1), l/s∈[0,1]）。 */
+function rgbToHsl(r: number, g: number, b: number): [number, number, number] {
+	r /= 255;
+	g /= 255;
+	b /= 255;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const l = (max + min) / 2;
+	if (max === min) return [0, 0, l];
+	const d = max - min;
+	const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+	let h: number;
+	switch (max) {
+		case r:
+			h = (g - b) / d + (g < b ? 6 : 0);
+			break;
+		case g:
+			h = (b - r) / d + 2;
+			break;
+		default:
+			h = (r - g) / d + 4;
+	}
+	return [h / 6, l, s];
+}
+
+/** HSL → RGB（h∈[0,1)，l/s∈[0,1]）。 */
+function hslToRgb(h: number, l: number, s: number): [number, number, number] {
+	if (s === 0) {
+		const v = Math.round(l * 255);
+		return [v, v, v];
+	}
+	const hue2rgb = (p: number, q: number, t: number): number => {
+		if (t < 0) t += 1;
+		if (t > 1) t -= 1;
+		if (t < 1 / 6) return p + (q - p) * 6 * t;
+		if (t < 1 / 2) return q;
+		if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+		return p;
+	};
+	const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+	const p = 2 * l - q;
+	return [
+		Math.round(hue2rgb(p, q, h + 1 / 3) * 255),
+		Math.round(hue2rgb(p, q, h) * 255),
+		Math.round(hue2rgb(p, q, h - 1 / 3) * 255),
+	];
+}
+
+/** 内部 tool call card 背景：在 userMessageBg 基础上按 HSL 变暗（l×0.7），
+ *  与外卡片形成嵌套层次；非 RGB 色或已足够暗时原样返回。 */
+function darkenBgAnsi(theme: any, slot: string): string {
+	const prefix = typeof theme?.getBgAnsi === "function" ? String(theme.getBgAnsi(slot)) : "";
+	const m = prefix.match(/48;2;(\d+);(\d+);(\d+)/);
+	if (!m) return prefix;
+	const [h, l, s] = rgbToHsl(Number(m[1]), Number(m[2]), Number(m[3]));
+	if (l <= 0.05) return prefix; // 已足够暗，不再变暗
+	const [r, g, b] = hslToRgb(h, l * 0.7, s);
+	return `\x1b[48;2;${r};${g};${b}m`;
+}
+
+/** 去掉行内所有 CSI/OSC 序列后是否有可见文本（判断工具卡首尾内容行）。 */
+function hasVisibleText(line: string): boolean {
+	return (
+		line
+			.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+			.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+			.trim().length > 0
+	);
+}
+
+/** 工具卡深色行：左右内缩（左 2 右 3 格，含工具卡自身 padding），背景只到内容区，
+ *  修复行尾 reset 截断。 */
+function toolCardBgRow(
+	theme: any,
+	slot: string,
+	bgAnsi: string,
+	line: string,
+	width: number,
+): string {
+	const leftInset = 2;
+	const rightInset = 3;
+	const contentWidth = Math.max(0, width - leftInset - rightInset);
+	// 深色块内左右各 1 格内部 padding；去掉行首原有空格后重新对齐
+	const text = stripBackgroundAnsi(line).replace(/^ +/, "");
+	const innerPad = 2;
+	const clipped = truncateToWidth(text, Math.max(0, contentWidth - innerPad), "");
+	const pad = Math.max(0, contentWidth - innerPad - visibleWidth(clipped));
+	const body = ` ${clipped}${" ".repeat(pad)} `;
+	const stable = body.replace(/\x1b\[(?:0)?m/g, (reset) => reset + bgAnsi);
+	const outerBg = typeof theme?.getBgAnsi === "function" ? String(theme.getBgAnsi(slot)) : "";
+	const inset = (n) => (outerBg ? `${outerBg}${" ".repeat(n)}\x1b[49m` : " ".repeat(n));
+	return `${inset(leftInset)}${bgAnsi}${stable}\x1b[49m${inset(rightInset)}`;
+}
+/** edit/write 展开卡：保持原样式（userMessageBg Box），不应用工具卡深色/间距改动。 */
+function editWriteExpandedCard(theme: any): any {
 	return new Box(
 		1,
 		1,
@@ -135,6 +331,73 @@ function expandedToolCard(theme: any): any {
 	);
 }
 
+/** compact 展开卡：外卡片保持 userMessageBg 原色；内部 tool call card（addToolChild）
+ *  背景更深一层且只覆盖内容区（左右内缩、上下限首尾文本行），形成嵌套层次。
+ *  逐行重建背景同时修复嵌套 Box 的右侧截断。 */
+function expandedToolCard(theme: any): any {
+	const slot = "userMessageBg";
+	const toolBgAnsi = darkenBgAnsi(theme, slot);
+	const children: any[] = [];
+	return {
+		children,
+		addChild(child: any) {
+			children.push(child);
+		},
+		addToolChild(child: any) {
+			child.__ccToolCard = true;
+			children.push(child);
+		},
+		render(width: number): string[] {
+			const innerWidth = Math.max(0, width - 2);
+			const lines: string[] = [];
+			lines.push(paddedBackgroundRow(theme, slot, "", width));
+			// 展开不再显示摘要行：跳过第一个 child 的首行空白，避免白占一行
+			let skipLeadingBlank = true;
+			for (const child of children) {
+				const childLines = child.render(innerWidth);
+				if (!child.__ccToolCard) {
+					let start = 0;
+					if (skipLeadingBlank) {
+						while (start < childLines.length && !hasVisibleText(childLines[start])) start++;
+						skipLeadingBlank = false;
+					}
+					for (let i = start; i < childLines.length; i++) {
+						lines.push(paddedBackgroundRow(theme, slot, childLines[i], width));
+					}
+					continue;
+				}
+				// 工具卡：前导 1 空行 + 首尾文本行之间的内容区（深色）；不保留尾随，
+				// 相邻工具卡之间正好 1 空行，底部由卡片 padding 收尾。
+				skipLeadingBlank = false;
+				let first = -1;
+				let last = -1;
+				for (let i = 0; i < childLines.length; i++) {
+					if (hasVisibleText(childLines[i])) {
+						if (first < 0) first = i;
+						last = i;
+					}
+				}
+				if (first < 0) {
+					for (const line of childLines) {
+						lines.push(paddedBackgroundRow(theme, slot, line, width));
+					}
+					continue;
+				}
+				lines.push(paddedBackgroundRow(theme, slot, "", width));
+				// 子卡片内部上下各 1 行深色 padding
+				lines.push(toolCardBgRow(theme, slot, toolBgAnsi, "", width));
+				for (let i = first; i <= last; i++) {
+					lines.push(toolCardBgRow(theme, slot, toolBgAnsi, childLines[i], width));
+				}
+				lines.push(toolCardBgRow(theme, slot, toolBgAnsi, "", width));
+			}
+			lines.push(paddedBackgroundRow(theme, slot, "", width));
+			return lines;
+		},
+		invalidate() {},
+	};
+}
+
 function isAssistantComponent(value: any): boolean {
 	return value instanceof AssistantMessageComponent;
 }
@@ -185,7 +448,7 @@ export type CompactModeHooks = {
 	refresh(): void;
 	/** compact 模式下重新认领 assistant patch（位于 compact-thinking 之上）。 */
 	assertOwnership(): void;
-	/** 重新渲染包含指定 toolCallId 的 assistant 消息（思考收尾时刷新时长）。 */
+	/** 重新渲染包含指定 toolCallId 的 assistant 消息（思考收尾时刷新）。 */
 	refreshToolCallMessage(toolCallId: string | undefined): void;
 	shutdown(): void;
 };
@@ -319,7 +582,7 @@ function compactEditWriteExpandedLines(
 		component.resultRendererComponent = detail;
 	}
 
-	const box = expandedToolCard(theme);
+	const box = editWriteExpandedCard(theme);
 	box.addChild({
 		render(innerWidth: number): string[] {
 			return compactEditWriteLine(component, innerWidth, writeMetadata).slice(1);
@@ -332,7 +595,8 @@ function compactEditWriteExpandedLines(
 
 function compactAssistantLineComponent(
 	component: any,
-	summary: string,
+	/** 静态串或每次 render 重算（Running 时长需逐步跳动）。 */
+	summary: string | (() => string),
 	query?: CompactThinkingQuery,
 	options: { hint?: boolean; leadingBlank?: boolean; pad?: number } = {},
 ): any {
@@ -344,17 +608,15 @@ function compactAssistantLineComponent(
 			const available = Math.max(0, width - pad);
 			const hintText = options.hint === false ? "" : ` • ${showMoreHintText()}`;
 			const summaryWidth = Math.max(0, available - visibleWidth(hintText));
-			const thinkingActive = summary.startsWith("Thinking...");
-			const displaySummary = thinkingActive
-				? `${self.hiddenThinkingLabel || "Thinking..."}${summary.slice("Thinking...".length)}`
-				: summary;
-			const plainText = truncateToWidth(displaySummary, summaryWidth, "…");
+			const resolved = typeof summary === "function" ? summary() : summary;
+			const runningActive = resolved.startsWith("Running...");
+			const plainText = truncateToWidth(resolved, summaryWidth, "…");
 			let text = theme.fg("muted", plainText);
-			if (thinkingActive || plainText.startsWith("Thought for ")) {
+			if (runningActive || plainText.startsWith("Ran for ")) {
 				const separator = plainText.indexOf(", ");
 				const heading = separator < 0 ? plainText : plainText.slice(0, separator);
 				const tools = separator < 0 ? "" : plainText.slice(separator);
-				if (thinkingActive) {
+				if (runningActive) {
 					const durationSeparator = heading.indexOf(" · ");
 					const label = durationSeparator < 0 ? heading : heading.slice(0, durationSeparator);
 					const duration = durationSeparator < 0 ? "" : heading.slice(durationSeparator);
@@ -376,11 +638,35 @@ function compactAssistantLineComponent(
 	};
 }
 
-function compactAssistantLine(component: any, summary: string, query?: CompactThinkingQuery): void {
-	if (!summary) return;
+function compactStopStatusLine(status: string, pad = 0): any {
+	return {
+		render(width: number): string[] {
+			const theme = themeOf();
+			const prefix = " ".repeat(Math.max(0, pad));
+			const line = `${prefix}${theme.fg("error", status)}`;
+			return ["", truncateToWidth(line, width, "")];
+		},
+		invalidate() {},
+	};
+}
+
+function compactAssistantLine(
+	component: any,
+	summary: string | (() => string),
+	query?: CompactThinkingQuery,
+): void {
+	// 空静态串跳过；getter 留给 render 判断（Running 可能稍后才有时长）。
+	if (typeof summary === "string" && !summary) return;
 	component.contentContainer.addChild(compactAssistantLineComponent(component, summary, query));
 }
 
+function appendStopStatus(component: any, status: string | undefined): void {
+	if (!status || !component?.contentContainer?.addChild) return;
+	component.contentContainer.addChild(
+		compactStopStatusLine(status, Number(component.outputPad) || 0),
+	);
+}
+
 function ensureAssistantSetExpanded(component: any): void {
 	if (
 		typeof component[ASSISTANT_SET_EXPANDED_KEY] === "function" &&
@@ -444,16 +730,28 @@ function collectMountedComponents(root: any): void {
 		}
 	};
 	visit(root);
-	trackedAssistantComponents.clear();
-	trackedToolComponents.clear();
-	for (const component of assistants) trackedAssistantComponents.add(component);
-	for (const component of tools) trackedToolComponents.add(component);
+	// 扫到组件才替换跟踪表。面板/custom UI 打开时 root 往往扫不到 transcript，
+	// 若此时清空会丢掉 live updateContent/updateDisplay 已登记的实例，
+	// /ccstyle 切换就只能靠 /reload 重建。
+	if (assistants.size > 0 || tools.size > 0) {
+		trackedAssistantComponents.clear();
+		trackedToolComponents.clear();
+		for (const component of assistants) trackedAssistantComponents.add(component);
+		for (const component of tools) trackedToolComponents.add(component);
+	} else if (config.mode === "compact") {
+		for (const component of trackedAssistantComponents) ensureAssistantSetExpanded(component);
+	}
 }
 
 export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHooks {
 	const host = globalThis as any;
 	const previous = host[COMPACT_MODE_PATCH_KEY] as CompactModePatch | undefined;
-	if (previous) previous.dispose();
+	if (previous) {
+		// Replacement reload：先释放旧 compact 外层，再清理其 thinking owner，
+		// 否则下面会把旧 thinking wrapper 误采样为 native prototype。
+		previous.dispose();
+		host[COMPACT_THINKING_OWNER_KEY]?.stop?.();
+	}
 
 	const assistantPrototype = AssistantMessageComponent.prototype as any;
 	const toolPrototype = ToolExecutionComponent.prototype as any;
@@ -489,10 +787,63 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		detachedMessages: any[];
 		active: boolean;
 		suppressedToolIds: Set<string>;
+		/** 回合挂钟起点，保证 Running 时长连续递增。 */
+		startedAt: number;
+		endedAt?: number;
 	};
 	let activeRound: CompactRound | undefined;
 	let roundByComponent = new WeakMap<object, CompactRound>();
 	const expandedRoundToolIds = new Set<string>();
+	let uiRef: { requestRender?: (force?: boolean) => void } | undefined;
+	let roundTickTimer: ReturnType<typeof setInterval> | undefined;
+
+	const roundWallMs = (round: CompactRound): number => {
+		const end = round.active ? Date.now() : (round.endedAt ?? Date.now());
+		return Math.max(1, end - round.startedAt);
+	};
+
+	const summarize = (messages: Iterable<any>, runningActive?: boolean, round?: CompactRound) =>
+		buildMessagesSummary(
+			messages,
+			deps.query,
+			runningActive,
+			round ? roundWallMs(round) : undefined,
+		);
+
+	const stopRoundTick = (): void => {
+		if (!roundTickTimer) return;
+		clearInterval(roundTickTimer);
+		roundTickTimer = undefined;
+	};
+
+	// 自备 tick：getter 在 render 重算挂钟；兼驱动 Running 扫光（setCompactSummaryActive）。
+	const ensureRoundTick = (): void => {
+		if (roundTickTimer) return;
+		roundTickTimer = setInterval(() => {
+			if (!patch.active || !activeRound?.active) {
+				stopRoundTick();
+				return;
+			}
+			try {
+				uiRef?.requestRender?.(true);
+			} catch {
+				/* 无 UI */
+			}
+		}, 250);
+		roundTickTimer.unref?.();
+	};
+
+	/** 结束回合活动态；可选立即重绘。 */
+	const endRound = (round: CompactRound, render = false): void => {
+		round.active = false;
+		if (round.endedAt === undefined) round.endedAt = Date.now();
+		if (activeRound === round) {
+			activeRound = undefined;
+			deps.query?.setCompactSummaryActive?.(false);
+			stopRoundTick();
+		}
+		if (render) renderRound(round);
+	};
 
 	const renderAssistantWithoutThinking = (component: any, message: any): any => {
 		const content = Array.isArray(message?.content) ? message.content : [];
@@ -520,7 +871,12 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	};
 
 	const renderRound = (round: CompactRound): void => {
-		const summary = buildMessagesSummary(roundMessages(round), deps.query, round.active);
+		const messages = roundMessages(round);
+		const stopStatus = roundStopStatus(messages);
+		if (stopStatus) endRound(round);
+		// Running 时每次 render 重算时长（含挂钟下限）；结束后固定。
+		const getSummary = () => summarize(roundMessages(round), round.active, round);
+		const summary = getSummary();
 		for (const id of round.suppressedToolIds) expandedRoundToolIds.delete(id);
 		round.suppressedToolIds.clear();
 
@@ -570,20 +926,13 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 				render(width: number): string[] {
 					const theme = themeOf();
 					const box = expandedToolCard(theme);
-					box.addChild(
-						compactAssistantLineComponent(round.anchor, summary, deps.query, {
-							hint: false,
-							leadingBlank: false,
-							pad: 0,
-						}),
-					);
 					for (const child of assistantChildren) box.addChild(child);
 					const ids = roundToolCallIds(round);
 					for (const tool of trackedToolComponents) {
 						if (!ids.has(tool.toolCallId) || EDIT_WRITE_TOOLS.has(String(tool.toolName ?? ""))) {
 							continue;
 						}
-						box.addChild({
+						box.addToolChild({
 							render: (innerWidth: number) => patch.toolOriginalRender.call(tool, innerWidth),
 							invalidate: () => tool.invalidate?.(),
 						});
@@ -594,13 +943,18 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					for (const child of assistantChildren) child.invalidate?.();
 				},
 			});
+			// 展开卡内工具会显示 error，外层仍挂 abort/length，避免只藏在折叠工具里。
+			appendStopStatus(round.anchor, stopStatus);
 			return;
 		}
 
 		for (const [component, message] of round.messages) {
 			if (component === round.anchor) {
 				renderAssistantWithoutThinking(component, message);
-				compactAssistantLine(component, summary, deps.query);
+				// 空摘要不挂行（getter 在 Running 启动瞬间也可能短暂为空）
+				if (summary || round.active) compactAssistantLine(component, getSummary, deps.query);
+				// 折叠时工具行被隐藏：abort/error/length 必须挂在摘要外层。
+				appendStopStatus(component, stopStatus);
 			} else {
 				component.contentContainer?.clear?.();
 			}
@@ -609,24 +963,21 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 
 	const activateRound = (round: CompactRound): void => {
 		round.active = true;
+		if (!round.startedAt) round.startedAt = Date.now();
+		delete round.endedAt;
 		activeRound = round;
 		deps.query?.setCompactSummaryActive?.(true);
+		ensureRoundTick();
 	};
 
-	const finishRound = (round: CompactRound): void => {
-		round.active = false;
-		renderRound(round);
-		if (activeRound === round) {
-			activeRound = undefined;
-			deps.query?.setCompactSummaryActive?.(false);
-		}
-	};
+	const finishRound = (round: CompactRound): void => endRound(round, true);
 
 	const resetRounds = (): void => {
 		activeRound = undefined;
 		roundByComponent = new WeakMap();
 		expandedRoundToolIds.clear();
 		deps.query?.setCompactSummaryActive?.(false);
+		stopRoundTick();
 	};
 
 	patch.assistantInstalled = function (this: any, message: any) {
@@ -661,6 +1012,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					detachedMessages: [],
 					active: true,
 					suppressedToolIds: new Set(),
+					startedAt: Date.now(),
 				};
 				roundByComponent.set(this, round);
 				activateRound(round);
@@ -671,6 +1023,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					detachedMessages: [],
 					active: true,
 					suppressedToolIds: new Set(),
+					startedAt: Date.now(),
 				};
 				roundByComponent.set(this, round);
 				if (!activeRound) activateRound(round);
@@ -693,12 +1046,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 				return renderAssistantWithoutThinking(this, message);
 			}
 			if (round) {
-				round.active = false;
+				endRound(round);
 				roundByComponent.delete(this);
-				if (activeRound === round) {
-					activeRound = undefined;
-					deps.query?.setCompactSummaryActive?.(false);
-				}
 				return passThroughAssistant(this, message);
 			}
 			if (activeRound) finishRound(activeRound);
@@ -715,6 +1064,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					detachedMessages: [],
 					active: true,
 					suppressedToolIds: new Set(),
+					startedAt: Date.now(),
 				};
 				roundByComponent.set(this, round);
 				if (!activeRound) activateRound(round);
@@ -724,6 +1074,15 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			return undefined;
 		}
 
+		// 无可见内容的 abort/error/length：直接外层状态行，并结束进行中的回合。
+		const loneStatus = messageStopStatus(message);
+		if (loneStatus) {
+			if (activeRound) finishRound(activeRound);
+			self.contentContainer.clear();
+			appendStopStatus(this, loneStatus);
+			return undefined;
+		}
+
 		self.contentContainer.clear();
 		return undefined;
 	};
@@ -739,6 +1098,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			if (this.expanded !== true) return lines;
 			return compactEditWriteExpandedLines(this, width, deps.writeMetadata);
 		}
+		// Agent/Task 等同普通工具：折叠不外置（live 面板走独立 widget）。
 		if (expandedRoundToolIds.has(String(this.toolCallId ?? ""))) return [];
 		// 普通工具折叠时不显示独立行（摘要行已统计），独立展开走原 renderer。
 		if (this.expanded === true) {
@@ -762,12 +1122,18 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	};
 
 	patch.assertAssistantOwnership = () => {
-		// 仅从已标记的 compact-thinking 包装器重新认领。未知外部包装器必须保留所有权。
+		// compact 必须在外层：从 compact-thinking 包装器认领，或收回 mode=on/off
+		// 时主动释放给 original/native 的所有权。未知外部包装器不抢，避免递归。
 		if (!patch.active || assistantPrototype.updateContent === patch.assistantInstalled) return;
 		const current = assistantPrototype.updateContent;
-		if ((current as any)[COMPACT_THINKING_PATCH_KEY] !== true) return;
-		patch.assistantOriginal = current;
-		assistantPrototype.updateContent = patch.assistantInstalled;
+		if ((current as any)[COMPACT_THINKING_PATCH_KEY] === true) {
+			patch.assistantOriginal = current;
+			assistantPrototype.updateContent = patch.assistantInstalled;
+			return;
+		}
+		if (current === patch.assistantOriginal || current === patch.assistantNative) {
+			assistantPrototype.updateContent = patch.assistantInstalled;
+		}
 	};
 
 	(patch.assistantInstalled as any)[PROTOTYPE_ORIGINAL_KEY] = patch.assistantNative;
@@ -808,31 +1174,23 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		for (const component of trackedToolComponents) component.expanded = globalExpanded;
 	};
 
-	const releaseAssistantOwnership = (): void => {
-		if (assistantPrototype.updateContent === patch.assistantInstalled) {
-			assistantPrototype.updateContent = patch.assistantOriginal;
-		}
-	};
-
 	return {
 		sync(ctx: any) {
 			if (!patch.active) return;
+			uiRef = ctx?.ui;
 			resetRounds();
-			if (config.mode === "compact") {
-				patch.assertAssistantOwnership();
-				syncGlobalExpanded(ctx);
-			} else {
-				releaseAssistantOwnership();
-			}
+			// 始终保持补丁在链上：mode=on/off 走 passThrough，仍写入 lastMessage
+			// 与 tracked 集合，这样 /ccstyle 切回 compact 时不必 /reload。
+			patch.assertAssistantOwnership();
+			if (config.mode === "compact") syncGlobalExpanded(ctx);
+			else hoveredAssistantComponent = undefined;
 			refreshTrackedComponents();
 		},
 		refresh() {
 			if (!patch.active) return;
 			resetRounds();
-			if (config.mode !== "compact") {
-				releaseAssistantOwnership();
-				hoveredAssistantComponent = undefined;
-			}
+			patch.assertAssistantOwnership();
+			if (config.mode !== "compact") hoveredAssistantComponent = undefined;
 			refreshTrackedComponents();
 		},
 		assertOwnership() {
@@ -864,15 +1222,15 @@ function refreshTrackedComponents(): void {
 	for (const component of [...trackedAssistantComponents]) {
 		try {
 			if (config.mode !== "compact") detachAssistantExpansion(component);
-			if (component.lastMessage) component.updateContent?.(component.lastMessage);
-			else component.invalidate?.();
+			refreshTranscriptComponent(component);
 		} catch {
 			trackedAssistantComponents.delete(component);
 		}
 	}
 	for (const component of [...trackedToolComponents]) {
 		try {
-			component.updateDisplay?.();
+			// 共享实现负责 updateDisplay；invalidate 属于 compact-mode 的跟踪语义。
+			refreshTranscriptComponent(component);
 			component.invalidate?.();
 		} catch {
 			trackedToolComponents.delete(component);