pi-cc-extensions 0.9.5 → 0.9.6

package/README.en.md

@@ -29,7 +29,7 @@ Run `/reload` after installation.
 | --------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------- |
 | Claude Code UI              | Tool summaries, expand/collapse, rich edit/write diffs, and `on` / `compact` / `off` modes | `/ccstyle`                                      |
 | Markdown enhancements       | Mermaid diagrams, admonitions, URL linking, and more                                      | Automatic                                       |
-| Fullscreen mode             | Tool card/group expand and collapse, previews, hover highlight, and a back-to-bottom button | `TUIMODE=fullscreen` or `--tui-mode fullscreen` |
+| Fullscreen mode             | Tool card/group expand and collapse on click, previews, hover highlight, and a back-to-bottom button | `TUIMODE=fullscreen` or `--tui-mode fullscreen` |
 | Settings panel              | `Style / Features / UI / Diff / Thinking / Footer` tabs                                   | `/ccstyle`                                      |
 | Context inspection          | Usage breakdown and previews for the system prompt, memory, skills, tools definition, and messages | `/context`                                      |
 | Session/Subagent references | Search and inject effective context from previous Sessions or existing SubAgents          | `@`                                             |
@@ -89,7 +89,7 @@ Renderer snapshots for `on` / `compact` modes: [default](./docs/tool-render-exam
 ```
 
 > [!TIP]
-> **Fullscreen**: click `click to show more` to expand tool cards, thinking, Skill, and compact summaries. An expanded diff always shows every line; when expanded Input/Output exceeds the line cap, the footer `… +N more lines • click to show more` opens a full preview. Double-click an expanded panel to collapse it.
+> **Fullscreen**: click `click to show more` to expand tool cards, thinking, Skill, and compact summaries. An expanded diff always shows every line; when expanded Input/Output exceeds the line cap, the footer `… +N more lines • click to show more` opens a full preview. Click to collapse (dragging inside the card selects text).
 
 > [!NOTE]
 > **Mermaid rendering**: set `markdown.mermaid` to `final` via `~/.pi/agent/settings.json` or the Mermaid diagrams option in `/settings`. Default `streaming` redraws per frame; `final` renders once at completion.

package/README.md

@@ -29,7 +29,7 @@ pi install git:github.com/minuque/pi-cc-extensions
 | --------------------- | ------------------------------------------------------------------------------- | ----------------------------------------------- |
 | Claude Code UI        | 工具摘要、折叠展开、rich edit/write diff，以及`on` / `compact` / `off` 三种模式 | `/ccstyle`                                      |
 | Markdown 增强         | Mermaid 图、提示框、URL 链接化等                                                        | 自动生效                                        |
-| Fullscreen mode       | 工具卡/group 单击展开、双击收起、预览、hover 高亮、回到底部按钮                 | `TUIMODE=fullscreen` 或 `--tui-mode fullscreen` |
+| Fullscreen mode       | 工具卡/group 单击展开与收起、预览、hover 高亮、回到底部按钮                 | `TUIMODE=fullscreen` 或 `--tui-mode fullscreen` |
 | 配置面板              | `Style / Features / UI / Diff / Thinking / Footer` 六页签                       | `/ccstyle`                                      |
 | 上下文检查            | 查看上下文占用，并预览 System prompt、Memory、Skills、Tools definition 和消息内容 | `/context`                                      |
 | Session/Subagent 引用 | 搜索并注入历史 Session 或现有 SubAgent 的有效上下文                             | `@`                                             |
@@ -89,7 +89,7 @@ pi install git:github.com/minuque/pi-cc-extensions
 ```
 
 > [!TIP]
-> **全屏模式**：单击 `click to show more` 展开工具卡、思考、Skill 和 compact 摘要；工具卡展开态 diff 全量显示，Input/Output 超行时末行 `… +N more lines • click to show more` 打开全量预览，双击展开面板收起。
+> **全屏模式**：单击 `click to show more` 展开工具卡、思考、Skill 和 compact 摘要；工具卡展开态 diff 全量显示，Input/Output 超行时末行 `… +N more lines • click to show more` 打开全量预览，单击收起（卡内拖动为选中文本）。
 
 > [!NOTE]
 > **Mermaid 渲染**：建议把 `markdown.mermaid` 设为 `final`（`~/.pi/agent/settings.json` 或 `/settings` 面板的 Mermaid diagrams 选项）。默认 `streaming` 逐帧重绘，`final` 渲染最终版更稳定。

package/extensions/feature/compact-thinking.ts

@@ -323,7 +323,7 @@ function hiddenPreviewHint(
 
 const expandedThinking = new Set<number>();
 
-/** 折叠预览 + 展开全文。fullscreen 点击 hint 展开、双击整块收起，对齐工具卡。 */
+/** 折叠预览 + 展开全文。fullscreen 点击 hint 展开、展开卡单击整块收起（拖动选择文本时不收起）。 */
 export class ThinkingPreviewBlock implements Component {
 	private heading: string;
 	private text: string;

package/extensions/renderer/compact-mode.ts

@@ -1,8 +1,9 @@
 /**
  * Compact mode：每条含 toolCall 的 assistant message 折叠为一条逐步累加的摘要行
  * （`Ran for 8s, bash×2, read×2`），edit/write 独立标题行（`✓ write <path> (+25 -0)`），
- * 普通工具折叠时不显示独立行；展开（Ctrl+O / fullscreen 点击）在单个工具卡中恢复
- * compact-thinking/Pi 原生或专用 renderer。edit/write 复用 mode=on 的 rich diff
+ * 普通工具折叠时不显示独立行；展开（Ctrl+O / fullscreen 点击）时助手文本按原生渲染，
+ * thinking 与工具卡装进 userMessageBg 面板（卡内恢复 compact-thinking/Pi 原生或专用
+ * renderer）。edit/write 复用 mode=on 的 rich diff
  * 与 `editDiffCollapsedLines` / `writeDiffCollapsedLines` / `expandedPreviewMaxLines`。
  * Agent/Task 族：调用只进摘要计数，tool 卡始终折叠（避免 pending→完成高度闪动）。
  * 底部 Agents/Tasks 面板由 pi-subagents/pi-tasks 独立 widget 负责，不经 tool 卡外置。
@@ -35,6 +36,7 @@ import {
 import { renderRichToolResult } from "./tool/diff/index.ts";
 import type { WriteExecutionMetadataStore } from "./tool/diff/write-execution.ts";
 import { isToolCallHovered } from "./mouse/hover.ts";
+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";
@@ -50,6 +52,11 @@ import {
 	PROTOTYPE_ORIGINAL_KEY,
 } from "../utils/patch-keys.ts";
 
+/** Pi 的 native 组件与扩展可能各持一份 pi-tui，Spacer 不能只靠 instanceof 判。 */
+function isSpacerComponent(value: any): boolean {
+	return value instanceof Spacer || value?.constructor?.name === "Spacer";
+}
+
 /** compact 渲染层对 compact-thinking 的只读查询面（不建第二套计时器）。 */
 export type CompactThinkingQuery = {
 	getMessageThinkingDurationMs(messageTimestamp: number): number | undefined;
@@ -320,14 +327,18 @@ function editWriteExpandedCard(theme: any): any {
 	);
 }
 
-/** compact 展开卡：外卡片保持 userMessageBg 原色；内部 tool call card
- *  背景更深一层且只覆盖内容区（左右内缩、上下限首尾文本行），形成嵌套层次。
- *  hits：非工具子卡（thinking）的行区间，供展开后点击 hint。 */
+/** compact 展开面板：外卡片保持 userMessageBg；展开的 thinking 另包一层更深的
+ *  内卡（自身 Box 背景与外卡同色，不区分会糊在一起），工具卡直接铺在外卡背景上。
+ *  每个子卡前面补 1 行分隔（上一条已经是空行时不再补），子卡自带的首尾空行会被裁掉，
+ *  避免与外卡/内卡 padding 叠出双空行。
+ *  hits：子卡的行区间与命中目标（thinking 命中自身，工具命中 tool 组件），
+ *  供展开后点击 hint。未开启 toolHits 时不映射工具，点击仍归外层面板。 */
 function layoutExpandedToolCard(
 	theme: any,
 	children: any[],
 	width: number,
 	paints?: string[][],
+	toolHits = false,
 ): { lines: string[]; hits: Array<{ child: any; start: number; end: number }> } {
 	const slot = "userMessageBg";
 	const toolBgAnsi = darkenBgAnsi(theme, slot);
@@ -335,31 +346,18 @@ function layoutExpandedToolCard(
 	const lines: string[] = [];
 	const hits: Array<{ child: any; start: number; end: number }> = [];
 	const isThinkingPreview = (child: any) => typeof child?.setHintHovered === "function";
-	lines.push(paddedBackgroundRow(theme, slot, "", width));
-	// 展开不再显示摘要行：跳过第一个 child 的首行空白，避免白占一行
-	let skipLeadingBlank = true;
+	let lastBlank = false;
+	const pushBlank = () => {
+		if (lastBlank) return;
+		lines.push(paddedBackgroundRow(theme, slot, "", width));
+		lastBlank = true;
+	};
 	for (let childIndex = 0; childIndex < children.length; childIndex++) {
 		const child = children[childIndex];
 		const painted = paints?.[childIndex];
 		const childLines = Array.isArray(painted) ? painted : child.render(innerWidth);
-		// 展开的 thinking 与 tool 一样走嵌套深色卡，避免贴在外卡同色底上看不见。
-		const nest = child.__ccToolCard || (isThinkingPreview(child) && child.expanded === true);
-		if (!nest) {
-			let start = 0;
-			if (skipLeadingBlank) {
-				while (start < childLines.length && !hasVisibleText(childLines[start])) start++;
-				skipLeadingBlank = false;
-			}
-			const rangeStart = lines.length;
-			for (let i = start; i < childLines.length; i++) {
-				lines.push(paddedBackgroundRow(theme, slot, childLines[i], width));
-			}
-			if (lines.length > rangeStart) hits.push({ child, start: rangeStart, end: lines.length });
-			continue;
-		}
-		// 工具卡：前导 1 空行 + 首尾文本行之间的内容区（深色）；不保留尾随，
-		// 相邻工具卡之间正好 1 空行，底部由卡片 padding 收尾。
-		skipLeadingBlank = false;
+		// 展开的 thinking 带深色内卡（自带上下 padding，不再补外卡分隔行）。
+		const innerCard = isThinkingPreview(child) && child.expanded === true;
 		let first = -1;
 		let last = -1;
 		for (let i = 0; i < childLines.length; i++) {
@@ -371,26 +369,36 @@ function layoutExpandedToolCard(
 		if (first < 0) {
 			for (const line of childLines) {
 				lines.push(paddedBackgroundRow(theme, slot, line, width));
+				lastBlank = !hasVisibleText(line);
 			}
 			continue;
 		}
-		lines.push(paddedBackgroundRow(theme, slot, "", width));
+		if (!innerCard) pushBlank();
 		const rangeStart = lines.length;
-		// 子卡片内部上下各 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));
+		// 展开的 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));
+		if (innerCard) paintRow("");
+		for (let i = first; i <= last; i++) paintRow(childLines[i]);
+		if (innerCard) paintRow("");
+		// 内卡的下 padding 不能当分隔：后面的子卡要再留 1 行外卡空行。
+		lastBlank = false;
+		// thinking 命中自身；工具在展开卡内需要能二次展开时才映射回 tool 组件。
 		if (isThinkingPreview(child)) hits.push({ child, start: rangeStart, end: lines.length });
+		else if (toolHits && child.__ccTool) {
+			hits.push({ child: child.__ccTool, start: rangeStart, end: lines.length });
+		}
 	}
-	lines.push(paddedBackgroundRow(theme, slot, "", width));
+	pushBlank();
 	return { lines, hits };
 }
 
 function compactRoundCard(
 	cardItems: Array<{ child?: any; tool?: any }>,
 	toolRender: (tool: any, width: number) => string[],
+	/** true 时卡内工具行归 tool 组件，可点击二次展开（整回合展开卡）。 */
+	toolHits = false,
 ): any {
 	const children: any[] = [];
 	for (const item of cardItems) {
@@ -399,6 +407,7 @@ function compactRoundCard(
 			const tool = item.tool;
 			children.push({
 				__ccToolCard: true,
+				__ccTool: tool,
 				render: (innerWidth: number) => toolRender(tool, innerWidth),
 				invalidate: () => tool.invalidate?.(),
 			});
@@ -429,12 +438,12 @@ function compactRoundCard(
 		) {
 			return paint;
 		}
-		const laid = layoutExpandedToolCard(theme, children, width, paints);
+		const laid = layoutExpandedToolCard(theme, children, width, paints, toolHits);
 		paint = {
 			width,
 			theme,
 			paints,
-			lines: ["", ...laid.lines],
+			lines: laid.lines,
 			hits: laid.hits,
 		};
 		return paint;
@@ -445,10 +454,8 @@ function compactRoundCard(
 			return layout(width).lines;
 		},
 		childAtRow(localRow: number, width: number) {
-			if (localRow < 1) return null;
-			const row = localRow - 1;
 			for (const hit of layout(width).hits) {
-				if (row >= hit.start && row < hit.end) return hit.child;
+				if (localRow >= hit.start && localRow < hit.end) return hit.child;
 			}
 			return null;
 		},
@@ -531,6 +538,43 @@ export function setHoveredCompactAssistant(component: any): boolean {
 	return true;
 }
 
+/**
+ * 整回合展开卡内的工具被点击展开时调用：让 compact 的强制折叠放行这一个，
+ * 并把同一回合里其他展开的工具收回去（保持单开）。非 round 内工具是空操作。
+ */
+let roundToolExpansion: { markUserExpanded(tool: any): void } | undefined;
+
+export function markCompactRoundToolExpanded(tool: any): void {
+	roundToolExpansion?.markUserExpanded(tool);
+}
+
+/** 面板展开前的视口位置：收起时还原，避免面板撑高后收起导致视口错位。 */
+const panelViewportBeforeExpand = new WeakMap<
+	object,
+	{ scrollTop: number; followingEnd: boolean }
+>();
+
+function capturePanelViewport(card: any): void {
+	if (!card || panelViewportBeforeExpand.has(card)) return;
+	const view = getToolMouseTui()?.getPrimaryScrollView?.();
+	if (!view || typeof view.scrollTop !== "number" || typeof view.scrollTo !== "function") return;
+	panelViewportBeforeExpand.set(card, {
+		scrollTop: view.scrollTop,
+		followingEnd: view.isFollowingEnd !== false,
+	});
+}
+
+function restorePanelViewport(card: any): void {
+	const snapshot = panelViewportBeforeExpand.get(card);
+	if (!snapshot) return;
+	panelViewportBeforeExpand.delete(card);
+	const view = getToolMouseTui()?.getPrimaryScrollView?.();
+	if (!view) return;
+	// 展开前就在底部：交回官方 follow；否则回到展开前的滚动偏移。
+	if (snapshot.followingEnd && typeof view.scrollToEnd === "function") view.scrollToEnd();
+	else if (typeof view.scrollTo === "function") view.scrollTo(snapshot.scrollTop);
+}
+
 function compactEditWriteLine(
 	component: any,
 	width: number,
@@ -968,6 +1012,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	let activeRound: CompactRound | undefined;
 	let roundByComponent = new WeakMap<object, CompactRound>();
 	const expandedRoundToolIds = new Set<string>();
+	/** 用户显式点开的 round 内工具；强制折叠不压回这些 id。 */
+	const explicitRoundToolIds = new Set<string>();
 	let uiRef: { requestRender?: (force?: boolean) => void } | undefined;
 	let roundTickTimer: ReturnType<typeof setInterval> | undefined;
 
@@ -1037,6 +1083,23 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		return result;
 	};
 
+	const markRoundToolUserExpanded = (tool: any): void => {
+		const id = String(tool?.toolCallId ?? "");
+		if (!id || !expandedRoundToolIds.has(id)) return;
+		for (const other of trackedToolComponents) {
+			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?.();
+			}
+		}
+		explicitRoundToolIds.add(id);
+	};
+	roundToolExpansion = { markUserExpanded: markRoundToolUserExpanded };
+
 	const roundMessages = (round: CompactRound): any[] => [
 		...round.messages.values(),
 		...round.detachedMessages,
@@ -1061,17 +1124,24 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		const summary = getSummary();
 		for (const id of round.suppressedToolIds) expandedRoundToolIds.delete(id);
 		round.suppressedToolIds.clear();
+		// 回合收起（或本回合不在展开态）时忘掉用户的单开选择。
+		if (round.anchor.expanded !== true) {
+			for (const id of roundToolCallIds(round)) explicitRoundToolIds.delete(id);
+		}
 
 		for (const [component, message] of round.messages) {
 			component.lastMessage = message;
 			ensureAssistantSetExpanded(component);
 			component[ASSISTANT_TOGGLE_ROUND_KEY] = (expanded: boolean) => {
+				const wasExpanded = round.anchor.expanded === true;
+				if (expanded && !wasExpanded) capturePanelViewport(round.anchor);
 				for (const member of round.messages.keys()) member.expanded = expanded;
 				if (!expanded) {
 					for (const id of round.suppressedToolIds) expandedRoundToolIds.delete(id);
 					round.suppressedToolIds.clear();
 				}
 				renderRound(round);
+				if (!expanded && wasExpanded) restorePanelViewport(round.anchor);
 			};
 		}
 
@@ -1080,14 +1150,39 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			for (const tool of trackedToolComponents) {
 				if (typeof tool?.toolCallId === "string") toolsById.set(tool.toolCallId, tool);
 			}
-			const cardItems: Array<{ child?: any; tool?: any }> = [];
-			const placedToolIds = new Set<string>();
-			const takeAssistantRun = (kids: any[], cursor: { i: number }) => {
-				while (cursor.i < kids.length && kids[cursor.i] instanceof Spacer) {
-					cardItems.push({ child: kids[cursor.i++] });
+			// 助手文本按原生渲染、不进面板（面板只留 thinking 与工具卡）。
+			// thinking/工具卡按连续段各包一张面板；先出文本再出面板，
+			// 否则消息内容里的 thinking（[thinking, text, toolCall]）会盖到文本上面。
+			const anchorChildren: any[] = [];
+			let cardItems: Array<{ child?: any; tool?: any }> = [];
+			const flushPanel = () => {
+				if (cardItems.length === 0) return;
+				if (cardItems.every((item) => !item.tool && isSpacerComponent(item.child))) {
+					for (const item of cardItems) anchorChildren.push(item.child);
+				} else {
+					// 面板上沿留 1 行卡外空行：面板底色与 userMessage 同色，
+					// 贴在一起会看成一个块；卡内顶部再加 1 行 padding 保持上下对称。
+					anchorChildren.push(new Spacer(1));
+					anchorChildren.push(
+						compactRoundCard(
+							cardItems,
+							(tool, innerWidth) => patch.toolOriginalRender.call(tool, innerWidth),
+							// 整回合展开卡：卡内工具行归 tool 组件，可单击二次展开。
+							true,
+						),
+					);
 				}
-				if (cursor.i < kids.length) cardItems.push({ child: kids[cursor.i++] });
+				cardItems = [];
 			};
+			const takeChild = (child: any, outside: boolean) => {
+				if (!outside) {
+					cardItems.push({ child });
+					return;
+				}
+				flushPanel();
+				anchorChildren.push(child);
+			};
+			const placedToolIds = new Set<string>();
 			const placeTool = (id: string, fallbackName?: string) => {
 				const tool = toolsById.get(id);
 				if (!tool || EDIT_WRITE_TOOLS.has(String(tool.toolName ?? fallbackName ?? ""))) return;
@@ -1095,6 +1190,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 				placedToolIds.add(id);
 				cardItems.push({ tool });
 			};
+			type LocalEntry = { outside: boolean; child?: any; toolId?: string; toolName?: string };
 			for (const [component, message] of round.messages) {
 				passThroughAssistant(component, message);
 				const kids = Array.isArray(component.contentContainer?.children)
@@ -1103,25 +1199,39 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 				component.contentContainer?.clear?.();
 				const cursor = { i: 0 };
 				let inThinkingRun = false;
+				// 本消息产出先收集再发射：文本（含其前导 Spacer）统一排在面板前面。
+				const local: LocalEntry[] = [];
+				const takeRun = (outside: boolean) => {
+					while (cursor.i < kids.length && isSpacerComponent(kids[cursor.i])) {
+						local.push({ outside, child: kids[cursor.i++] });
+					}
+					if (cursor.i < kids.length) local.push({ outside, child: kids[cursor.i++] });
+				};
 				for (const item of Array.isArray(message?.content) ? message.content : []) {
 					if (item?.type === "thinking") {
 						if (!String(item.thinking ?? "").trim()) continue;
 						if (!inThinkingRun) {
-							takeAssistantRun(kids, cursor);
+							takeRun(false);
 							inThinkingRun = true;
 						}
 						continue;
 					}
 					inThinkingRun = false;
 					if (item?.type === "text" && String(item.text ?? "").trim()) {
-						takeAssistantRun(kids, cursor);
+						takeRun(true);
 						continue;
 					}
 					if (item?.type === "toolCall" && typeof item.id === "string") {
-						placeTool(item.id, item.name);
+						local.push({ outside: false, toolId: item.id, toolName: item.name });
 					}
 				}
-				while (cursor.i < kids.length) cardItems.push({ child: kids[cursor.i++] });
+				while (cursor.i < kids.length) local.push({ outside: false, child: kids[cursor.i++] });
+				for (const entry of local) if (entry.outside) takeChild(entry.child, true);
+				for (const entry of local) {
+					if (entry.outside) continue;
+					if (entry.toolId) placeTool(entry.toolId, entry.toolName);
+					else takeChild(entry.child, false);
+				}
 			}
 			for (const message of round.detachedMessages) {
 				for (const item of Array.isArray(message?.content) ? message.content : []) {
@@ -1136,12 +1246,14 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 				expandedRoundToolIds.add(id);
 				if (!placedToolIds.has(id)) placeTool(id);
 			}
-			// Round 展开只打开外层卡片。普通工具保持折叠，避免长输出递归撑满屏幕。
+			// Round 展开只打开外层卡片。普通工具保持折叠，避免长输出递归撑满屏幕；
+			// 用户单独点开的（explicitRoundToolIds）不压回去。
 			for (const tool of trackedToolComponents) {
 				if (
 					!ids.has(tool.toolCallId) ||
 					EDIT_WRITE_TOOLS.has(String(tool.toolName ?? "")) ||
-					tool.expanded !== true
+					tool.expanded !== true ||
+					explicitRoundToolIds.has(String(tool.toolCallId ?? ""))
 				) {
 					continue;
 				}
@@ -1151,11 +1263,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 					tool.updateDisplay?.();
 				}
 			}
-			round.anchor.contentContainer.addChild(
-				compactRoundCard(cardItems, (tool, innerWidth) =>
-					patch.toolOriginalRender.call(tool, innerWidth),
-				),
-			);
+			flushPanel();
+			for (const child of anchorChildren) round.anchor.contentContainer.addChild(child);
 			// 展开卡内工具会显示 error，外层仍挂 abort/length，避免只藏在折叠工具里。
 			appendStopStatus(round.anchor, stopStatus);
 			return;
@@ -1189,6 +1298,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		activeRound = undefined;
 		roundByComponent = new WeakMap();
 		expandedRoundToolIds.clear();
+		explicitRoundToolIds.clear();
 		deps.query?.setCompactSummaryActive?.(false);
 		stopRoundTick();
 	};
@@ -1322,12 +1432,11 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	};
 
 	patch.toolInstalledUpdateDisplay = function (this: any) {
-		if (
-			patch.active &&
-			config.mode === "compact" &&
-			expandedRoundToolIds.has(String(this.toolCallId ?? ""))
-		) {
-			this.expanded = false;
+		const id = String(this.toolCallId ?? "");
+		if (patch.active && config.mode === "compact" && expandedRoundToolIds.has(id)) {
+			// 用户点开的保留展开；其余（含全局展开被收回的）继续强制折叠。
+			if (this.expanded !== true) explicitRoundToolIds.delete(id);
+			else if (!explicitRoundToolIds.has(id)) this.expanded = false;
 		}
 		const result = patch.toolOriginalUpdateDisplay.call(this);
 		if (!patch.active) return result;
@@ -1355,6 +1464,9 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 	patch.dispose = () => {
 		if (!patch.active) return;
 		patch.active = false;
+		if (roundToolExpansion?.markUserExpanded === markRoundToolUserExpanded) {
+			roundToolExpansion = undefined;
+		}
 		if (assistantPrototype.updateContent === patch.assistantInstalled) {
 			assistantPrototype.updateContent = patch.assistantOriginal;
 		}

package/extensions/renderer/default-mode.ts

@@ -221,7 +221,7 @@ function createCcstyleTool(
 		...originalTool,
 		renderShell: "self",
 		renderCall(args: any, theme: any, context: any) {
-			if (config.mode !== "on") {
+			if (config.mode === "off") {
 				return renderDefault(originalTool, "renderCall", [args, theme, context], String(toolName));
 			}
 
@@ -293,7 +293,7 @@ function createCcstyleTool(
 			};
 		},
 		renderResult(result: any, options: any, theme: any, context: any) {
-			if (config.mode !== "on") {
+			if (config.mode === "off") {
 				return renderDefault(
 					originalTool,
 					"renderResult",
@@ -416,8 +416,9 @@ function shouldGloballyStyleTool(component: any, patch: GlobalToolRenderPatch):
 	const builtInDefinition = component.builtInToolDefinition;
 	const definition = extensionDefinition ?? builtInDefinition;
 	const toolName = String(component.toolName || definition?.name || "");
+	// compact 也复用同一套 ccstyle call/result，避免折叠态工具卡回落到 Pi 原生样式。
 	const useCcstyle =
-		patch.mode() === "on" &&
+		patch.mode() !== "off" &&
 		!DEDICATED_RENDERER_TOOLS.has(toolName) &&
 		!preservesOriginalRenderer(extensionDefinition, toolName, builtInDefinition);
 	component[COMPONENT_TOOL_RENDER_MODE] = useCcstyle;
@@ -585,19 +586,27 @@ function installGlobalToolRendering(
 			return originalRender.call(this, width);
 		}
 		const cache = patch.paintCache;
-		const hit = cache?.get(this);
+		// A running partial tool owns a time-varying spinner. Light animation ticks
+		// request a repaint without invalidating the component, so settled-content
+		// caching must not intercept those paints.
+		const cacheable = !(this.executionStarted && this.isPartial);
+		const hit = cacheable ? cache?.get(this) : undefined;
 		if (hit && toolPaintMatches(hit, this, width)) return hit.lines;
 		const lines = originalRender.call(this, width);
-		cache?.set(this, {
-			width,
-			expanded: Boolean(this.expanded),
-			isPartial: Boolean(this.isPartial),
-			result: this.result,
-			args: this.args,
-			callHover: isToolCallHovered(this.toolCallId),
-			ioHover: ioHoverOf(this),
-			lines,
-		});
+		if (cacheable) {
+			cache?.set(this, {
+				width,
+				expanded: Boolean(this.expanded),
+				isPartial: Boolean(this.isPartial),
+				result: this.result,
+				args: this.args,
+				callHover: isToolCallHovered(this.toolCallId),
+				ioHover: ioHoverOf(this),
+				lines,
+			});
+		} else {
+			cache?.delete(this);
+		}
 		return lines;
 	};
 	patch.invalidatePaint = function (this: any): void {

package/extensions/renderer/mouse/interaction.ts

@@ -1,13 +1,21 @@
 import { ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
 import { hasActiveTextPreview, showTextPreview } from "../../feature/context.ts";
 import { ThinkingPreviewBlock } from "../../feature/compact-thinking.ts";
-import { patchRegistry, TOOL_MOUSE_OWNER_KEY } from "../../utils/patch-keys.ts";
+import {
+	patchRegistry,
+	TOOL_GROUPING_PARENT_KEY,
+	TOOL_MOUSE_OWNER_KEY,
+} from "../../utils/patch-keys.ts";
 import { ToolGroupComponent } from "../tool/grouping.ts";
-import { isCompactAssistantComponent, setHoveredCompactAssistant } from "../compact-mode.ts";
+import {
+	isCompactAssistantComponent,
+	markCompactRoundToolExpanded,
+	setHoveredCompactAssistant,
+} from "../compact-mode.ts";
 import { isMessageDisplayComponent } from "../tool/message-display.ts";
 import { config } from "../../config/config.ts";
 import { isLazyProxyTui } from "../../utils/fullscreen-detect.ts";
-import { setToolTuiFullscreen } from "../tool/show-more-hint.ts";
+import { setToolTuiFullscreen, isCollapseHintLine } from "../tool/show-more-hint.ts";
 import {
 	type ExpandedToolIoView,
 	getActiveIoViewFrame,
@@ -76,7 +84,7 @@ type FrameToolRender = {
 };
 
 type InteractionRegion = {
-	kind: "collapsed-hint" | "expanded-card" | "show-more" | "scroll-bottom";
+	kind: "collapsed-hint" | "collapse-hint" | "expanded-card" | "show-more" | "scroll-bottom";
 	row: number;
 	startCol: number;
 	endCol: number;
@@ -119,6 +127,7 @@ function interactionRegionAt(packet: SgrMousePacket): InteractionRegion | null {
 		matches.find((region) => region.kind === "show-more") ??
 		matches.find((region) => region.kind === "scroll-bottom") ??
 		matches.find((region) => region.kind === "collapsed-hint") ??
+		matches.find((region) => region.kind === "collapse-hint") ??
 		matches.find((region) => region.kind === "expanded-card") ??
 		null
 	);
@@ -146,7 +155,12 @@ function updateToolSummaryHover(tui: any, packet: SgrMousePacket): void {
 	const scrollButtonChanged = setScrollButtonHovered(nextScrollButtonHovered);
 	const component = region?.component;
 	const nextToolCallId = region?.kind === "collapsed-hint" ? (component?.toolCallId ?? null) : null;
-	const nextGroup = component instanceof ToolGroupComponent ? component : null;
+	// group 只在提示文字上高亮（展开卡整行都是 expanded-card，不能算 hint）。
+	const nextGroup =
+		(region?.kind === "collapsed-hint" || region?.kind === "collapse-hint") &&
+		component instanceof ToolGroupComponent
+			? component
+			: null;
 	const nextIoView = region?.kind === "show-more" ? (region.view ?? null) : null;
 	const nextIoSection = region?.kind === "show-more" ? (region.section ?? null) : null;
 	const changed = nextToolCallId !== sharedToolHoverState().toolCallId;
@@ -160,75 +174,92 @@ function updateToolSummaryHover(tui: any, packet: SgrMousePacket): void {
 		tui.requestRender?.();
 }
 
-const EXPAND_PANEL_DOUBLE_CLICK_MS = 400;
-/** 松开后短时间内的重复按下视为同一次单击（终端会在 mouseup 后再打一次 press）。 */
-const EXPAND_PANEL_CLICK_ARM_MS = 50;
-let pendingExpandPress: { id: unknown } | null = null;
-let lastExpandClick: { id: unknown; at: number } | null = null;
-let armExpandClickTimer: ReturnType<typeof setTimeout> | null = null;
+/** 单击判定：按下与松开落在同一格（renderer 合成 click 的条件），位移与时限各留容差。 */
+const COLLAPSE_CLICK_MOVE_TOLERANCE = 1;
+const COLLAPSE_CLICK_MAX_MS = 600;
+/** 扩展收起自有卡后，官方 click 可能对同一次点击再 toggle 内部工具卡，短暂吞掉。 */
+const SUPPRESS_OFFICIAL_CARD_CLICK_MS = 300;
+/** 官方 fullscreen 的焦点事件串：发给原 handler 可清掉选区锚点（见 tui-alt-screen）。 */
+const FULLSCREEN_FOCUS_OUT = "\x1b[O";
 
-function expandPanelIdentity(card: any): unknown {
-	return card instanceof ThinkingPreviewBlock
-		? `${card.messageTimestamp}:${card.runStartIndex}`
-		: card;
-}
+let pendingCollapsePress: {
+	card: any;
+	/** 命中的最内层组件：官方工具卡由 MouseRegion 的 click 收起。 */
+	component: any;
+	col: number;
+	row: number;
+	at: number;
+} | null = null;
+let suppressOfficialCardClickUntil = 0;
 
-function isExpandPanelDoubleClick(card: any): boolean {
-	const now = Date.now();
-	const id = expandPanelIdentity(card);
-	const prev = lastExpandClick;
-	pendingExpandPress = { id };
-	if (prev && prev.id === id && now - prev.at <= EXPAND_PANEL_DOUBLE_CLICK_MS) {
-		pendingExpandPress = null;
-		lastExpandClick = null;
-		return true;
-	}
-	return false;
+function clearPendingCollapsePress(): void {
+	pendingCollapsePress = null;
 }
 
-function completeExpandPanelClick(): void {
-	if (!pendingExpandPress) return;
-	const click = { id: pendingExpandPress.id, at: Date.now() };
-	pendingExpandPress = null;
-	if (armExpandClickTimer) clearTimeout(armExpandClickTimer);
-	armExpandClickTimer = setTimeout(() => {
-		armExpandClickTimer = null;
-		// 50ms 内又按下：仍是同一次单击，不能武装成双击。
-		if (pendingExpandPress) return;
-		lastExpandClick = click;
-	}, EXPAND_PANEL_CLICK_ARM_MS);
-	if (
-		typeof armExpandClickTimer === "object" &&
-		armExpandClickTimer &&
-		"unref" in armExpandClickTimer
-	) {
-		armExpandClickTimer.unref();
+/** 带键拖动或滚轮：位置真的变了（超出抖动容差）就不再是单击。 */
+function clearPendingCollapsePressOnMove(packet: SgrMousePacket): void {
+	const press = pendingCollapsePress;
+	if (!press) return;
+	if ((packet.code & 64) !== 0) {
+		pendingCollapsePress = null;
+		return;
 	}
-}
-
-function clearExpandPanelDoubleClick(): void {
-	pendingExpandPress = null;
-	lastExpandClick = null;
-	if (armExpandClickTimer) {
-		clearTimeout(armExpandClickTimer);
-		armExpandClickTimer = null;
+	if (Math.abs(packet.col - press.col) <= COLLAPSE_CLICK_MOVE_TOLERANCE) {
+		if (Math.abs(packet.row - press.row) <= COLLAPSE_CLICK_MOVE_TOLERANCE) return;
 	}
+	pendingCollapsePress = null;
 }
 
-function collapseExpandedCard(tui: any, card: any): boolean {
-	// 单击也 consume，避免官方链再合成一次 press 把单击当成双击。
-	if (!isExpandPanelDoubleClick(card)) return true;
-	card.setExpanded(false);
+function clearHoverState(): void {
 	setHoveredToolCallId(null);
 	setHoveredToolGroup(null);
 	setHoveredThinking(null);
 	setHoveredMessageDisplay(null);
 	setHoveredToolIo(null, null);
 	setHoveredCompactAssistant(null);
+}
+
+/** 收起一张展开卡（group 的 setExpanded 会传播到内部工具）。 */
+function collapseExpandedCard(tui: any, card: any): void {
+	card.setExpanded(false);
+	clearHoverState();
 	card.invalidate?.();
-	tui.requestRender?.();
-	clearExpandPanelDoubleClick();
-	return true;
+	tui?.requestRender?.();
+}
+
+function rememberCollapsePress(card: any, component: any, packet: SgrMousePacket): void {
+	pendingCollapsePress = { card, component, col: packet.col, row: packet.row, at: Date.now() };
+}
+
+/**
+ * 松手结算：只有"按下与松开在同一格"的完整单击才收起，拖动选择文本时保持展开。
+ * 官方工具卡（result 区的 MouseRegion）由 guard 在官方 click 里收起，这里必须跳过，
+ * 否则先收起会被官方 click 的 setExpanded(!expanded) 翻回来。
+ */
+function resolveCollapsePress(
+	tui: any,
+	packet: SgrMousePacket,
+	options: { skipOfficialCards: boolean },
+): any {
+	const press = pendingCollapsePress;
+	pendingCollapsePress = null;
+	if (!press || packet.final !== "m") return undefined;
+	if (Math.abs(packet.col - press.col) > COLLAPSE_CLICK_MOVE_TOLERANCE) return undefined;
+	if (Math.abs(packet.row - press.row) > COLLAPSE_CLICK_MOVE_TOLERANCE) return undefined;
+	if (Date.now() - press.at > COLLAPSE_CLICK_MAX_MS) return undefined;
+	if (options.skipOfficialCards && press.component instanceof ToolExecutionComponent)
+		return undefined;
+	const card = press.card;
+	if (
+		(card instanceof ToolGroupComponent || isCompactAssistantComponent(card)) &&
+		press.component !== card
+	) {
+		// 点击落在卡内工具行：官方 click 会对同一次点击再次 toggle，吞掉它。
+		suppressOfficialCardClickUntil = Date.now() + SUPPRESS_OFFICIAL_CARD_CLICK_MS;
+	}
+	collapseExpandedCard(tui, card);
+	// 返回收起的卡：调用方只对 compact 面板清官方选区。
+	return card;
 }
 
 function toggleToolAtMouseClick(tui: any, packet: SgrMousePacket): boolean {
@@ -238,9 +269,13 @@ function toggleToolAtMouseClick(tui: any, packet: SgrMousePacket): boolean {
 	if (region.kind === "show-more") return tryOpenToolIoShowMore(region);
 	const component = region.component;
 	if (!component) return false;
-	if (region.kind === "expanded-card") return collapseExpandedCard(tui, component);
+	if (region.kind === "expanded-card" || region.kind === "collapse-hint") {
+		// regular 模式没有官方 click 合成，按下先记账，松手结算是否收起。
+		rememberCollapsePress(component, component, packet);
+		return true;
+	}
 	component.setExpanded(true);
-	clearExpandPanelDoubleClick();
+	clearPendingCollapsePress();
 	setHoveredToolCallId(null);
 	setHoveredToolGroup(null);
 	setHoveredToolIo(null, null);
@@ -339,9 +374,10 @@ function blocksOfficialCardToggle(component: any, event: any): boolean {
 
 /**
  * 官方 fullscreen 工具卡点击：collapsed hint 单击展开
- * （有且仅保持一个展开：展开前收起其他工具卡），expanded 整卡双击收起，
- * 截断头 show-more 单击打开全量预览；回到底部按钮 scrollToBottom。
- * 滚动条列、含 OSC8 链接行、非工具区域、展开卡单击放行官方。
+ * （有且仅保持一个展开：展开前收起其他工具卡），expanded 卡放行官方 press，
+ * 位置不变的松手才收起（官方卡经 guard，思考/group/compact 自有卡由扩展结算），
+ * 拖动选择文本时不收起；截断头 show-more 单击打开全量预览；回到底部按钮 scrollToBottom。
+ * 滚动条列、含 OSC8 链接行、非工具区域、折叠卡正文放行官方。
  */
 function handleFullscreenToolClick(tui: any, packet: SgrMousePacket): boolean {
 	const layout = tui.currentLayout;
@@ -359,7 +395,10 @@ function handleFullscreenToolClick(tui: any, packet: SgrMousePacket): boolean {
 	const target = componentAtLocalRow(hit.box.component, hit.localRow, contentWidth);
 	if (!target) return false;
 	const component = target.component;
-	const card = target.group ?? component;
+	// compact 展开面板内命中时 owner 是面板：收起对象与记账对象都归面板，
+	// 否则 skipOfficialCards 会把内部工具当成官方卡跳过。
+	const card = target.group ?? target.owner ?? component;
+	const pressComponent = target.owner ?? component;
 	// 回到底部按钮：按组件引用命中，不依赖渲染行缓存。
 	if (getScrollButtonVisible() && component === getScrollButtonWidget()) {
 		tui.scrollToBottom?.();
@@ -377,21 +416,32 @@ function handleFullscreenToolClick(tui: any, packet: SgrMousePacket): boolean {
 	if (!component.expanded) {
 		// collapsed 仅按钮文本可展开，不能把同一行正文/留白变成点击区。
 		const hint = collapsedHintHitbox(line);
-		if (!hint || packet.col < hint.startCol || packet.col > hint.endCol) return false;
-		if (!isCollapsedHintRow(component, line)) return false;
+		const onHint = Boolean(
+			hint &&
+				packet.col >= hint.startCol &&
+				packet.col <= hint.endCol &&
+				isCollapsedHintRow(component, line),
+		);
+		if (!onHint) {
+			// 面板内非提示区（工具卡标题/摘要行、thinking 预览正文）：单击收起整块面板。
+			if (target.owner) rememberCollapsePress(target.owner, target.owner, packet);
+			return false;
+		}
 		// single-expand：展开前收起其他已展开工具卡/group。
 		const others: any[] = [];
 		collectFullscreenToolCards(hit.box.component, others);
 		for (const other of others) {
 			if (other !== component && other.expanded) {
-				// 展开 round 内 thinking 时不要把外层 compact 卡收起。
-				if (isThinking && isCompactAssistantComponent(other)) continue;
+				// 展开 round 卡内 thinking/工具时，外层 compact 卡是它的容器，不能收起。
+				if ((isThinking || isTool) && isCompactAssistantComponent(other)) continue;
 				other.setExpanded(false);
 				other.invalidate?.();
 			}
 		}
+		// 展开 round 卡内工具时，让 compact 的强制折叠放行它（非 round 内工具为空操作）。
+		if (isTool) markCompactRoundToolExpanded(component);
 		component.setExpanded(true);
-		clearExpandPanelDoubleClick();
+		clearPendingCollapsePress();
 	} else {
 		// 普通工具截断头 show-more：打开全量预览（不收起）。
 		const view = isTool ? component.resultRendererComponent : null;
@@ -399,7 +449,7 @@ function handleFullscreenToolClick(tui: any, packet: SgrMousePacket): boolean {
 			const plain = stripTerminalSequencesPreservingLayout(line);
 			const section = view.matchShowMoreLine(plain);
 			if (section) {
-				clearExpandPanelDoubleClick();
+				clearPendingCollapsePress();
 				const box = view.showMoreHitbox(plain);
 				return tryOpenToolIoShowMore({
 					kind: "show-more",
@@ -412,17 +462,20 @@ function handleFullscreenToolClick(tui: any, packet: SgrMousePacket): boolean {
 				});
 			}
 		}
-		// 双击收起：内部工具仍归所属 group。单击放行官方（选择/链接）。
-		return collapseExpandedCard(tui, card);
+		// 其余放行官方：选区、OSC8 链接与 click 合成都交给 renderer。
+		// 完整单击的收起：官方卡由 guard 处理，自有卡在松手时结算。
+		rememberCollapsePress(card, pressComponent, packet);
+		return false;
 	}
-	// 点击后清 hover 高亮。
+	// 点击后清 hover 高亮。只 invalidate 点中的组件（或它所在的 group），
+	// 不要动 owner 面板：面板 invalidate 会连带重跑 updateContent，重建 thinking 实例。
 	setHoveredToolCallId(null);
 	setHoveredToolGroup(null);
 	setHoveredThinking(null);
 	setHoveredMessageDisplay(null);
 	setHoveredToolIo(null, null);
 	setHoveredCompactAssistant(null);
-	card.invalidate?.();
+	(target.group ?? component).invalidate?.();
 	tui.requestRender?.();
 	return true;
 }
@@ -526,7 +579,22 @@ function patchFullscreenViewportInput(tui: any): void {
 			if (packets && tui.hasOverlay?.() && hasActiveTextPreview()) return undefined;
 			if (packets && !tui.hasOverlay?.()) {
 				for (const packet of packets) {
-					if (isSgrLeftRelease(packet)) completeExpandPanelClick();
+					if (isSgrLeftRelease(packet)) {
+						// 只给 compact 面板清选区：自有面板收起会重排布局，官方选区锚点
+						// 还停在旧布局上，同一次 release 会结算出多行高亮。
+						if (
+							isCompactAssistantComponent(
+								resolveCollapsePress(tui, packet, { skipOfficialCards: true }),
+							)
+						) {
+							try {
+								Reflect.apply(original, this, [FULLSCREEN_FOCUS_OUT]);
+							} catch {
+								/* 老版本没有选区状态 */
+							}
+						}
+					} else if (!isSgrLeftPress(packet) && !isSgrIdleMotion(packet))
+						clearPendingCollapsePressOnMove(packet);
 					if (isSgrLeftPress(packet) && handleFullscreenToolClick(tui, packet)) {
 						return { consume: true };
 					}
@@ -639,6 +707,11 @@ function buildInteractionFrame(
 			if (placement.componentRow < cardStart) continue;
 			const finalRow = lineIndexToScreenRow(placement.lineIndex);
 			if (finalRow >= 1 && finalRow <= visibleRows) {
+				// 展开态的 ↑ Collapse 提示单独成区：hover 高亮 hint，点击仍收起整卡。
+				const hintBox = collapsedHintHitbox(placement.finalLine);
+				if (hintBox && isCollapseHintLine(stripTerminalSequences(placement.finalLine))) {
+					regions.push({ kind: "collapse-hint", row: finalRow, ...hintBox, component });
+				}
 				regions.push({
 					kind: "expanded-card",
 					row: finalRow,
@@ -868,8 +941,15 @@ function handleToolMouseInput(data: string): { consume: true } | undefined {
 	let consumed = false;
 	for (const packet of packets) {
 		updateToolSummaryHover(getToolMouseTui(), packet);
-		if (isSgrLeftRelease(packet)) completeExpandPanelClick();
-		if (!isSgrLeftPress(packet)) continue;
+		if (isSgrLeftRelease(packet)) {
+			resolveCollapsePress(getToolMouseTui(), packet, { skipOfficialCards: false });
+			continue;
+		}
+		if (!isSgrLeftPress(packet)) {
+			// 带键拖动或滚轮：位置变了就不再是单击。
+			if (!isSgrIdleMotion(packet)) clearPendingCollapsePressOnMove(packet);
+			continue;
+		}
 		if (toggleToolAtMouseClick(getToolMouseTui(), packet)) {
 			consumed = true;
 		}
@@ -899,7 +979,8 @@ export function teardownToolMouseInteraction(
 	setHoveredToolIo(null, null);
 	setHoveredCompactAssistant(null);
 	releaseToolCardMouseGuard();
-	clearExpandPanelDoubleClick();
+	clearPendingCollapsePress();
+	suppressOfficialCardClickUntil = 0;
 	try {
 		if (isLazyProxyTui(getToolMouseTui())) releaseFullscreenToolMouseMotion(getToolMouseTui());
 		else getToolMouseTui()?.terminal?.write?.(TOOL_MOUSE_DISABLE);
@@ -947,6 +1028,13 @@ type ToolCardMouseGuard = {
 	wrapper: (event: any) => any;
 };
 
+/** 官方 click 落在展开卡上：同一 group 的任意内部工具行都收起整个 group。 */
+function collapseExpandedCardFromOfficialClick(component: any): void {
+	if (typeof component?.setExpanded !== "function") return;
+	const group = component?.[TOOL_GROUPING_PARENT_KEY];
+	collapseExpandedCard(getToolMouseTui(), group instanceof ToolGroupComponent ? group : component);
+}
+
 function installToolCardMouseGuard(): void {
 	const prototype = (ToolExecutionComponent as any)?.prototype;
 	if (typeof prototype?.handleMouse !== "function") return;
@@ -956,6 +1044,19 @@ function installToolCardMouseGuard(): void {
 	// 每次取当前值作为下游，可能是别的扩展的包装。
 	const original = prototype.handleMouse;
 	const wrapper = function (this: any, event: any) {
+		if (event?.type === "click" && event.button === "left") {
+			// 扩展刚收起过自有卡：这次 click 属于同一次单击，吞掉避免内部工具被翻回展开。
+			if (suppressOfficialCardClickUntil && Date.now() <= suppressOfficialCardClickUntil) {
+				suppressOfficialCardClickUntil = 0;
+				if (this?.expanded) collapseExpandedCardFromOfficialClick(this);
+				return { handled: true };
+			}
+			// 展开卡整卡 click：接管官方 toggle，改为收起（group 内部工具行收起整个 group）。
+			if (this?.expanded && typeof this.setExpanded === "function") {
+				collapseExpandedCardFromOfficialClick(this);
+				return { handled: true };
+			}
+		}
 		if (blocksOfficialCardToggle(this, event)) return { handled: true };
 		return original.call(this, event);
 	};

package/extensions/renderer/mouse/layout.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/extensions/renderer/tool/grouping.ts

@@ -9,7 +9,7 @@ import {
 import { TOOL_LOADING_INTERVAL_MS, toolLoadingIcon } from "../../utils/tool-loading-icon.ts";
 import { getToolMouseTui } from "../mouse/scroll.ts";
 import { mcpToolTitle } from "./mcp-title.ts";
-import { isToolTuiFullscreen, showMoreHintText } from "./show-more-hint.ts";
+import { collapseHintText, isToolTuiFullscreen, showMoreHintText } from "./show-more-hint.ts";
 import { stripAnsi, stripBackgroundAnsi, stripLeadingStatusIcon } from "../../utils/ansi-text.ts";
 import { walkComponentTree } from "../../utils/component-tree.ts";
 import {
@@ -372,7 +372,8 @@ export class ToolGroupComponent extends Container {
 		const overallColor = overall === "pending" ? "accent" : overall;
 		const nameList = names.size > 1 ? ` ${fg("dim", `• ${toolNameList(this.children)}`)}` : "";
 		// 圆点保持 dim；hover 只高亮可点击文字。
-		const hint = `${fg("dim", "•")} ${fg(this.hintHovered ? "text" : "dim", showMoreHintText())}`;
+		const hintText = this._expanded ? collapseHintText() : showMoreHintText();
+		const hint = `${fg("dim", "•")} ${fg(this.hintHovered ? "text" : "dim", hintText)}`;
 		const lines = [
 			"",
 			truncateToWidth(

package/extensions/renderer/tool/show-more-hint.ts

@@ -36,3 +36,13 @@ export function expandShortcutText(): string {
 export function showMoreHintText(): string {
 	return isToolTuiFullscreen() ? "click to show more" : `${expandShortcutText()} to show more`;
 }
+
+/** 展开卡的收起提示，与折叠态 showMoreHintText 同一位置对称。 */
+export function collapseHintText(): string {
+	return isToolTuiFullscreen() ? "↑ Collapse" : `${expandShortcutText()} to collapse`;
+}
+
+/** 该行是否带展开态收起提示（用于展开卡的 hint hover 命中）。 */
+export function isCollapseHintLine(plainLine: string): boolean {
+	return plainLine.includes(collapseHintText());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-extensions",
-	"version": "0.9.5",
+	"version": "0.9.6",
 	"license": "MIT",
 	"description": "Claude Code-style TUI output with some personal touches and handy utilities.",
 	"type": "module",
@@ -38,6 +38,7 @@
 	},
 	"scripts": {
 		"test": "node --test tests/**/*.test.ts",
+		"coverage": "node --test --experimental-test-coverage --test-coverage-include=extensions/**/*.ts tests/**/*.test.ts",
 		"typecheck": "tsc --noEmit",
 		"format": "biome format --write .",
 		"format:check": "biome format .",