pi-cc-extensions 0.9.6 → 0.9.7

package/extensions/feature/shell/working-message.ts

@@ -1,4 +1,10 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getCompactRunStatusText } from "../../renderer/compact-mode.ts";
+import {
+	fullscreenLazyTui,
+	getToolMouseTui,
+	isFullscreenAtBottom,
+} from "../../renderer/mouse/scroll.ts";
 import { formatDuration } from "../../utils/format.ts";
 
 const REFRESH_INTERVAL_MS = 1_000;
@@ -84,11 +90,24 @@ export default function (pi: ExtensionAPI): void {
 		if (output > 0) providerOutputTokens = output;
 	}
 
+	/**
+	 * 摘要行滚出视口才镜像：仅 fullscreen 且已离开 transcript 底部。
+	 * regular 没有“离开底部”信号（transcript 在终端回滚区），保持 Pi 默认文案。
+	 */
+	function compactMirrorText(): string | undefined {
+		const tui = getToolMouseTui();
+		if (!tui || !fullscreenLazyTui(tui) || isFullscreenAtBottom(tui)) return undefined;
+		return getCompactRunStatusText();
+	}
+
 	function buildWorkingMessage(): string {
-		const elapsed = Date.now() - (agentStartTime || turnStartTime);
-		const tokens = tokenCount();
 		const parts: string[] = [];
+		const tokens = tokenCount();
 		if (tokens > 0) parts.push(`↓ ${formatCount(tokens)} tokens`);
+		// compact 活动回合且已滚出摘要行：直接用摘要行文案（自带回合时长，不叠 agent 计时）。
+		const compactStatus = compactMirrorText();
+		if (compactStatus) return [compactStatus, ...parts].join(" · ");
+		const elapsed = Date.now() - (agentStartTime || turnStartTime);
 		if (elapsed >= SHOW_TIMER_AFTER_MS || tokens > 0) {
 			// formatDuration 低于 1 秒返回 ""，此处回退 "0s" 保持计时器连续跳动。
 			parts.push(formatDuration(elapsed) || "0s");

package/extensions/renderer/compact-mode.ts

@@ -8,6 +8,11 @@
  * Agent/Task 族：调用只进摘要计数，tool 卡始终折叠（避免 pending→完成高度闪动）。
  * 底部 Agents/Tasks 面板由 pi-subagents/pi-tasks 独立 widget 负责，不经 tool 卡外置。
  *
+ * live 围观态（回合进行中 / 收尾静默期）：正文与摘要行跟折叠态同形，只在摘要行下面多一张
+ * 单一槽位卡（`↳` + 最新的一个块：仍在增长的思考预览，或本回合最近的工具，运行中优先）。
+ * 思考原地增长不轮换，只有新的思考块或工具调用进来才换槽位内容。
+ * 收尾时摘要行原地从 Running... 翻成 Ran for、槽位卡消失，正文与摘要行都不换位置。
+ *
  * 工具计数：read 按非空路径去重、其余按调用计数（首次出现顺序）；edit/write 不进摘要。
  * 时长 = 回合流逝挂钟；进行中 Running...，结束 Ran for。
  * abort/error/length 状态行挂在摘要外层，避免被折叠吞掉。
@@ -40,7 +45,12 @@ import { getToolMouseTui } from "./mouse/scroll.ts";
 import { insetComponent, renderExpandedToolResult, scheduleAnimation } from "./tool/result.ts";
 import { paddedBackgroundRow } from "./tool/grouping.ts";
 import { formatDisplayPath } from "./tool/names.ts";
-import { hasVisibleText, stripBackgroundAnsi } from "../utils/ansi-text.ts";
+import {
+	hasVisibleText,
+	removeStyledRange,
+	stripBackgroundAnsi,
+	stripTerminalSequencesPreservingLayout,
+} from "../utils/ansi-text.ts";
 import { walkComponentTree } from "../utils/component-tree.ts";
 import {
 	ASSISTANT_REENTRY_KEY,
@@ -67,6 +77,12 @@ export type CompactThinkingQuery = {
 
 const EDIT_WRITE_TOOLS = new Set(["edit", "write"]);
 
+/**
+ * 回合收尾后延迟收拢的静默期（ms）。正文 token 往往先于 toolCall 到达，
+ * 立刻收拢会得到「先收再开」两次转场；静默期内被新回合接替则一并收拢。
+ */
+const FOLD_SETTLE_MS = 250;
+
 type CompactThinkingTheme = Pick<Theme, "fg" | "italic" | "bold">;
 
 /** 与 compact-thinking 主渲染器共用的静态文字样式。 */
@@ -332,23 +348,52 @@ function editWriteExpandedCard(theme: any): any {
  *  每个子卡前面补 1 行分隔（上一条已经是空行时不再补），子卡自带的首尾空行会被裁掉，
  *  避免与外卡/内卡 padding 叠出双空行。
  *  hits：子卡的行区间与命中目标（thinking 命中自身，工具命中 tool 组件），
- *  供展开后点击 hint。未开启 toolHits 时不映射工具，点击仍归外层面板。 */
+ *  供展开后点击 hint。未开启 toolHits 时不映射工具，点击仍归外层面板。
+ *  live=true：live 槽位用，不铺底色也不留上下空行，首行紧跟 `↳`、其余行缩进对齐
+ *  （Claude Code 的 ⎿ 口径）。行的产出仍是一行对一行，hits 行号无需平移。
+ */
 function layoutExpandedToolCard(
 	theme: any,
 	children: any[],
 	width: number,
 	paints?: string[][],
 	toolHits = false,
+	live = false,
 ): { lines: string[]; hits: Array<{ child: any; start: number; end: number }> } {
 	const slot = "userMessageBg";
 	const toolBgAnsi = darkenBgAnsi(theme, slot);
-	const innerWidth = Math.max(0, width - 2);
+	/** live 每行前面的标记宽度（首行 `↳ `，其余对齐空格）。 */
+	const markerWidth = live ? 2 : 0;
+	const innerWidth = Math.max(0, width - 2 - markerWidth);
 	const lines: string[] = [];
 	const hits: Array<{ child: any; start: number; end: number }> = [];
 	const isThinkingPreview = (child: any) => typeof child?.setHintHovered === "function";
 	let lastBlank = false;
+	/** live 首行被吃掉的前导缩进：续行同步左移同样格数，保持块内相对对齐。 */
+	let liveLead = 0;
+	const pushRow = (raw: string) => {
+		if (!live) {
+			lines.push(paddedBackgroundRow(theme, slot, raw, width));
+			return;
+		}
+		// 槽位里不重复展开入口（见 SLOT_HINT_PATTERNS）。
+		const line = stripSlotHint(raw);
+		// 工具卡行首带 SGR：ANSI 之后才是缩进空格。
+		const head = line.match(/^((?:\x1b\[[0-9;]*m)*)( *)/);
+		const ansi = head?.[1] ?? "";
+		const spaces = head?.[2]?.length ?? 0;
+		const first = lines.length === 0;
+		if (first) liveLead = spaces;
+		// 首行挂 muted 的 `↳`（与 default-mode 工具结果行同色）；续行按 liveLead 去缩进。
+		// 两侧都保留行首 SGR：丢掉它整行会掉回终端默认前景色。
+		const marker = first ? `${theme.fg("muted", "↳")} ` : "  ";
+		const lead = first ? spaces : Math.min(spaces, liveLead);
+		lines.push(
+			`${marker}${ansi}${truncateToWidth(line.slice(ansi.length + lead), innerWidth, "")}`,
+		);
+	};
 	const pushBlank = () => {
-		if (lastBlank) return;
+		if (live || lastBlank) return;
 		lines.push(paddedBackgroundRow(theme, slot, "", width));
 		lastBlank = true;
 	};
@@ -356,8 +401,8 @@ function layoutExpandedToolCard(
 		const child = children[childIndex];
 		const painted = paints?.[childIndex];
 		const childLines = Array.isArray(painted) ? painted : child.render(innerWidth);
-		// 展开的 thinking 带深色内卡（自带上下 padding，不再补外卡分隔行）。
-		const innerCard = isThinkingPreview(child) && child.expanded === true;
+		// live 不留空行、也不叠深色内卡：槽位没有边框。
+		const innerCard = !live && isThinkingPreview(child) && child.expanded === true;
 		let first = -1;
 		let last = -1;
 		for (let i = 0; i < childLines.length; i++) {
@@ -367,6 +412,7 @@ function layoutExpandedToolCard(
 			}
 		}
 		if (first < 0) {
+			if (live) continue;
 			for (const line of childLines) {
 				lines.push(paddedBackgroundRow(theme, slot, line, width));
 				lastBlank = !hasVisibleText(line);
@@ -378,7 +424,7 @@ function layoutExpandedToolCard(
 		// 展开的 thinking 走深色内卡（上下各 1 行 padding），工具卡直接铺在外卡上。
 		const paintRow = innerCard
 			? (line: string) => lines.push(toolCardBgRow(theme, slot, toolBgAnsi, line, width))
-			: (line: string) => lines.push(paddedBackgroundRow(theme, slot, line, width));
+			: pushRow;
 		if (innerCard) paintRow("");
 		for (let i = first; i <= last; i++) paintRow(childLines[i]);
 		if (innerCard) paintRow("");
@@ -399,6 +445,8 @@ function compactRoundCard(
 	toolRender: (tool: any, width: number) => string[],
 	/** true 时卡内工具行归 tool 组件，可点击二次展开（整回合展开卡）。 */
 	toolHits = false,
+	/** true 时走 live 槽位排布：不留空行、首行紧跟 `↳`。 */
+	live = false,
 ): any {
 	const children: any[] = [];
 	for (const item of cardItems) {
@@ -413,6 +461,8 @@ function compactRoundCard(
 			});
 		}
 	}
+	/** 子块可用宽度：live 还要让出首行 `↳ ` 的标记位。 */
+	const contentWidth = (width: number) => Math.max(0, width - 2 - (live ? 2 : 0));
 	let paint:
 		| {
 				width: number;
@@ -424,7 +474,7 @@ function compactRoundCard(
 		| undefined;
 	const layout = (width: number) => {
 		const theme = themeOf();
-		const innerWidth = Math.max(0, width - 2);
+		const innerWidth = contentWidth(width);
 		const paints = children.map((child) => {
 			const lines = child.render?.(innerWidth);
 			return Array.isArray(lines) ? lines : [];
@@ -438,7 +488,7 @@ function compactRoundCard(
 		) {
 			return paint;
 		}
-		const laid = layoutExpandedToolCard(theme, children, width, paints, toolHits);
+		const laid = layoutExpandedToolCard(theme, children, width, paints, toolHits, live);
 		paint = {
 			width,
 			theme,
@@ -532,6 +582,17 @@ const trackedAssistantComponents = new Set<any>();
 const trackedToolComponents = new Set<any>();
 let hoveredAssistantComponent: any;
 
+/**
+ * 活动回合摘要 getter：常驻状态行（pi working row）镜像用。
+ * installCompactMode 注册、卸载时清空，直接读 activeRound，不持有回合闭包。
+ */
+let compactRunStatusGetter: (() => string | undefined) | undefined;
+
+/** 活动回合的摘要文本（`Running... · 9s, bash×1`）；无活动回合返回 undefined。 */
+export function getCompactRunStatusText(): string | undefined {
+	return compactRunStatusGetter?.();
+}
+
 export function setHoveredCompactAssistant(component: any): boolean {
 	if (hoveredAssistantComponent === component) return false;
 	hoveredAssistantComponent = component;
@@ -841,7 +902,9 @@ function compactAssistantLineComponent(
 				return paint.lines;
 			}
 			const plainText = truncateToWidth(resolved, summaryWidth, "…");
-			let text = theme.fg("muted", plainText);
+			// Dim thinking text 开启时整行统一 dim，否则工具计数保持 muted。
+			const plain = (value: string) => theme.fg(config.dimThinkingText ? "dim" : "muted", value);
+			let text = plain(plainText);
 			if (runningActive || plainText.startsWith("Ran for ")) {
 				const separator = plainText.indexOf(", ");
 				const heading = separator < 0 ? plainText : plainText.slice(0, separator);
@@ -850,13 +913,9 @@ function compactAssistantLineComponent(
 					const durationSeparator = heading.indexOf(" · ");
 					const label = durationSeparator < 0 ? heading : heading.slice(0, durationSeparator);
 					const duration = durationSeparator < 0 ? "" : heading.slice(durationSeparator);
-					text = `${animateCompactThinkingText(
-						label,
-						theme,
-						query?.getThinkingAnimationFrame?.() ?? 0,
-					)}${styleCompactThinkingText(duration, theme)}${theme.fg("muted", tools)}`;
+					text = `${animateCompactThinkingText(label, theme, query?.getThinkingAnimationFrame?.() ?? 0)}${styleCompactThinkingText(duration, theme)}${plain(tools)}`;
 				} else {
-					text = `${styleCompactThinkingText(heading, theme)}${theme.fg("muted", tools)}`;
+					text = `${styleCompactThinkingText(heading, theme)}${plain(tools)}`;
 				}
 			}
 			const hintColor = hover ? "text" : "dim";
@@ -894,6 +953,51 @@ function compactStopStatusLine(status: string, pad = 0): any {
 	};
 }
 
+/**
+ * 槽位卡内的展开入口：卡里是只读围观，展开走摘要行自己的 hint，卡内不再重复提示。
+ * 提示有两处来源——我们的 showMoreHintText（`… +N more lines • click to show more`）与
+ * pi 原生工具卡（`… (N earlier lines, ctrl+o to expand)`），所以按渲染结果收尾裁剪。
+ * 只去掉动作词，`(N more lines)` 这类计数保留。
+ */
+/** 展开入口的动作词：我们的 `click to show more`、pi 的 `<key> to expand`（键名可能取不到）。 */
+const EXPAND_ACTION = String.raw`(?:click to show more|(?:[\w/+]+\s+)?to (?:show more|expand))`;
+
+const SLOT_HINT_PATTERNS: RegExp[] = [
+	// 卡在括号里：`(9 more lines, click to show more)` / `(195 earlier lines, ctrl+o to expand)`，
+	// 只去掉动作词，收尾括号与计数保留。
+	new RegExp(String.raw`,\s*[^()]*?${EXPAND_ACTION}(?=\))`),
+	// 直接挂在行尾：整段去掉。
+	new RegExp(String.raw`\s*(?:•\s*)?${EXPAND_ACTION}\s*$`),
+];
+
+function stripSlotHint(line: string): string {
+	const plain = stripTerminalSequencesPreservingLayout(line);
+	for (const re of SLOT_HINT_PATTERNS) {
+		const match = re.exec(plain);
+		if (!match) continue;
+		// 删除区间而非截断后拼纯文本：收尾括号留在原样式里（dim），不会掉回默认前景色。
+		return removeStyledRange(line, match.index, match.index + match[0].length);
+	}
+	return line;
+}
+
+/** live 槽位卡：按 pad 缩进；首行 `↳` 由卡自身的 live 排布加，行不增不减。 */
+function compactLiveSlot(card: any, pad = 0): any {
+	const innerOf = (width: number) => Math.max(0, width - Math.max(0, pad));
+	return {
+		render(width: number): string[] {
+			const indent = " ".repeat(Math.max(0, pad));
+			return card.render(innerOf(width)).map((line: string) => `${indent}${line}`);
+		},
+		childAtRow(localRow: number, width: number) {
+			return card.childAtRow?.(localRow, innerOf(width)) ?? null;
+		},
+		invalidate() {
+			card.invalidate();
+		},
+	};
+}
+
 function compactAssistantLine(
 	component: any,
 	summary: string | (() => string),
@@ -1005,6 +1109,11 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		detachedMessages: any[];
 		active: boolean;
 		suppressedToolIds: Set<string>;
+		/** live 槽位内联渲染的工具 id；回合结束时随槽位一起交还外层。 */
+		liveSlotToolIds: Set<string>;
+		/** 收尾后的静默期截止时间戳；期间仍按围观态渲染，到点才收拢。 */
+		settleUntil?: number;
+		foldTimer?: ReturnType<typeof setTimeout>;
 		/** 回合挂钟起点，保证 Running 时长连续递增。 */
 		startedAt: number;
 		endedAt?: number;
@@ -1014,6 +1123,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	const expandedRoundToolIds = new Set<string>();
 	/** 用户显式点开的 round 内工具；强制折叠不压回这些 id。 */
 	const explicitRoundToolIds = new Set<string>();
+	const liveSlotToolIds = new Set<string>();
+	const pendingFoldRounds = new Set<CompactRound>();
 	let uiRef: { requestRender?: (force?: boolean) => void } | undefined;
 	let roundTickTimer: ReturnType<typeof setInterval> | undefined;
 
@@ -1053,8 +1164,22 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		}, 250);
 	};
 
-	/** 结束回合活动态；可选立即重绘。 */
-	const endRound = (round: CompactRound, render = false): void => {
+	/** 围观中：活动回合，或收尾静默期还没走完的回合（槽位卡仍挂在屏幕上）。 */
+	const roundLive = (round: CompactRound): boolean =>
+		round.active || (round.settleUntil !== undefined && Date.now() < round.settleUntil);
+
+	const clearFoldTimer = (round: CompactRound): void => {
+		if (round.foldTimer !== undefined) {
+			clearTimeout(round.foldTimer);
+			round.foldTimer = undefined;
+		}
+		round.settleUntil = undefined;
+		pendingFoldRounds.delete(round);
+	};
+
+	/** 结束回合活动态；不做任何重绘。 */
+	const finalizeRound = (round: CompactRound): void => {
+		clearFoldTimer(round);
 		round.active = false;
 		if (round.endedAt === undefined) round.endedAt = Date.now();
 		if (activeRound === round) {
@@ -1062,7 +1187,36 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			deps.query?.setCompactSummaryActive?.(false);
 			stopRoundTick();
 		}
-		if (render) renderRound(round);
+	};
+
+	/**
+	 * 结束回合活动态；render=true 时走静默期，延迟 FOLD_SETTLE_MS 再收拢。
+	 * 分组语义不受影响：activeRound 立即让位，新消息不会被并进已收尾的回合。
+	 */
+	const endRound = (round: CompactRound, render = false): void => {
+		if (!render || !round.active) {
+			finalizeRound(round);
+			if (render) renderRound(round);
+			return;
+		}
+		finalizeRound(round);
+		if (round.foldTimer !== undefined) return;
+		round.settleUntil = Date.now() + FOLD_SETTLE_MS;
+		pendingFoldRounds.add(round);
+		round.foldTimer = setTimeout(() => {
+			round.foldTimer = undefined;
+			round.settleUntil = undefined;
+			pendingFoldRounds.delete(round);
+			renderRound(round);
+		}, FOLD_SETTLE_MS);
+	};
+
+	/** 新回合接替时立即收掉还在静默期的回合，把两次转场并成一次。 */
+	const flushSettle = (): void => {
+		for (const round of [...pendingFoldRounds]) {
+			clearFoldTimer(round);
+			renderRound(round);
+		}
 	};
 
 	const renderAssistantWithoutThinking = (
@@ -1083,6 +1237,22 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		return result;
 	};
 
+	/** compact 只允许单开：收回一张工具卡的展开态。 */
+	const collapseTool = (tool: any): void => {
+		if (typeof tool?.setExpanded === "function") tool.setExpanded(false);
+		else {
+			tool.expanded = false;
+			tool.updateDisplay?.();
+		}
+	};
+
+	/** 按条件收回已展开的工具卡。 */
+	const collapseTools = (shouldCollapse: (tool: any) => boolean): void => {
+		for (const tool of trackedToolComponents) {
+			if (tool.expanded === true && shouldCollapse(tool)) collapseTool(tool);
+		}
+	};
+
 	const markRoundToolUserExpanded = (tool: any): void => {
 		const id = String(tool?.toolCallId ?? "");
 		if (!id || !expandedRoundToolIds.has(id)) return;
@@ -1090,11 +1260,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			const otherId = String(other?.toolCallId ?? "");
 			if (other === tool || !expandedRoundToolIds.has(otherId) || other.expanded !== true) continue;
 			explicitRoundToolIds.delete(otherId);
-			if (typeof other.setExpanded === "function") other.setExpanded(false);
-			else {
-				other.expanded = false;
-				other.updateDisplay?.();
-			}
+			collapseTool(other);
 		}
 		explicitRoundToolIds.add(id);
 	};
@@ -1105,6 +1271,12 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		...round.detachedMessages,
 	];
 
+	/** 镜像给常驻状态行的文案：只认当前活动回合（摘要行被顶出视口时由 working-message 取用）。 */
+	compactRunStatusGetter = () => {
+		const round = activeRound;
+		return round?.active ? summarize(roundMessages(round), true, round) || undefined : undefined;
+	};
+
 	const roundToolCallIds = (round: CompactRound): Set<string> => {
 		const ids = new Set<string>();
 		for (const message of roundMessages(round)) {
@@ -1115,19 +1287,132 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		return ids;
 	};
 
+	/**
+	 * 末块仍是 thinking = 思考还在长；后面跟了正文或工具调用就算结束。
+	 * 围观态只预览这一种，已完成的思考直接回收进摘要行，不在屏幕上留 Thought 行。
+	 */
+	const hasTrailingThinking = (message: any): boolean => {
+		const content = Array.isArray(message?.content) ? message.content : [];
+		for (let i = content.length - 1; i >= 0; i--) {
+			const item = content[i];
+			if (item?.type === "thinking") return true;
+			if (item?.type === "toolCall") return false;
+			if (item?.type === "text" && String(item.text ?? "").trim()) return false;
+		}
+		return false;
+	};
+
+	/** 运行中的工具：已开始且尚无最终结果。 */
+	const isRunningTool = (tool: any): boolean =>
+		tool?.executionStarted === true && (!tool.result || tool.isPartial === true);
+
+	/**
+	 * live 围观态：正文 + 摘要行照折叠态渲染，只在摘要行下多一张槽位卡。
+	 * - 思考：只预览最后一条仍在思考的消息，它的块是当前最新内容；
+	 * - 工具：没有活动思考时才占槽位，运行中优先，否则取本回合最近的，完成也留着；
+	 * - 槽位只放一个块（思考或工具），新的思考块/工具调用进来才轮换；
+	 * - 本回合所有工具都由槽位卡接管，外层不再单独成行。
+	 * 可见性判断只在这里发生；回合结束（renderRound 非 active）只剩槽位卡消失。
+	 */
+	const renderRoundLive = (
+		round: CompactRound,
+		stopStatus: string | undefined,
+		getSummary: () => string,
+	): void => {
+		// 仍在思考的消息 = 当前最新内容，优先占槽位。
+		let previewComponent: any;
+		for (const [component, message] of round.messages) {
+			if (hasTrailingThinking(message)) previewComponent = component;
+		}
+
+		const thinkingKids: any[] = [];
+		for (const [component, message] of round.messages) {
+			if (component !== previewComponent) {
+				component.contentContainer?.clear?.();
+				continue;
+			}
+			passThroughAssistant(component, message);
+			const kids = Array.isArray(component.contentContainer?.children)
+				? [...component.contentContainer.children]
+				: [];
+			component.contentContainer?.clear?.();
+			// 只摘思考预览块进槽位；已收尾的思考回收进摘要行。
+			for (const kid of kids) {
+				if (typeof kid?.setHintHovered === "function") thinkingKids.push(kid);
+			}
+		}
+		// 正文照折叠态渲染（不含 thinking）：live 与收尾后同形，收尾只剩槽位卡消失。
+		renderAssistantWithoutThinking(round.anchor, round.messages.get(round.anchor));
+
+		const toolsById = new Map<string, any>();
+		for (const tool of trackedToolComponents) {
+			if (typeof tool?.toolCallId === "string") toolsById.set(tool.toolCallId, tool);
+		}
+		let runningTool: any;
+		let lastTool: any;
+		for (const [, message] of round.messages) {
+			for (const item of Array.isArray(message?.content) ? message.content : []) {
+				if (item?.type !== "toolCall" || typeof item.id !== "string") continue;
+				const tool = toolsById.get(item.id);
+				// edit/write 保留自己的 compact 行，不进槽位。
+				if (EDIT_WRITE_TOOLS.has(String(tool?.toolName ?? item.name ?? ""))) continue;
+				round.liveSlotToolIds.add(item.id);
+				liveSlotToolIds.add(item.id);
+				if (!tool) continue;
+				lastTool = tool;
+				if (isRunningTool(tool)) runningTool = tool;
+			}
+		}
+		// 槽位单块：活动思考最新；否则本回合最近的工具（运行中原位增长，完成也留着）。
+		const slotTool = thinkingKids.length > 0 ? undefined : (runningTool ?? lastTool);
+		const cardItems: Array<{ child?: any; tool?: any }> = slotTool
+			? [{ tool: slotTool }]
+			: thinkingKids.map((child) => ({ child }));
+
+		const anchor = round.anchor;
+		const pad = Number(anchor.outputPad) || 0;
+		// 摘要行位置与折叠态一致（正文之后），收尾只有时态变化和槽位卡消失。
+		compactAssistantLine(anchor, getSummary, deps.query);
+		if (cardItems.length > 0) {
+			anchor.contentContainer.addChild(
+				compactLiveSlot(
+					compactRoundCard(
+						cardItems,
+						(tool, innerWidth) => patch.toolOriginalRender.call(tool, innerWidth),
+						false,
+						true,
+					),
+					pad,
+				),
+			);
+		}
+		appendStopStatus(anchor, stopStatus);
+	};
+
 	const renderRound = (round: CompactRound): void => {
 		const messages = roundMessages(round);
 		const stopStatus = roundStopStatus(messages);
 		if (stopStatus) endRound(round);
 		// Running 时每次 render 重算时长（含挂钟下限）；结束后固定。
+		// 静默期内回合已收尾，摘要行直接给 Ran for，只有槽位卡多留一拍。
 		const getSummary = () => summarize(roundMessages(round), round.active, round);
 		const summary = getSummary();
 		for (const id of round.suppressedToolIds) expandedRoundToolIds.delete(id);
 		round.suppressedToolIds.clear();
-		// 回合收起（或本回合不在展开态）时忘掉用户的单开选择。
+		// 回合收起（或本回合不在展开态）时忘掉用户的单开选择，并把面板接管的工具一起收回：
+		// 少了后一步，被点开的工具会带着自身的 expanded 落到 toolInstalledRender 的放行分支，
+		// 面板一收就单独渲染成一张卡。
 		if (round.anchor.expanded !== true) {
-			for (const id of roundToolCallIds(round)) explicitRoundToolIds.delete(id);
+			const ids = roundToolCallIds(round);
+			for (const id of ids) explicitRoundToolIds.delete(id);
+			collapseTools(
+				(tool) =>
+					ids.has(String(tool.toolCallId ?? "")) &&
+					!EDIT_WRITE_TOOLS.has(String(tool.toolName ?? "")),
+			);
 		}
+		for (const id of round.liveSlotToolIds) liveSlotToolIds.delete(id);
+		round.liveSlotToolIds.clear();
 
 		for (const [component, message] of round.messages) {
 			component.lastMessage = message;
@@ -1248,21 +1533,12 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			}
 			// Round 展开只打开外层卡片。普通工具保持折叠，避免长输出递归撑满屏幕；
 			// 用户单独点开的（explicitRoundToolIds）不压回去。
-			for (const tool of trackedToolComponents) {
-				if (
-					!ids.has(tool.toolCallId) ||
-					EDIT_WRITE_TOOLS.has(String(tool.toolName ?? "")) ||
-					tool.expanded !== true ||
-					explicitRoundToolIds.has(String(tool.toolCallId ?? ""))
-				) {
-					continue;
-				}
-				if (typeof tool.setExpanded === "function") tool.setExpanded(false);
-				else {
-					tool.expanded = false;
-					tool.updateDisplay?.();
-				}
-			}
+			collapseTools(
+				(tool) =>
+					ids.has(String(tool.toolCallId ?? "")) &&
+					!EDIT_WRITE_TOOLS.has(String(tool.toolName ?? "")) &&
+					!explicitRoundToolIds.has(String(tool.toolCallId ?? "")),
+			);
 			flushPanel();
 			for (const child of anchorChildren) round.anchor.contentContainer.addChild(child);
 			// 展开卡内工具会显示 error，外层仍挂 abort/length，避免只藏在折叠工具里。
@@ -1270,6 +1546,12 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			return;
 		}
 
+		if (roundLive(round)) {
+			// 围观态：单一槽位卡（活动思考预览 + 当前工具），回合结束自动收回。
+			renderRoundLive(round, stopStatus, getSummary);
+			return;
+		}
+
 		for (const [component, message] of round.messages) {
 			if (component === round.anchor) {
 				renderAssistantWithoutThinking(component, message);
@@ -1284,6 +1566,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	};
 
 	const activateRound = (round: CompactRound): void => {
+		flushSettle();
 		round.active = true;
 		if (!round.startedAt) round.startedAt = Date.now();
 		delete round.endedAt;
@@ -1295,10 +1578,12 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	const finishRound = (round: CompactRound): void => endRound(round, true);
 
 	const resetRounds = (): void => {
+		for (const round of [...pendingFoldRounds]) clearFoldTimer(round);
 		activeRound = undefined;
 		roundByComponent = new WeakMap();
 		expandedRoundToolIds.clear();
 		explicitRoundToolIds.clear();
+		liveSlotToolIds.clear();
 		deps.query?.setCompactSummaryActive?.(false);
 		stopRoundTick();
 	};
@@ -1337,6 +1622,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					detachedMessages: [],
 					active: true,
 					suppressedToolIds: new Set(),
+					liveSlotToolIds: new Set(),
 					startedAt: Date.now(),
 				};
 				roundByComponent.set(this, round);
@@ -1348,6 +1634,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					detachedMessages: [],
 					active: true,
 					suppressedToolIds: new Set(),
+					liveSlotToolIds: new Set(),
 					startedAt: Date.now(),
 				};
 				roundByComponent.set(this, round);
@@ -1371,7 +1658,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 				return renderAssistantWithoutThinking(this, message);
 			}
 			if (round) {
-				endRound(round);
+				// 围观态下 anchor 还挂着槽位卡，必须重绘才能收回。
+				endRound(round, true);
 				roundByComponent.delete(this);
 				return passThroughAssistant(this, message);
 			}
@@ -1389,6 +1677,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					detachedMessages: [],
 					active: true,
 					suppressedToolIds: new Set(),
+					liveSlotToolIds: new Set(),
 					startedAt: Date.now(),
 				};
 				roundByComponent.set(this, round);
@@ -1424,6 +1713,9 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		}
 		// Agent/Task 等同普通工具：折叠不外置（live 面板走独立 widget）。
 		if (expandedRoundToolIds.has(String(this.toolCallId ?? ""))) return [];
+		// live 围观态：本回合工具交由槽位卡内联渲染，外层不再单独成行，
+		// 卡片因此不会随工具完成反复挂载/卸载。
+		if (liveSlotToolIds.has(String(this.toolCallId ?? ""))) return [];
 		// 普通工具折叠时不显示独立行（摘要行已统计），独立展开走原 renderer。
 		if (this.expanded === true) {
 			return patch.toolOriginalRender.call(this, width);
@@ -1482,6 +1774,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		trackedToolComponents.clear();
 		hoveredAssistantComponent = undefined;
 		resetRounds();
+		compactRunStatusGetter = undefined;
 	};
 
 	assistantPrototype.updateContent = patch.assistantInstalled;

package/extensions/renderer/index.ts

@@ -30,7 +30,7 @@ import {
 	teardownToolMouseInteraction,
 	TOOL_MOUSE_DISABLE,
 } from "./mouse/interaction.ts";
-import { getToolMouseTui } from "./mouse/scroll.ts";
+import { getToolMouseTui, noteNewTranscriptItem } from "./mouse/scroll.ts";
 import { setHoveredToolGroup, setHoveredToolIo } from "./mouse/hover.ts";
 import { clearAllAnimations } from "./tool/result.ts";
 import { installWriteOverride, WriteExecutionMetadataStore } from "./tool/diff/index.ts";
@@ -189,6 +189,13 @@ export default function (
 		}
 	});
 
+	// 回到底部按钮的累计计数：离开底部期间每落一块内容 +1。
+	pi.on("message_start", async (event) => {
+		const role = event.message?.role;
+		// toolResult 不单独成块（渲染在工具卡内），跳过以免与工具卡重复计数。
+		if (role === "user" || role === "assistant" || role === "custom") noteNewTranscriptItem();
+	});
+
 	pi.on("tool_execution_end", async (event) => {
 		if (config.mode !== "compact") return;
 		// Agent 等工具收尾后延迟刷新，让 compact-thinking 先落最终态。
@@ -243,6 +250,7 @@ export default function (
 
 	pi.on("tool_execution_start", async (_event, ctx) => {
 		installation?.toolGrouping.setTheme(ctx.ui.theme);
+		noteNewTranscriptItem();
 	});
 
 	pi.on("session_shutdown", async () => {

package/extensions/renderer/mouse/scroll.ts

@@ -27,12 +27,19 @@ export function setToolMouseTui(tui: any): void {
 	patchRegistry.install(TOOL_MOUSE_TUI_SLOT, tui);
 }
 
-type ScrollButtonState = { visible: boolean; hovered: boolean; widget: any };
+type ScrollButtonState = {
+	visible: boolean;
+	hovered: boolean;
+	widget: any;
+	/** 按钮可见期间新落的 transcript 块数（消息 + 工具卡）。 */
+	newCount: number;
+};
 function scrollButtonState(): ScrollButtonState {
 	return patchRegistry.ensure(SCROLL_BUTTON_STATE_SLOT, () => ({
 		visible: false,
 		hovered: false,
 		widget: null,
+		newCount: 0,
 	}));
 }
 export function getScrollButtonVisible(): boolean {
@@ -44,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?.();
 }
 
 /** 返回是否发生变化（调用方据此决定是否需要重渲染）。 */
@@ -64,6 +95,7 @@ export function resetScrollButtonState(): void {
 	scrollButtonState().visible = false;
 	scrollButtonState().hovered = false;
 	scrollButtonState().widget = null;
+	scrollButtonState().newCount = 0;
 	scrollButtonSyncScheduled = false;
 }
 
@@ -206,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/extensions/utils/ansi-text.ts

@@ -45,3 +45,32 @@ export function stripLeadingStatusIcon(line: string): string {
 		"$1",
 	);
 }
+
+/** 终端序列零宽（不计入 plain 下标），与 stripAnsi/stripTerminalSequencesPreservingLayout 一致。 */
+const ANY_SEQUENCE_RE = new RegExp(`${CSI_SEQUENCE_RE.source}|${OSC_SEQUENCE_RE.source}`, "g");
+
+/** 只保留 [start, end) 之外的字符（base 为 text 首字符在 plain 串中的下标）。 */
+function keepOutsideRange(text: string, base: number, start: number, end: number): string {
+	if (base + text.length <= start || base >= end) return text;
+	return text.slice(0, Math.max(0, start - base)) + text.slice(Math.max(0, end - base));
+}
+
+/**
+ * 删除 plain 区间 [start, end) 的字符，保留其余字符的 ANSI 样式。
+ * 区间内的终端序列原样保留，因此区间后的字符（如收尾括号）沿用前文颜色，
+ * 不会像截断后拼纯文本那样掉回终端默认前景色。
+ */
+export function removeStyledRange(styled: string, start: number, end: number): string {
+	if (end <= start) return styled;
+	let plain = 0;
+	let cursor = 0;
+	let out = "";
+	for (const match of styled.matchAll(ANY_SEQUENCE_RE)) {
+		const text = styled.slice(cursor, match.index);
+		out += keepOutsideRange(text, plain, start, end);
+		plain += text.length;
+		out += match[0];
+		cursor = match.index + match[0].length;
+	}
+	return out + keepOutsideRange(styled.slice(cursor), plain, start, end);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-extensions",
-	"version": "0.9.6",
+	"version": "0.9.7",
 	"license": "MIT",
 	"description": "Claude Code-style TUI output with some personal touches and handy utilities.",
 	"type": "module",