pi-claude-code-ui 1.0.83 → 1.0.85

package/extensions/index.ts

@@ -41,6 +41,24 @@ import {
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import * as PiTui from "@earendil-works/pi-tui";
+
+// Pi 0.85+ fullscreen mouse types. The 0.79 peer typings do not export them yet.
+interface TuiMouseEvent {
+	type: string;
+	button: string;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+interface TuiMouseEventResult {
+	handled?: boolean;
+	capture?: boolean;
+	focus?: boolean;
+	render?: boolean;
+}
+type MouseLayoutEntry = { component?: any; height: number; top: number };
 
 import * as Diff from "diff";
 import type { BundledLanguage, BundledTheme } from "shiki";
@@ -52,6 +70,7 @@ import {
 	formatBashDuration,
 	getLastBashOutputLine,
 } from "./bash-command";
+import { getUserSettingsPath } from "./settings-path";
 
 const RESET = "\x1b[0m";
 const TRANSPARENT_BG = "\x1b[49m";
@@ -71,6 +90,8 @@ const TOOL_RENDER_CACHE = Symbol.for("pi-claude-style-tools:tool-render-cache");
 const COMPONENT_PARENT = Symbol.for("pi-claude-style-tools:component-parent");
 const PARENT_TRACKING_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-parent-tracking");
 const TOOL_CACHE_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-tool-cache-invalidation");
+const TOOL_MOUSE_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-tool-fullscreen-mouse");
+const FULLSCREEN_HOVER_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-fullscreen-hover");
 const TOOL_IMAGE_EXPAND_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-read-image-expansion");
 const CUSTOM_MESSAGE_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-custom-message-render");
 const USER_MESSAGE_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-user-message-render");
@@ -147,7 +168,7 @@ function readSettings(): SettingsFile {
 		return _settingsCache.value;
 	}
 	const cwdPath = `${process.cwd()}/.pi/settings.json`;
-	const homePath = `${process.env.HOME ?? ""}/.pi/settings.json`;
+	const homePath = getUserSettingsPath();
 	const merged: SettingsFile = {};
 	for (const path of [cwdPath, homePath]) {
 		try {
@@ -175,9 +196,9 @@ function bustSpinnerSettingsCache(): void {
 function writeSettingsKey(key: string, value: unknown): void {
 	_settingsCache = null; // invalidate cache on write
 	const home = process.env.HOME ?? "";
-	if (!home) return;
-	const dir = `${home}/.pi`;
-	const path = `${dir}/settings.json`;
+	if (!home && !process.env.PI_CODING_AGENT_DIR) return;
+	const path = getUserSettingsPath();
+	const dir = dirname(path);
 	let settings: Record<string, unknown> = {};
 	try {
 		if (existsSync(path)) settings = JSON.parse(readFileSync(path, "utf8")) ?? {};
@@ -506,8 +527,8 @@ function getThinkingMode(): ThinkingMode {
 
 function isAssistantThinkingComplete(comp: any, message: any): boolean {
 	if (!message || message.role !== "assistant") return false;
-	if (typeof message[THINKING_DURATION_KEY] === "number") return true;
-	if (message[THINKING_ACTIVE_KEY]) return false;
+	if (getThinkingDurationMetadata(message) !== undefined) return true;
+	if (hasThinkingActiveMetadata(message)) return false;
 	// Providers keep stopReason "pending" for the whole stream ("deferred" while
 	// a deferred call is unresolved); both are in-flight sentinels, never
 	// completion signals. Without this, live-thinking detection would depend on
@@ -534,7 +555,7 @@ function isAssistantThinkingComplete(comp: any, message: any): boolean {
 function isLiveThinkingMessage(comp: any, message: any): boolean {
 	if (!message || message.role !== "assistant") return false;
 	if (isAssistantThinkingComplete(comp, message)) return false;
-	if ((message as any)[THINKING_ACTIVE_KEY]) return true;
+	if (hasThinkingActiveMetadata(message)) return true;
 	if (Array.isArray(message.content)) {
 		return message.content.some((b: any) => b?.type === "thinking" && typeof b?.thinking === "string" && b.thinking.trim());
 	}
@@ -880,7 +901,8 @@ function isGroupableTool(value: unknown): value is InstanceType<typeof ToolExecu
 
 class ToolGroupComponent extends Container {
 	private tools: any[] = [];
-	private expanded = false;
+	expanded = false;
+	private mouseLayout?: { width: number; children: MouseLayoutEntry[] };
 	// Memoize full group output. Grouped history is the long-chat bottleneck:
 	// each warm frame used to re-render every child tool, re-branch lines, and
 	// re-clamp every row even when nothing changed.
@@ -933,6 +955,8 @@ class ToolGroupComponent extends Container {
 	addTool(tool: any): void {
 		ACTIVE_TOOL_GROUPS.add(this);
 		this.tools.push(tool);
+		setToolHover(tool, false);
+		if (hoveredClickTarget?.owner === tool) hoveredClickTarget = undefined;
 		tool[COMPONENT_PARENT] = this;
 		// Don't cascade invalidate into every child — only drop our own cache.
 		// Child tools already rebuild via their own updateDisplay path.
@@ -948,7 +972,7 @@ class ToolGroupComponent extends Container {
 	}
 
 	setExpanded(expanded: boolean): void {
-		if (this.expanded === expanded) return;
+		if (this.expanded === expanded && this.tools.every((tool) => tool.expanded === expanded)) return;
 		this.expanded = expanded;
 		for (const tool of this.tools) tool.setExpanded?.(expanded);
 		this.clearRenderCache();
@@ -962,8 +986,27 @@ class ToolGroupComponent extends Container {
 		this.clearRenderCache();
 	}
 
+	handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+		const target = mouseLayoutTarget(this.mouseLayout, event);
+		if (event.type === "move") {
+			const row = target?.top ?? -1;
+			claimClickHover(this, () => { if (setGroupHover(this, -1)) requestComponentRender(this); });
+			return setGroupHover(this, row) ? { handled: true, render: true } : undefined;
+		}
+		if (isPrimaryClick(event) && target) {
+			const targets = target.component
+				? Array.isArray(target.component) ? target.component : [target.component]
+				: this.tools;
+			return toggleGroupedTools(this, targets);
+		}
+		return undefined;
+	}
+
 	render(width: number): string[] {
-		if (this.tools.length === 0) return [];
+		if (this.tools.length === 0) {
+			rememberMouseLayout(this, width, []);
+			return [];
+		}
 		const safeWidth = Number.isFinite(width) ? Math.max(1, Math.floor(width)) : 1;
 		// Fast path: settled groups with a valid memo skip ALL child walks.
 		// Child mutations mark dirty via clearToolRenderCache → invalidate().
@@ -975,7 +1018,7 @@ class ToolGroupComponent extends Container {
 			&& this.cachedMode === toolBackgroundMode
 			&& this.cachedExpanded === this.expanded
 		) {
-			return this.cachedLines;
+			return applyGroupHover(this.cachedLines, this.mouseLayout, (this as any)[GROUP_HOVER_KEY]);
 		}
 
 		const status = this.statusSnapshot();
@@ -988,6 +1031,12 @@ class ToolGroupComponent extends Container {
 		const label = getToolGroupLabel(this.tools);
 		const names = groupedName ? "" : formatToolNameList(this.tools);
 		const overall: ToolStatus = status.error > 0 ? "error" : status.pending > 0 ? "pending" : "success";
+		const mouseChildren: MouseLayoutEntry[] = [];
+		let mouseY = 0;
+		const recordLines = (rowLines: string[], target?: any) => {
+			mouseChildren.push({ component: target, height: rowLines.length, top: mouseY });
+			mouseY += rowLines.length;
+		};
 		// Group header breathes only when every pending member is Agent-family;
 		// mixed groups keep the ordinary on/off light.
 		const pendingTools = this.tools.filter((tool) => getToolStatusForGroup(tool) === "pending");
@@ -1006,13 +1055,17 @@ class ToolGroupComponent extends Container {
 		if (collapseToSingleRow) {
 			const entry = { tools: this.tools, name: groupedName, subject };
 			const entryLine = getCollapsedToolEntryLine(entry, Math.max(1, safeWidth - 3));
-			lines.push(clampLineWidth(
+			const row = [clampLineWidth(
 				` ${light} ${entryLine}${toolOutputDetailHint(undefined as any, false, true)}`,
 				safeWidth,
-			));
+			)];
+			recordLines(row, undefined);
+			lines.push(...row);
 		} else {
 			const summary = ` ${light} ${summaryLabel} ${countsText}${names ? ` ${TRANSPARENT_RESET}• ${names}` : ""}${toolOutputDetailHint(undefined as any, this.expanded, true)}`;
-			lines.push(" ".repeat(safeWidth), clampLineWidth(summary, safeWidth));
+			const header = [" ".repeat(safeWidth), clampLineWidth(summary, safeWidth)];
+			recordLines(header, undefined);
+			lines.push(...header);
 			const childWidth = Math.max(1, safeWidth - 6);
 			if (this.expanded) {
 				for (let index = 0; index < total; index++) {
@@ -1025,7 +1078,9 @@ class ToolGroupComponent extends Container {
 						getToolStatusForGroup(tool),
 						{ agentBreathe: isAgentFamilyToolName(getToolName(tool)) },
 					);
-					for (const line of branched) lines.push(clampLineWidth(line, safeWidth));
+					const row = branched.map((line) => clampLineWidth(line, safeWidth));
+					recordLines(row, tool);
+					lines.push(...row);
 				}
 			} else {
 				const entries = collapseRepeatedToolEntries(this.tools);
@@ -1039,10 +1094,13 @@ class ToolGroupComponent extends Container {
 						getToolGroupOverallStatus(entry.tools),
 						{ agentBreathe: entry.tools.every((tool) => isAgentFamilyToolName(getToolName(tool))) },
 					);
-					for (const line of branched) lines.push(clampLineWidth(line, safeWidth));
+					const row = branched.map((line) => clampLineWidth(line, safeWidth));
+					recordLines(row, entry.tools.length === 1 ? entry.tools[0] : entry.tools);
+					lines.push(...row);
 				}
 			}
 		}
+		rememberMouseLayout(this, safeWidth, mouseChildren);
 
 		// Final clamp already applied per-line above; avoid a second full pass.
 		if (canCache) {
@@ -1058,10 +1116,20 @@ class ToolGroupComponent extends Container {
 		} else {
 			this.clearRenderCache();
 		}
-		return lines;
+		return applyGroupHover(lines, this.mouseLayout, (this as any)[GROUP_HOVER_KEY]);
 	}
 }
 
+function applyGroupHover(lines: string[], layout: { children: MouseLayoutEntry[] } | undefined, hoverStart: unknown): string[] {
+	if (typeof hoverStart !== "number" || hoverStart < 0 || !layout) return lines;
+	const entry = layout.children.find((candidate) => candidate.top === hoverStart);
+	if (!entry) return lines;
+	const rendered = lines.slice();
+	const line = entry.top + (entry.component ? 0 : Math.max(0, entry.height - 1));
+	if (line < rendered.length) rendered[line] = brightenRenderedLine(rendered[line]);
+	return rendered;
+}
+
 function isToolGroupComponent(value: unknown): value is ToolGroupComponent {
 	return value instanceof ToolGroupComponent;
 }
@@ -1132,7 +1200,7 @@ function isThinkingOnlyAssistantComponent(comp: unknown): comp is InstanceType<t
 	if (hasText) return false;
 	const hasToolCalls = msg.content.some((c: any) => c?.type === "toolCall");
 	if (hasToolCalls) return false;
-	if ((comp as any).isStreaming === true || msg[THINKING_ACTIVE_KEY]) return false;
+	if ((comp as any).isStreaming === true || hasThinkingActiveMetadata(msg)) return false;
 	return true;
 }
 
@@ -1160,10 +1228,13 @@ function maybeMergeConsecutiveThinkingMessages(parent: any): void {
 			const mergedDuration = durA + durB;
 
 			const nextThinkingBlocks = nextMsg.content.filter((c: any) => c?.type === "thinking");
-			curMsg.content.push(...nextThinkingBlocks);
-			curMsg[THINKING_DURATION_KEY] = mergedDuration;
+			const mergedMessage = {
+				...curMsg,
+				content: [...curMsg.content, ...nextThinkingBlocks],
+				[THINKING_DURATION_KEY]: mergedDuration,
+			};
 
-			(current as any).updateContent(curMsg);
+			(current as any).updateContent(mergedMessage);
 
 			const removeCount = nextIdx - i;
 			children.splice(i + 1, removeCount);
@@ -1189,7 +1260,7 @@ function maybeGroupToolComponent(parent: any, component: any): void {
 	}
 	if (isGroupableTool(previous)) {
 		const group = new ToolGroupComponent();
-		group.setExpanded(Boolean((previous as any).expanded));
+		group.expanded = (previous as any).expanded === true || (component as any).expanded === true;
 		group.addTool(previous);
 		group.addTool(component);
 		(group as any)[COMPONENT_PARENT] = parent;
@@ -1265,17 +1336,21 @@ function patchGlobalToolBorders(): void {
 				&& cached?.branchKey === branchKey
 				&& cached?.branchEpoch === _toolBranchVisualEpoch
 			) {
+				// A cache hit skips Container.render, which is also where fullscreen
+				// mouse targets are recorded. Restore the layout from that render.
+				if (cached.mouseLayout) (this as { mouseLayout?: unknown }).mouseLayout = cached.mouseLayout;
 				return cached.lines;
 			}
 		}
 
 		const rendered = originalRender.call(this, width);
+		const mouseLayout = (this as { mouseLayout?: unknown }).mouseLayout;
 		if (!Array.isArray(rendered) || rendered.length === 0) return rendered;
 		const todoOverlay = formatTodoOverlayLines(rendered, width);
 		if (!isToolExecutionLike(this)) return todoOverlay;
 		const branchCache = { branchKey: toolBranchRenderCacheKey(), branchEpoch: _toolBranchVisualEpoch };
 		if (toolBackgroundMode === "default") {
-			(this as any)[TOOL_RENDER_CACHE] = { width, mode: toolBackgroundMode, lines: rendered, ...branchCache };
+			(this as any)[TOOL_RENDER_CACHE] = { width, mode: toolBackgroundMode, lines: rendered, mouseLayout, ...branchCache };
 			return rendered;
 		}
 
@@ -1287,7 +1362,7 @@ function patchGlobalToolBorders(): void {
 
 		const { textLines, imageLines } = splitRenderedImageBlock(rendered.slice(start, end + 1));
 		if (imageLines.length > 0) {
-			(this as any)[TOOL_RENDER_CACHE] = { width, mode: toolBackgroundMode, lines: rendered, ...branchCache };
+			(this as any)[TOOL_RENDER_CACHE] = { width, mode: toolBackgroundMode, lines: rendered, mouseLayout, ...branchCache };
 			return rendered;
 		}
 		// Agent-family tools stay column-aligned with every other tool row — no extra
@@ -1307,7 +1382,7 @@ function patchGlobalToolBorders(): void {
 			result = [spacerLine, ...core, ...imageLines];
 		}
 
-		(this as any)[TOOL_RENDER_CACHE] = { width, mode: toolBackgroundMode, lines: result, ...branchCache };
+		(this as any)[TOOL_RENDER_CACHE] = { width, mode: toolBackgroundMode, lines: result, mouseLayout, ...branchCache };
 		return result;
 	};
 
@@ -1379,6 +1454,96 @@ function clearToolRenderCache(value: unknown): void {
 	if (isToolGroupComponent(parent)) parent.invalidate();
 }
 
+/** Fullscreen hit-testing reads the layout recorded by the last render. */
+function rememberMouseLayout(component: object, width: number, children: MouseLayoutEntry[]): void {
+	(component as { mouseLayout?: { width: number; children: MouseLayoutEntry[] } }).mouseLayout = { width, children };
+}
+
+function isPrimaryClick(event: TuiMouseEvent): boolean {
+	return event.type === "click" && event.button === "left";
+}
+
+function toggleExpandedComponent(component: any): boolean {
+	if (!component || typeof component.setExpanded !== "function") return false;
+	component.setExpanded(component.expanded !== true);
+	return true;
+}
+
+function requestComponentRender(component: any): void {
+	const ui = component?.ui;
+	if (typeof ui?.requestRender === "function") ui.requestRender();
+}
+
+const GROUP_HOVER_KEY = Symbol.for("pi-claude-style-tools:group-hover");
+
+function setGroupHover(group: any, rowStart: number): boolean {
+	if (group[GROUP_HOVER_KEY] === rowStart) return false;
+	group[GROUP_HOVER_KEY] = rowStart;
+	return true;
+}
+
+function mouseLayoutTarget(
+	layout: { width: number; children: MouseLayoutEntry[] } | undefined,
+	event: TuiMouseEvent,
+): MouseLayoutEntry | undefined {
+	if (!layout || layout.width !== event.width || event.y < 0 || event.y >= event.height) return undefined;
+	return layout.children.find((entry) => event.y >= entry.top && event.y < entry.top + entry.height);
+}
+
+function toggleGroupedTools(group: any, tools: any[]): { handled: true } | undefined {
+	const targets = tools.filter((tool) => typeof tool?.setExpanded === "function");
+	if (targets.length === 0) return undefined;
+	const expanded = targets.some((tool) => tool.expanded !== true);
+	for (const tool of targets) tool.setExpanded(expanded);
+	if (Array.isArray(group?.tools)) group.expanded = group.tools.some((tool: any) => tool?.expanded === true);
+	group.invalidate?.();
+	const ui = targets.find((tool) => typeof tool?.ui?.requestRender === "function")?.ui;
+	ui?.requestRender?.();
+	return { handled: true };
+}
+
+let hoveredClickTarget: { owner: object; clear: () => void } | undefined;
+let hoverClaimedThisMove = false;
+
+function claimClickHover(owner: object, clear: () => void): void {
+	hoverClaimedThisMove = true;
+	if (hoveredClickTarget?.owner === owner) return;
+	const previous = hoveredClickTarget;
+	hoveredClickTarget = { owner, clear };
+	previous?.clear();
+}
+
+function patchFullscreenHoverExit(): void {
+	const proto = (PiTui as any).TuiAltScreen?.prototype;
+	if (!proto || proto[FULLSCREEN_HOVER_PATCH_FLAG] || typeof proto.handleMouseEvent !== "function") return;
+	const originalHandleMouse = proto.handleMouseEvent;
+	proto.handleMouseEvent = function patchedFullscreenMouseEvent(raw: { button: number }) {
+		const isMove = (raw.button & 35) === 35;
+		if (isMove) hoverClaimedThisMove = false;
+		const result = originalHandleMouse.call(this, raw);
+		if (isMove && !hoverClaimedThisMove && hoveredClickTarget) {
+			const previous = hoveredClickTarget;
+			hoveredClickTarget = undefined;
+			previous.clear();
+			this.requestRender();
+		}
+		return result;
+	};
+	if (typeof proto.handleViewportInput === "function") {
+		const originalInput = proto.handleViewportInput;
+		proto.handleViewportInput = function patchedFullscreenInput(data: string) {
+			if (data === "\x1b[O" && hoveredClickTarget) {
+				const previous = hoveredClickTarget;
+				hoveredClickTarget = undefined;
+				previous.clear();
+				this.requestRender();
+			}
+			return originalInput.call(this, data);
+		};
+	}
+	proto[FULLSCREEN_HOVER_PATCH_FLAG] = true;
+}
+
 function unrefTimer(timer: ReturnType<typeof setTimeout> | null | undefined): void {
 	(timer as any)?.unref?.();
 }
@@ -1393,6 +1558,7 @@ function safeInvalidate(ctx: any): void {
 
 const ASSISTANT_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-assistant-message");
 const ASSISTANT_RENDER_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-assistant-message-render");
+const ASSISTANT_MOUSE_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-assistant-fullscreen-mouse");
 const TOOL_EXECUTION_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-tool-execution");
 
 // Rendered-output cache for assistant/user/custom message components.
@@ -1450,9 +1616,48 @@ const WORKED_TURNS_KEY = "_piClaudeStyleWorkedTurns";
 const WORKED_DURATION_MARKER = "Turn took";
 const THINKING_DURATION_KEY = "_piClaudeStyleThinkingDurationMs";
 const THINKING_ACTIVE_KEY = "_piClaudeStyleThinkingActive";
-const MIN_THINKING_SUMMARY_MS = 100;
+const MAX_REASONABLE_THINKING_DURATION_MS = 24 * 60 * 60 * 1000;
+
+// Presentation metadata belongs to the renderer, not the canonical session
+// messages. Weak collections keep live state available to the TUI without
+// changing the objects Pi persists or projects for compaction replay.
+const thinkingDurationByMessage = new WeakMap<object, number>();
+const thinkingActiveMessages = new WeakSet<object>();
+const workedStartByMessage = new WeakMap<object, number>();
+const workedDurationByMessage = new WeakMap<object, { duration: number; sessionTotal?: number; turns?: number }>();
+
+function getThinkingDurationMetadata(message: any): number | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const stored = thinkingDurationByMessage.get(message) ?? message[THINKING_DURATION_KEY];
+	return typeof stored === "number"
+		&& Number.isFinite(stored)
+		&& stored > 0
+		&& stored <= MAX_REASONABLE_THINKING_DURATION_MS
+		? stored
+		: undefined;
+}
+
+function hasThinkingActiveMetadata(message: any): boolean {
+	return !!message
+		&& typeof message === "object"
+		&& (thinkingActiveMessages.has(message) || message[THINKING_ACTIVE_KEY] === true);
+}
+
+function workedMetadataForMessage(message: any): { duration: number; sessionTotal?: number; turns?: number } | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const metadata = workedDurationByMessage.get(message);
+	if (metadata) return metadata;
+	const duration = message[WORKED_DURATION_KEY];
+	if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0) return undefined;
+	const sessionTotal = message[WORKED_SESSION_TOTAL_KEY];
+	const turns = message[WORKED_TURNS_KEY];
+	return {
+		duration,
+		sessionTotal: typeof sessionTotal === "number" ? sessionTotal : undefined,
+		turns: typeof turns === "number" ? turns : undefined,
+	};
+}
 
-let lastThinkingBlockDurationMs: number | undefined;
 let thinkingBlockStartMs = 0;
 /** True from thinking_start until thinking_end on the current assistant stream. */
 let thinkingBlockInFlight = false;
@@ -1518,9 +1723,25 @@ function pluralizeTurns(n: number): string {
 	return `${n} turn${n === 1 ? "" : "s"}`;
 }
 
-function thinkingSummaryStyledText(body: string): string {
+function thinkingSummaryStyledText(body: string, hovered = false): string {
 	// Preserve the visible thinking text column while omitting ∴ when collapsed.
-	return `   ${WORKED_LINE_FG}${body}${RESET}`;
+	const color = hovered ? brightenAnsi(WORKED_LINE_FG) : WORKED_LINE_FG;
+	return `   ${color}${body}${RESET}`;
+}
+
+/** Brighten an existing color without changing its hue. */
+function brightenAnsi(baseAnsi: string): string {
+	const rgb = parseAnsiRgb(baseAnsi);
+	if (!rgb) return "\x1b[97m";
+	const maximum = Math.max(rgb.r, rgb.g, rgb.b);
+	if (maximum === 0) return baseAnsi;
+	const scale = Math.min(1.12, 255 / maximum);
+	const lift = (channel: number) => Math.round(channel * scale);
+	return `\x1b[38;2;${lift(rgb.r)};${lift(rgb.g)};${lift(rgb.b)}m`;
+}
+
+function brightenRenderedLine(line: string): string {
+	return line.replace(/\x1b\[38;2;(\d+);(\d+);(\d+)m/g, (_match, r, g, b) => brightenAnsi(`\x1b[38;2;${r};${g};${b}m`));
 }
 
 function thinkingActiveSummaryText(): string {
@@ -1533,48 +1754,55 @@ function thoughtDurationSummaryText(ms: number): string {
 
 /** Single-line hidden thinking row — no Text paddingX or thinking symbol. */
 class HiddenThinkingSummary {
-	private summaryText: string;
+	private body: string;
+	private hovered = false;
 	private cachedWidth?: number;
+	private cachedHovered?: boolean;
 	private cachedLines?: string[];
 
-	constructor(summaryText: string) {
-		this.summaryText = summaryText;
+	constructor(body: string) {
+		this.body = stripAnsi(body).trim();
 	}
 
 	setSummary(summaryText: string): void {
-		this.summaryText = summaryText;
+		const body = stripAnsi(summaryText).trim();
+		if (this.body === body) return;
+		this.body = body;
+		this.invalidate();
+	}
+
+	setHovered(hovered: boolean): void {
+		if (this.hovered === hovered) return;
+		this.hovered = hovered;
 		this.invalidate();
 	}
 
 	invalidate(): void {
 		this.cachedWidth = undefined;
+		this.cachedHovered = undefined;
 		this.cachedLines = undefined;
 	}
 
 	render(width: number): string[] {
-		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+		if (this.cachedLines && this.cachedWidth === width && this.cachedHovered === this.hovered) return this.cachedLines;
 		const safeWidth = Number.isFinite(width) ? Math.max(0, Math.floor(width)) : 0;
 		if (safeWidth <= 0) {
 			this.cachedWidth = width;
+			this.cachedHovered = this.hovered;
 			this.cachedLines = [""];
 			return this.cachedLines;
 		}
-		const line = padRenderedLineToWidth(this.summaryText, safeWidth);
+		const line = padRenderedLineToWidth(thinkingSummaryStyledText(this.body, this.hovered), safeWidth);
 		this.cachedWidth = width;
+		this.cachedHovered = this.hovered;
 		this.cachedLines = [line];
 		return this.cachedLines;
 	}
 }
 
 function getMessageThinkingDurationMs(message: any): number {
-	const stored = (message as any)?.[THINKING_DURATION_KEY];
-	if (typeof stored === "number" && stored > 0) return stored;
-	if (typeof lastThinkingBlockDurationMs === "number" && lastThinkingBlockDurationMs > 0) {
-		return lastThinkingBlockDurationMs;
-	}
-	if (typeof (message as any)?.[WORKED_DURATION_KEY] === "number" && (message as any)[WORKED_DURATION_KEY] > 0) {
-		return (message as any)[WORKED_DURATION_KEY];
-	}
+	const stored = getThinkingDurationMetadata(message);
+	if (stored !== undefined) return stored;
 	let totalChars = 0;
 	if (Array.isArray(message?.content)) {
 		for (const block of message.content) {
@@ -1595,9 +1823,6 @@ function hiddenThinkingSummaryForMessage(message: any, comp?: any): string {
 		return thinkingActiveSummaryText();
 	}
 	const durationMs = getMessageThinkingDurationMs(message);
-	if (message && typeof message === "object") {
-		(message as any)[THINKING_DURATION_KEY] = durationMs;
-	}
 	return thoughtDurationSummaryText(durationMs);
 }
 
@@ -1778,13 +2003,20 @@ function patchTerminalWriteTagScrubber(): void {
 
 function replaceInlineMath(text: string): string {
 	if (!hasInlineMathMarkers(text)) return text;
-	const withParens = text.replace(/\\\(([\s\S]*?)\\\)/g, (_match, body: string) => {
-		return codeSpan(formatMathForDisplay(body, false));
-	});
-	return withParens.replace(/(^|[^\\])\$([^\n$]{1,200})\$/g, (match, prefix: string, body: string) => {
-		if (!looksLikeInlineMath(body)) return match;
-		return `${prefix}${codeSpan(formatMathForDisplay(body, false))}`;
-	});
+	const transform = (segment: string): string => {
+		const withParens = segment.replace(/\\\(([\s\S]*?)\\\)/g, (_match, body: string) => {
+			return codeSpan(formatMathForDisplay(body, false));
+		});
+		return withParens.replace(/(^|[^\\])\$([^\n$]{1,200})\$/g, (match, prefix: string, body: string) => {
+			if (!looksLikeInlineMath(body)) return match;
+			return `${prefix}${codeSpan(formatMathForDisplay(body, false))}`;
+		});
+	};
+	// Markdown code spans and fenced blocks are literal source. Apply math
+	// formatting only to prose segments so shell variables such as `$base` and
+	// `$scope` remain byte-for-byte unchanged in displayed/copied commands.
+	const parts = text.split(/(`{3,}[\s\S]*?`{3,}|`[^`\n]*`)/g);
+	return parts.map((part, index) => index % 2 === 1 ? part : transform(part)).join("");
 }
 
 interface MathBlock {
@@ -1873,16 +2105,30 @@ function shouldFormatStandaloneMath(text: string): boolean {
 	return !/[.!?]\s/.test(plain) && plain.length <= 240;
 }
 
-function appendMarkdownSegment(segments: ParagraphSegment[], text: string, theme: MarkdownThemeLike): void {
+// Options Pi hands to the Markdown components it builds, including the markdown
+// transformers (Pi's own Mermaid renderer, extension transformers, ...). Paragraph
+// wrappers rebuild those components, so they have to forward the options.
+type MarkdownOptions = ConstructorParameters<typeof Markdown>[5]
+
+function appendMarkdownSegment(
+	segments: ParagraphSegment[],
+	text: string,
+	theme: MarkdownThemeLike,
+	options?: MarkdownOptions,
+): void {
 	if (!text.trim()) return;
 	const normalized = shouldFormatStandaloneMath(text) ? formatMathForDisplay(text, false) : replaceInlineMath(text);
-	segments.push({ kind: "markdown", md: new Markdown(normalized, 0, 0, theme) });
+	segments.push({ kind: "markdown", md: new Markdown(normalized, 0, 0, theme, undefined, options) });
 }
 
-function buildParagraphSegments(text: string, theme: MarkdownThemeLike): ParagraphSegment[] {
+function buildParagraphSegments(
+	text: string,
+	theme: MarkdownThemeLike,
+	options?: MarkdownOptions,
+): ParagraphSegment[] {
 	const segments: ParagraphSegment[] = [];
 	if (!hasDisplayMathMarkers(text)) {
-		appendMarkdownSegment(segments, text, theme);
+		appendMarkdownSegment(segments, text, theme, options);
 		return segments;
 	}
 	const scanLoose = shouldScanLooseBracketMath(text);
@@ -1890,12 +2136,12 @@ function buildParagraphSegments(text: string, theme: MarkdownThemeLike): Paragra
 	while (cursor < text.length) {
 		const next = findNextDisplayMathBlock(text, cursor, scanLoose);
 		if (!next) break;
-		appendMarkdownSegment(segments, text.slice(cursor, next.index), theme);
+		appendMarkdownSegment(segments, text.slice(cursor, next.index), theme, options);
 		const raw = text.slice(next.contentStart, next.contentEnd).trim();
 		if (raw) segments.push({ kind: "math", raw });
 		cursor = next.endIndex;
 	}
-	appendMarkdownSegment(segments, text.slice(cursor), theme);
+	appendMarkdownSegment(segments, text.slice(cursor), theme, options);
 	return segments;
 }
 
@@ -1982,9 +2228,9 @@ class DottedParagraph {
 	private cachedWidth?: number;
 	private cachedLines?: string[];
 
-	constructor(text: string, markdownTheme: MarkdownThemeLike) {
+	constructor(text: string, markdownTheme: MarkdownThemeLike, options?: MarkdownOptions) {
 		this.markdownTheme = copySafeMarkdownTheme(markdownTheme);
-		this.segments = buildParagraphSegments(stripTransientMagicContextTags(text), this.markdownTheme);
+		this.segments = buildParagraphSegments(stripTransientMagicContextTags(text), this.markdownTheme, options);
 	}
 
 	invalidate(): void {
@@ -2073,16 +2319,29 @@ function replaceHiddenThinkingPlaceholders(container: { children?: any[] }, mess
 
 class ThinkingParagraph {
 	private text: string;
+	private hovered = false;
 	private cachedWidth?: number;
 	private cachedLines?: string[];
+	private cachedHovered = false;
 	private chromeEpoch = -1;
+	private options?: MarkdownOptions;
+
+	setHovered(hovered: boolean): void {
+		if (this.hovered === hovered) return;
+		this.hovered = hovered;
+		this.invalidate();
+	}
 
 	constructor(
 		text: string,
 		_markdownTheme: ConstructorParameters<typeof Markdown>[3],
 		_defaultTextStyle?: ConstructorParameters<typeof Markdown>[4],
+		options?: MarkdownOptions,
 	) {
-		this.text = stripTransientMagicContextTags(text);
+		// Prefix only the renderer's private copy. The assistant message itself is
+		// canonical session data and must remain untouched for compaction replay.
+		this.text = prefixThinkingLine(stripTransientMagicContextTags(text), undefined);
+		this.options = options;
 	}
 
 	private thinkingMarkdown(): InstanceType<typeof Markdown> {
@@ -2110,7 +2369,7 @@ class ThinkingParagraph {
 			italic: false,
 			color: (s: string) => `${DIM_FG}${s}`,
 		};
-		return new Markdown(this.text, 0, 0, plainTheme, plainStyle);
+		return new Markdown(this.text, 0, 0, plainTheme, plainStyle, this.options);
 	}
 
 	invalidate(): void {
@@ -2123,6 +2382,7 @@ class ThinkingParagraph {
 		if (
 			this.cachedLines
 			&& this.cachedWidth === width
+			&& this.cachedHovered === this.hovered
 			&& this.chromeEpoch === _toolBranchVisualEpoch
 		) {
 			return this.cachedLines;
@@ -2144,8 +2404,9 @@ class ThinkingParagraph {
 			return this.cachedLines;
 		}
 		const lines = sanitizeRenderedTextBlockLines(md.render(safeWidth - PREFIX_W), safeWidth - PREFIX_W);
+		const displayLines = this.hovered ? lines.map((line) => brightenRenderedLine(line)) : lines;
 		let symbolPlaced = false;
-		const rendered = lines.map((line: string) => {
+		const rendered = displayLines.map((line: string) => {
 			if (!symbolPlaced && stripAnsi(line).trim()) {
 				symbolPlaced = true;
 				return ` ${prefix} ${line}`;
@@ -2153,6 +2414,7 @@ class ThinkingParagraph {
 			return `   ${line}`;
 		}).map((line) => clampLineWidth(line, safeWidth));
 		this.cachedWidth = width;
+		this.cachedHovered = this.hovered;
 		this.cachedLines = rendered;
 		this.chromeEpoch = _toolBranchVisualEpoch;
 		return rendered;
@@ -2444,8 +2706,10 @@ function patchAssistantMessages(): void {
 		// - "full" mode: behaves like stock pi (stays collapsed).
 		const liveMode = getThinkingMode() === "live";
 		const thinkingCollapsed = !!(this as any).hideThinkingBlock;
-		const showLiveThinking = liveMode && thinkingCollapsed && isLiveThinkingMessage(this, message);
-		if (thinkingCollapsed && messageHasThinkingContent(message)) {
+		const override = (this as any).thinkingVisibilityOverrides?.get?.(0);
+		const showLiveThinking = liveMode && thinkingCollapsed && override !== true && isLiveThinkingMessage(this, message);
+		const hideThinking = override ?? (thinkingCollapsed && !showLiveThinking);
+		if (hideThinking && messageHasThinkingContent(message)) {
 			// Pi wraps this in theme.italic/fg again — keep plain label for the placeholder pass.
 			(this as any).hiddenThinkingLabel = "Thinking…";
 		}
@@ -2459,7 +2723,7 @@ function patchAssistantMessages(): void {
 		// Replace text-block Markdown children with DottedParagraph wrappers
 		const container = (this as any).contentContainer;
 		if (!container?.children) return;
-		if (thinkingCollapsed && !showLiveThinking && messageHasThinkingContent(message)) {
+		if (hideThinking && messageHasThinkingContent(message)) {
 			replaceHiddenThinkingPlaceholders(container, message);
 		}
 		const mdTheme = (this as any).markdownTheme;
@@ -2469,17 +2733,18 @@ function patchAssistantMessages(): void {
 			if (isMarkdownComponent(inner)) {
 				const text = (inner as any).text;
 				if (!text) continue;
+				const options = (inner as any).options as MarkdownOptions;
 				const isThinking = !!(inner as any).defaultTextStyle?.italic;
 				if (isThinking) {
 					const style = (inner as any).defaultTextStyle;
-					const replacement = new ThinkingParagraph(text, mdTheme, style);
+					const replacement = new ThinkingParagraph(text, mdTheme, style, options);
 					if ((child as any)?.child !== undefined) {
 						(child as any).child = replacement;
 					} else {
 						container.children[i] = replacement;
 					}
 				} else {
-					const replacement = new DottedParagraph(text, mdTheme);
+					const replacement = new DottedParagraph(text, mdTheme, options);
 					if ((child as any)?.child !== undefined) {
 						(child as any).child = replacement;
 					} else {
@@ -2488,9 +2753,10 @@ function patchAssistantMessages(): void {
 				}
 			}
 		}
-		const explicitDuration = (message as any)[WORKED_DURATION_KEY];
-		const explicitSessionTotal = (message as any)[WORKED_SESSION_TOTAL_KEY];
-		const explicitTurns = (message as any)[WORKED_TURNS_KEY];
+		const workedMetadata = workedMetadataForMessage(message);
+		const explicitDuration = workedMetadata?.duration;
+		const explicitSessionTotal = workedMetadata?.sessionTotal;
+		const explicitTurns = workedMetadata?.turns;
 		// The "Turn took" line must only appear once the stream has truly closed.
 		// `message.stopReason === "stop"` is not a safe "finished" signal here because
 		// providers may initialize a live message with that value. The `message_end`
@@ -2513,8 +2779,120 @@ function patchAssistantMessages(): void {
 	proto[ASSISTANT_PATCH_FLAG] = true;
 }
 
+const THINKING_HOVER_KEY = Symbol.for("pi-claude-style-tools:thinking-hover");
+
+function thinkingVisualChild(child: any): any {
+	const inner = child?.child ?? child;
+	if (
+		inner instanceof HiddenThinkingSummary
+		|| inner instanceof ThinkingParagraph
+		|| inner?.constructor?.name === "HiddenThinkingSummary"
+		|| inner?.constructor?.name === "ThinkingParagraph"
+	) return inner;
+	return undefined;
+}
+
+function thinkingLayout(component: any, width: number): Array<{ component: any; height: number }> {
+	const container = component?.contentContainer;
+	const children = Array.isArray(container?.children) ? container.children : [];
+	if (container?.mouseLayout?.width === width) return container.mouseLayout.children;
+	return children.map((child: any) => ({ component: child, height: child.render(width).length }));
+}
+
+function thinkingRowAt(component: any, event: TuiMouseEvent): any {
+	let childY = 0;
+	for (const entry of thinkingLayout(component, event.width)) {
+		if (event.y >= childY && event.y < childY + entry.height) return thinkingVisualChild(entry.component);
+		childY += entry.height;
+	}
+	return undefined;
+}
+
+function setThinkingHover(component: any, hovered: any): boolean {
+	const previous = component[THINKING_HOVER_KEY];
+	if (previous === hovered) return false;
+	previous?.setHovered?.(false);
+	if (hovered) hovered.setHovered(true);
+	component[THINKING_HOVER_KEY] = hovered;
+	clearMessageRenderCache(component);
+	return true;
+}
+
+function patchAssistantFullscreenMouse(): void {
+	const proto = AssistantMessageComponent.prototype as any;
+	if (proto[ASSISTANT_MOUSE_PATCH_FLAG]) return;
+	const originalHandleMouse = proto.handleMouse;
+	proto.handleMouse = function patchedAssistantHandleMouse(event: TuiMouseEvent) {
+		const hovered = thinkingRowAt(this, event);
+		if (event.type === "move" && hovered) {
+			claimClickHover(this, () => { if (setThinkingHover(this, undefined)) requestComponentRender(this); });
+		}
+		const hoverChanged = event.type === "move" ? setThinkingHover(this, hovered) : false;
+		if (event.type === "move") return hoverChanged ? { handled: true, render: true } : undefined;
+		// Claim the row before Pi's MouseRegion. Its handler restores the italic
+		// "Thinking…" label while a block is streaming.
+		if (isPrimaryClick(event) && hovered && this.lastMessage) {
+			const overrides = this.thinkingVisibilityOverrides instanceof Map
+				? this.thinkingVisibilityOverrides
+				: new Map();
+			this.thinkingVisibilityOverrides = overrides;
+			overrides.set(0, hovered instanceof ThinkingParagraph);
+			this.updateContent(this.lastMessage);
+			return { handled: true };
+		}
+		return typeof originalHandleMouse === "function" ? originalHandleMouse.call(this, event) : undefined;
+	};
+	proto[ASSISTANT_MOUSE_PATCH_FLAG] = true;
+}
+
 const TOOL_BG_PATCH_FLAG = Symbol.for("pi-claude-style-tools:patched-tool-bg-sync");
 
+const TOOL_HOVER_KEY = Symbol.for("pi-claude-style-tools:tool-hover");
+
+function setToolHover(component: any, hovered: boolean): boolean {
+	if (component[TOOL_HOVER_KEY] === hovered) return false;
+	component[TOOL_HOVER_KEY] = hovered;
+	clearToolRenderCache(component);
+	return true;
+}
+
+function patchToolFullscreenMouse(): void {
+	const proto = ToolExecutionComponent.prototype as any;
+	if (proto[TOOL_MOUSE_PATCH_FLAG]) return;
+	const originalHandleMouse = proto.handleMouse;
+	if (typeof originalHandleMouse !== "function") return;
+	const originalRender = proto.render;
+	proto.render = function patchedToolHoverRender(width: number) {
+		const lines = originalRender.call(this, width);
+		if (this[TOOL_HOVER_KEY] !== true || !Array.isArray(lines)) return lines;
+		const titleIndex = lines.findIndex((line: string) => stripAnsi(line).trim().length > 0 && !/^\s*[╭╰─│]+\s*$/.test(stripAnsi(line)));
+		if (titleIndex < 0) return lines;
+		const rendered = lines.slice();
+		rendered[titleIndex] = brightenRenderedLine(rendered[titleIndex]);
+		return rendered;
+	};
+	proto.handleMouse = function patchedToolHandleMouse(event: TuiMouseEvent) {
+		if (event.type === "move") {
+			claimClickHover(this, () => { if (setToolHover(this, false)) requestComponentRender(this); });
+			return setToolHover(this, true) ? { handled: true, render: true } : undefined;
+		}
+		const result = originalHandleMouse.call(this, event);
+		if (result) return result;
+		// Self-rendered rows forward into their own content. Default-shell rows
+		// reach here only when no nested region claimed the click, including the
+		// blank outline padding our container patch paints around the content.
+		if (!isPrimaryClick(event) || !this.result) return undefined;
+		const group = this[COMPONENT_PARENT];
+		if (group?.constructor?.name === "ToolGroupComponent") {
+			return toggleGroupedTools(group, [this]);
+		}
+		if (!toggleExpandedComponent(this)) return undefined;
+		requestComponentRender(this);
+		return { handled: true };
+	};
+	proto[TOOL_MOUSE_PATCH_FLAG] = true;
+}
+
 function patchToolExecutionBackgroundSync(): void {
 	const proto = ToolExecutionComponent.prototype as any;
 	if (proto[TOOL_BG_PATCH_FLAG]) return;
@@ -3465,6 +3843,10 @@ function bashCollapsedLimit(): number {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 10;
 }
 
+function bashOutputMode(): "opencode" | "summary" | "preview" {
+	return getMode(readSettings().bashOutputMode, ["opencode", "summary", "preview"] as const, "opencode");
+}
+
 function bashCommandPreviewLimit(): number {
 	const value = readSettings().bashCommandPreviewLines;
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 8;
@@ -5274,20 +5656,23 @@ function trackThinkingBlockEvents(event: any, ctx?: any): void {
 	if (evt.type === "thinking_start") {
 		thinkingBlockInFlight = true;
 		thinkingBlockStartMs = Date.now();
-		lastThinkingBlockDurationMs = undefined;
 		if (message?.role === "assistant") {
-			(message as any)[THINKING_ACTIVE_KEY] = true;
-			delete (message as any)[THINKING_DURATION_KEY];
+			thinkingActiveMessages.add(message);
+			thinkingDurationByMessage.delete(message);
 		}
 		refreshThinkingChrome();
 		return;
 	}
 	if (evt.type === "thinking_end") {
 		thinkingBlockInFlight = false;
-		const duration = Math.max(0, Date.now() - thinkingBlockStartMs);
-		if (message?.role === "assistant") delete (message as any)[THINKING_ACTIVE_KEY];
-		lastThinkingBlockDurationMs = duration;
-		if (message?.role === "assistant") (message as any)[THINKING_DURATION_KEY] = duration;
+		const duration = thinkingBlockStartMs > 0
+			? Math.max(0, Date.now() - thinkingBlockStartMs)
+			: undefined;
+		if (message?.role === "assistant") thinkingActiveMessages.delete(message);
+		if (typeof duration === "number" && duration <= MAX_REASONABLE_THINKING_DURATION_MS && message?.role === "assistant") {
+			thinkingDurationByMessage.set(message, duration);
+		}
+		thinkingBlockStartMs = 0;
 		refreshThinkingChrome();
 		return;
 	}
@@ -5297,15 +5682,15 @@ function trackThinkingBlockEvents(event: any, ctx?: any): void {
 	// run normally. Any non-thinking stream event on the same assistant message
 	// means thinking is no longer the live activity: freeze the elapsed time into
 	// a "Thought for Xs" duration so the row always resolves.
-	if ((message as any)?.[THINKING_ACTIVE_KEY] || thinkingBlockInFlight) {
+	if (hasThinkingActiveMetadata(message) || thinkingBlockInFlight) {
 		if (evt.type === "text_start" || evt.type === "text_delta" || evt.type === "toolcall_start" || evt.type === "toolcall_end") {
 			thinkingBlockInFlight = false;
 			const duration = thinkingBlockStartMs > 0 ? Math.max(0, Date.now() - thinkingBlockStartMs) : undefined;
-			if (message?.role === "assistant") delete (message as any)[THINKING_ACTIVE_KEY];
-			if (typeof duration === "number") {
-				lastThinkingBlockDurationMs = duration;
-				if (message?.role === "assistant") (message as any)[THINKING_DURATION_KEY] = duration;
+			if (message?.role === "assistant") thinkingActiveMessages.delete(message);
+			if (typeof duration === "number" && duration <= MAX_REASONABLE_THINKING_DURATION_MS && message?.role === "assistant") {
+				thinkingDurationByMessage.set(message, duration);
 			}
+			thinkingBlockStartMs = 0;
 			refreshThinkingChrome();
 		}
 	}
@@ -5318,11 +5703,9 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 		if (theme) applyThemePaletteIfNeeded(theme);
 		const message = event?.message;
 		if (!message || message.role !== "assistant" || !Array.isArray(message.content)) return;
-		for (const block of message.content) {
-			if (block && block.type === "thinking" && typeof block.thinking === "string") {
-				block.thinking = prefixThinkingLine(block.thinking, theme);
-			}
-		}
+		// Thinking labels are applied by ThinkingParagraph while rendering. Never
+		// rewrite the assistant message object: context/compaction consumers need
+		// its canonical thinking content unchanged.
 	};
 	pi.on("before_agent_start", async () => {
 		// Start once per top-level request. Steering/follow-up messages can be
@@ -5348,13 +5731,14 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 		}
 		if (message?.role === "assistant") {
 			currentAssistantMessageStartMs = Date.now();
-			(message as any)[WORKED_START_KEY] = currentAssistantMessageStartMs;
+			workedStartByMessage.set(message, currentAssistantMessageStartMs);
 			// A new assistant message starts a fresh thinking lifecycle. Without
 			// this, a missing thinking_end on the previous message leaves the
 			// global in-flight flag set and the next message renders a stale
 			// "Thinking..." row until its own thinking events arrive.
 			thinkingBlockInFlight = false;
-			delete (message as any)[THINKING_ACTIVE_KEY];
+			thinkingBlockStartMs = 0;
+			thinkingActiveMessages.delete(message);
 		}
 	});
 	pi.on("message_update", async (event, ctx) => {
@@ -5369,30 +5753,22 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 			// into its "Thought for Xs" duration here so the row always resolves
 			// at the end of the message instead of sticking into later calls.
 			thinkingBlockInFlight = false;
-			delete (message as any)[THINKING_ACTIVE_KEY];
-			if (typeof (message as any)[THINKING_DURATION_KEY] !== "number") {
-				const duration = thinkingBlockStartMs > 0 ? Math.max(0, Date.now() - thinkingBlockStartMs) : undefined;
-				if (typeof duration === "number" && duration > 0) {
-					lastThinkingBlockDurationMs = duration;
-					(message as any)[THINKING_DURATION_KEY] = duration;
-				} else if (typeof lastThinkingBlockDurationMs === "number" && lastThinkingBlockDurationMs > 0) {
-					(message as any)[THINKING_DURATION_KEY] = lastThinkingBlockDurationMs;
-				}
+			thinkingActiveMessages.delete(message);
+			if (getThinkingDurationMetadata(message) === undefined && thinkingBlockStartMs > 0) {
+				const duration = Math.max(0, Date.now() - thinkingBlockStartMs);
+				if (duration <= MAX_REASONABLE_THINKING_DURATION_MS) thinkingDurationByMessage.set(message, duration);
 			}
 			thinkingBlockStartMs = 0;
 			const started = typeof currentAgentWorkStartMs === "number"
 				? currentAgentWorkStartMs
-				: typeof (message as any)[WORKED_START_KEY] === "number"
-					? (message as any)[WORKED_START_KEY]
-					: currentAssistantMessageStartMs;
+				: workedStartByMessage.get(message)
+					?? (typeof (message as any)[WORKED_START_KEY] === "number" ? (message as any)[WORKED_START_KEY] : currentAssistantMessageStartMs);
 			const isFinalAssistantMessage = message.stopReason === "stop";
 			if (started !== undefined && isFinalAssistantMessage) {
 				const durationMs = Date.now() - started;
 				const sessionTotalMs = typeof sessionStartMs === "number" ? Date.now() - sessionStartMs : undefined;
 				const turns = userTurnCount > 0 ? userTurnCount : undefined;
-				(message as any)[WORKED_DURATION_KEY] = durationMs;
-				if (typeof sessionTotalMs === "number") (message as any)[WORKED_SESSION_TOTAL_KEY] = sessionTotalMs;
-				if (typeof turns === "number") (message as any)[WORKED_TURNS_KEY] = turns;
+				workedDurationByMessage.set(message, { duration: durationMs, sessionTotal: sessionTotalMs, turns });
 				// Duration metadata drives the assistant component's TUI-only status line.
 				// Message content stays presentation-neutral for persistence and consumers.
 			}
@@ -5440,17 +5816,10 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 			sessionStartMs = sessionStartMs === undefined ? earliest : Math.min(sessionStartMs, earliest);
 		}
 		if (userCount > userTurnCount) userTurnCount = userCount;
-		for (const msg of messages) {
-			if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-			for (const block of msg.content) {
-				if (block && block.type === "thinking" && typeof block.thinking === "string") {
-					block.thinking = stripThinkingPresentationArtifacts(block.thinking);
-				}
-				if (block && block.type === "text" && typeof block.text === "string") {
-					block.text = stripWorkedDurationLine(block.text);
-				}
-			}
-		}
+		// Do not normalize or strip message content here. The context event is also
+		// consumed by compaction/replay integrations that compare these objects
+		// against the persisted session projection. Presentation cleanup belongs in
+		// the renderer and must not mutate canonical history.
 	});
 }
 
@@ -6440,11 +6809,14 @@ export default function (pi: ExtensionAPI) {
 	patchToolExecutionBackgroundSync();
 	patchToolRenderCacheInvalidation();
 	patchReadImageExpansion();
+	patchFullscreenHoverExit();
+	patchToolFullscreenMouse();
 	patchContainerParentTracking();
 	patchGlobalToolBorders();
 	patchCustomMessageRender();
 	patchUserMessageRender();
 	patchAssistantMessages();
+	patchAssistantFullscreenMouse();
 	patchToolExecutionRenderers();
 	applyDiffPalette();
 	registerThinkingLabels(pi);
@@ -6870,6 +7242,8 @@ export default function (pi: ExtensionAPI) {
 		name: "read",
 		label: "read",
 		description: readTool.description,
+		promptSnippet: (readTool as any).promptSnippet,
+		promptGuidelines: (readTool as any).promptGuidelines,
 		parameters: readTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return readTool.execute(toolCallId, params, signal, onUpdate);
@@ -6925,6 +7299,8 @@ export default function (pi: ExtensionAPI) {
 		name: "bash",
 		label: "bash",
 		description: bashTool.description,
+		promptSnippet: (bashTool as any).promptSnippet,
+		promptGuidelines: (bashTool as any).promptGuidelines,
 		parameters: bashTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return bashTool.execute(toolCallId, params, signal, onUpdate);
@@ -6982,9 +7358,18 @@ export default function (pi: ExtensionAPI) {
 			let text = exitCode === null || exitCode === 0 ? theme.fg("success", "Done") : theme.fg("error", `Exit ${exitCode}`);
 			text += theme.fg("muted", ` (${nonEmpty.total} lines)`);
 			if (details?.truncation?.truncated) text += theme.fg("warning", " [truncated]");
+			const mode = bashOutputMode();
+			if (mode === "summary") return makeText(ctx.lastComponent, withBranch(text, theme));
 			const persistentPreview = shouldPreserveBashPreview(ctx) ? buildPersistentBashPreview(nonEmpty.lines, theme) : "";
-			if (!expanded && persistentPreview) return makeText(ctx.lastComponent, withBranch(`${text}${toolOutputDetailHint(theme, expanded)}\n${persistentPreview}`, theme));
-			if (!expanded && nonEmpty.total > 0) return makeText(ctx.lastComponent, withBranch(`${text}${toolOutputDetailHint(theme, expanded)}`, theme));
+			if (!expanded && mode === "preview") {
+				const previewLines = nonEmpty.lines.slice(0, bashCollapsedLimit());
+				const preview = previewLines.length > 0
+					? buildPreviewText(previewLines, false, theme, bashCollapsedLimit(), nonEmpty.total, (line) => theme.fg("dim", line || " "))
+					: "";
+				const suffix = toolOutputDetailHint(theme, expanded);
+				return makeText(ctx.lastComponent, withBranch(`${text}${suffix}${preview ? `\n${preview}` : ""}`, theme));
+			}
+			if (!expanded && mode === "opencode" && nonEmpty.total > 0) return makeText(ctx.lastComponent, withBranch(`${text}${toolOutputDetailHint(theme, expanded)}`, theme));
 			if (!expanded) return makeText(ctx.lastComponent, withBranch(text, theme));
 			const collapsed = bashCollapsedLimit();
 			if (rewrite) text += `\n${formatRtkRewriteDetails(rewrite, theme)}`;
@@ -6998,6 +7383,8 @@ export default function (pi: ExtensionAPI) {
 		name: "grep",
 		label: "grep",
 		description: grepTool.description,
+		promptSnippet: (grepTool as any).promptSnippet,
+		promptGuidelines: (grepTool as any).promptGuidelines,
 		parameters: grepTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return grepTool.execute(toolCallId, params, signal, onUpdate);
@@ -7038,6 +7425,8 @@ export default function (pi: ExtensionAPI) {
 		name: "find",
 		label: "find",
 		description: findTool.description,
+		promptSnippet: (findTool as any).promptSnippet,
+		promptGuidelines: (findTool as any).promptGuidelines,
 		parameters: findTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return findTool.execute(toolCallId, params, signal, onUpdate);
@@ -7089,6 +7478,8 @@ export default function (pi: ExtensionAPI) {
 		name: "ls",
 		label: "ls",
 		description: lsTool.description,
+		promptSnippet: (lsTool as any).promptSnippet,
+		promptGuidelines: (lsTool as any).promptGuidelines,
 		parameters: lsTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return lsTool.execute(toolCallId, params, signal, onUpdate);
@@ -7140,6 +7531,8 @@ export default function (pi: ExtensionAPI) {
 		name: "write",
 		label: "write",
 		description: writeTool.description,
+		promptSnippet: (writeTool as any).promptSnippet,
+		promptGuidelines: (writeTool as any).promptGuidelines,
 		parameters: writeTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate, _ctx) {
 			const fp = params.path ?? (params as any).file_path ?? "";
@@ -7255,6 +7648,8 @@ export default function (pi: ExtensionAPI) {
 		name: "edit",
 		label: "edit",
 		description: editTool.description,
+		promptSnippet: (editTool as any).promptSnippet,
+		promptGuidelines: (editTool as any).promptGuidelines,
 		parameters: editTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate, _ctx) {
 			const fp = params.path ?? (params as any).file_path ?? "";