pi-compact-tools 0.6.1 → 0.7.7

package/extensions/compact-tools-layout.ts

@@ -117,28 +117,6 @@ export function renderToolCall(title: string, details: string | undefined, theme
 	});
 }
 
-export function wrapEditResult(component: Component, theme: Theme): Component {
-	return new CachedComponent((width) => {
-		const lines = component.render(Math.max(1, width - 3));
-		const first = lines.findIndex((line) => visibleWidth(line.trim()) > 0);
-		if (first < 0) return [];
-		const contentLines = lines.slice(first);
-		let commonIndent = Number.POSITIVE_INFINITY;
-		for (const line of contentLines) {
-			const plain = stripTerminalSequences(line);
-			if (plain.trim().length === 0) continue;
-			commonIndent = Math.min(commonIndent, plain.match(/^ */)?.[0].length ?? 0);
-			if (commonIndent === 0) break;
-		}
-		if (!Number.isFinite(commonIndent)) commonIndent = 0;
-		const prefix = theme.fg("border", " │ ");
-		return contentLines.map((line) => {
-			const content = sliceByColumn(line, commonIndent, Math.max(0, visibleWidth(line) - commonIndent), true);
-			return `${prefix}${content}`;
-		});
-	}, () => component.invalidate?.());
-}
-
 export function styleMultiline(text: string, style: (line: string) => string): string {
 	return normalizeLineEndings(text).split("\n").map(style).join("\n");
 }
@@ -151,6 +129,29 @@ export function renderOutput(output: string, theme: Theme, isError: boolean): Co
 	return prefixedText(styled, theme.fg("border", " │ "));
 }
 
+/** Render an edit's changed lines without unchanged context, hunk metadata, or result prose. */
+export function renderEditChanges(changes: string, theme: Theme): Component | undefined {
+	const normalized = normalizeLineEndings(changes).trimEnd();
+	if (!normalized) return undefined;
+	const styled = normalized.split("\n").map((line) =>
+		theme.fg(line.startsWith("+") ? "success" : "error", line)
+	).join("\n");
+	return prefixedText(styled, theme.fg("border", " │ "));
+}
+
+/** Limit a result preview by rendered rows while preserving the full source component for expansion. */
+export function limitComponentLines(component: Component, maximumLines: number, theme: Theme): Component {
+	return new CachedComponent((width) => {
+		const lines = component.render(width);
+		if (lines.length <= maximumLines) return lines;
+		const omitted = lines.length - maximumLines;
+		return [
+			...lines.slice(0, maximumLines),
+			theme.fg("border", " │ ") + theme.fg("borderAccent", `… ${omitted} more ${omitted === 1 ? "line" : "lines"}`),
+		];
+	}, () => component.invalidate?.());
+}
+
 export function renderArguments(args: ToolArgs, theme: Theme): Component {
 	const json = JSON.stringify(args, null, 2) ?? "{}";
 	const styled = styleMultiline(json, (line) => theme.fg("toolOutput", line));

package/extensions/compact-tools-progress.ts

@@ -0,0 +1,158 @@
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences, truncateToWidth } from "@earendil-works/pi-tui";
+import { colorizeRgb, interpolateRgb, themeColorRgb, type Rgb } from "./compact-tools-color.ts";
+import type { ToolArgs } from "./compact-tools-types.ts";
+
+const GLOW_INTERVAL_MS = 80;
+const WHITE: Rgb = { r: 255, g: 255, b: 255 };
+
+const TOOL_PROGRESS_MESSAGES: Readonly<Record<string, string>> = {
+	read: "Reading file…",
+	write: "Writing file…",
+	edit: "Editing file…",
+	bash: "Running command…",
+	powershell: "Running command…",
+	grep: "Searching text…",
+	find: "Finding files…",
+	ls: "Listing files…",
+};
+
+function humanizeToolName(toolName: string, args: ToolArgs): string {
+	const routedName = (toolName === "mcp" || toolName.startsWith("mcp__")) && typeof args.tool === "string"
+		? args.tool
+		: toolName;
+	const readableName = stripTerminalSequences(routedName)
+		.replace(/[\u0000-\u001f\u007f]/gu, " ")
+		.replace(/^mcp__/iu, "")
+		.replace(/[_-]mcp$/iu, "")
+		.replace(/([A-Z]+)([A-Z][a-z])/gu, "$1 $2")
+		.replace(/([a-z\d])([A-Z])/gu, "$1 $2")
+		.replace(/[_-]+/gu, " ")
+		.replace(/\s+/gu, " ")
+		.trim();
+	return truncateToWidth(readableName, 40, "…");
+}
+
+/** Keep the working row calm and private; invocation details remain in the tool card. */
+export function formatToolProgress(toolName: string, args: ToolArgs): string {
+	const builtInMessage = TOOL_PROGRESS_MESSAGES[toolName];
+	if (builtInMessage) return builtInMessage;
+	const displayName = humanizeToolName(toolName, args);
+	return displayName ? `Using ${displayName}…` : "Running tool…";
+}
+
+function glowRadius(length: number): number {
+	return Math.max(2, Math.min(8, Math.ceil(length / 4)));
+}
+
+/** Render a thinking-summary-colored label with a proportional white highlight sweeping left to right. */
+export function glowProgressMessage(message: string, frame: number, theme: Theme): string {
+	const characters = [...message];
+	if (characters.length === 0) return "";
+	const radius = glowRadius(characters.length);
+	const center = frame % (characters.length + radius * 2) - radius;
+	const base = themeColorRgb(theme, "thinkingMax");
+	if (!base) {
+		return characters.map((character, index) =>
+			theme.fg(Math.abs(index - center) < radius ? "mdHeading" : "thinkingMax", character)).join("");
+	}
+	return characters.map((character, index) => {
+		const distance = Math.abs(index - center);
+		const strength = Math.max(0, 1 - distance / radius);
+		return colorizeRgb(theme, interpolateRgb(base, WHITE, strength), character);
+	}).join("");
+}
+
+function createGlowFrames(message: string, theme: Theme): string[] {
+	const length = [...message].length;
+	if (length === 0) return [""];
+	return Array.from({ length: length + glowRadius(length) * 2 }, (_, frame) =>
+		glowProgressMessage(message, frame, theme));
+}
+
+/** Owns Pi's single working row so animation remains continuous across thinking and tool execution. */
+export class ProgressController {
+	private context: ExtensionContext | undefined;
+	private readonly activeTools = new Map<string, string>();
+	private message: string | undefined;
+	private frames: string[] = [];
+	private frame = 0;
+	private timer: ReturnType<typeof setInterval> | undefined;
+
+	constructor(pi: ExtensionAPI) {
+		pi.on("agent_start", () => this.setMessage("Thinking…"));
+		pi.on("message_update", (event) => {
+			const type = event.assistantMessageEvent.type;
+			if (type === "thinking_start" || type === "thinking_delta") this.setMessage("Thinking…");
+			else if (type === "text_start" || type === "text_delta") this.setMessage("Responding…");
+			else if (type === "toolcall_start" || type === "toolcall_delta") this.setMessage("Preparing tools…");
+		});
+		pi.on("tool_execution_start", (event) => {
+			const message = formatToolProgress(event.toolName, event.args ?? {});
+			this.activeTools.set(event.toolCallId, message);
+			this.setMessage(message);
+		});
+		pi.on("tool_execution_end", (event) => {
+			this.activeTools.delete(event.toolCallId);
+			const remaining = [...this.activeTools.values()].at(-1);
+			this.setMessage(remaining ?? "Processing results…");
+		});
+		pi.on("agent_end", () => {
+			this.activeTools.clear();
+			this.clearMessage();
+		});
+	}
+
+	bind(ctx: ExtensionContext): void {
+		this.stopAnimation();
+		this.context = ctx;
+		this.activeTools.clear();
+		this.message = undefined;
+		this.frames = [];
+		this.frame = 0;
+		ctx.ui.setWorkingVisible(true);
+		ctx.ui.setWorkingIndicator({ frames: [] });
+	}
+
+	dispose(): void {
+		this.stopAnimation();
+		this.activeTools.clear();
+		this.context?.ui.setWorkingMessage();
+		this.context?.ui.setWorkingIndicator();
+		this.message = undefined;
+		this.frames = [];
+		this.context = undefined;
+	}
+
+	private setMessage(message: string): void {
+		if (!this.context || (this.message === message && this.timer)) return;
+		this.message = message;
+		this.frames = createGlowFrames(message, this.context.ui.theme);
+		this.frame = 0;
+		this.renderMessage();
+		if (this.timer) return;
+		this.timer = setInterval(() => {
+			this.frame++;
+			this.renderMessage();
+		}, GLOW_INTERVAL_MS);
+		this.timer.unref?.();
+	}
+
+	private renderMessage(): void {
+		if (!this.message || !this.context || this.frames.length === 0) return;
+		this.context.ui.setWorkingMessage(this.frames[this.frame % this.frames.length]);
+	}
+
+	private clearMessage(): void {
+		this.stopAnimation();
+		this.message = undefined;
+		this.frames = [];
+		this.frame = 0;
+		this.context?.ui.setWorkingMessage();
+	}
+
+	private stopAnimation(): void {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = undefined;
+	}
+}

package/extensions/compact-tools-runtime.ts

@@ -9,32 +9,26 @@ import type {
 } from "./compact-tools-types.ts";
 
 const MAX_TRACKED_ROWS = 2_000;
-const SPINNING_ROWS_KEY = Symbol.for("pi.compact-tools.spinning-rows");
+const INDICATOR_INTERVAL_MS = 45;
 const EXECUTION_TIMINGS_KEY = Symbol.for("pi.compact-tools.execution-timings");
 
 type ExecutionTiming = { startedAt: number; endedAt?: number };
-type TrackedRow = { state: RowState; name: CompactToolName; invalidate: () => void };
 type TimedExecute = (...args: any[]) => Promise<AgentToolResult<unknown>>;
 type SharedState = typeof globalThis & {
-	[SPINNING_ROWS_KEY]?: Set<RowState>;
 	[EXECUTION_TIMINGS_KEY]?: Map<string, ExecutionTiming>;
 };
 
 export class ToolRuntime {
 	private configValue = DEFAULT_CONFIG;
 	private configRevision: object = {};
-	private animateRows = false;
-	private readonly spinningRows = new Set<RowState>();
 	private readonly executionTimings: Map<string, ExecutionTiming>;
-	private readonly trackedRows = new Map<string, TrackedRow>();
+	private readonly indicatorInvalidators = new Map<string, () => void>();
+	private indicatorFrame = 0;
+	private indicatorTimer: ReturnType<typeof setInterval> | undefined;
 
 	constructor() {
 		const shared = globalThis as SharedState;
-		for (const state of shared[SPINNING_ROWS_KEY] ?? []) {
-			if (state.timer) clearInterval(state.timer);
-		}
 		this.executionTimings = shared[EXECUTION_TIMINGS_KEY] ?? new Map<string, ExecutionTiming>();
-		shared[SPINNING_ROWS_KEY] = this.spinningRows;
 		shared[EXECUTION_TIMINGS_KEY] = this.executionTimings;
 	}
 
@@ -42,14 +36,8 @@ export class ToolRuntime {
 		return this.configValue;
 	}
 
-	get animatesRows(): boolean {
-		return this.animateRows;
-	}
-
-	configure(config: CompactToolsConfig, animateRows: boolean): void {
-		this.reset(false);
+	configure(config: CompactToolsConfig): void {
 		this.configValue = config;
-		this.animateRows = animateRows;
 		this.configRevision = {};
 	}
 
@@ -58,40 +46,35 @@ export class ToolRuntime {
 	}
 
 	reset(clearTimings: boolean): void {
-		for (const state of this.spinningRows) this.stopSpinner(state);
-		this.trackedRows.clear();
+		this.stopIndicators();
 		if (clearTimings) this.clearTimings();
 	}
 
-	track(ctx: RenderContext, name: CompactToolName, state: RowState): void {
-		this.trackedRows.delete(ctx.toolCallId);
-		this.trackedRows.set(ctx.toolCallId, { state, name, invalidate: ctx.invalidate });
-		if (this.trackedRows.size <= MAX_TRACKED_ROWS) return;
-		const oldest = this.trackedRows.keys().next().value;
-		if (oldest !== undefined) this.trackedRows.delete(oldest);
-	}
-
-	toggleTrackedRows(): "expanded" | "collapsed" | undefined {
-		const rows: TrackedRow[] = [];
-		for (const row of this.trackedRows.values()) {
-			if (this.configValue.auto_compact[row.name] && row.state.hasResult) rows.push(row);
+	syncIndicator(toolCallId: string, running: boolean, invalidate: () => void): number {
+		if (!running) {
+			this.removeIndicator(toolCallId);
+			return 0;
 		}
-		if (rows.length === 0) return undefined;
-		const expand = rows.some(({ state }) => !state.expanded);
-		for (const { state, invalidate } of rows) {
-			state.expanded = expand;
-			invalidate();
+		this.indicatorInvalidators.set(toolCallId, invalidate);
+		if (!this.indicatorTimer) {
+			this.indicatorTimer = setInterval(() => {
+				this.indicatorFrame++;
+				for (const requestRender of this.indicatorInvalidators.values()) requestRender();
+			}, INDICATOR_INTERVAL_MS);
+			this.indicatorTimer.unref?.();
 		}
-		return expand ? "expanded" : "collapsed";
+		return this.indicatorFrame;
 	}
 
 	syncExpansion(state: RowState, hostExpanded: boolean, name: CompactToolName): boolean {
-		const initialized = this.initializeExpansion(state, name);
-		if (initialized || state.lastHostExpanded === undefined) {
-			state.lastHostExpanded = hostExpanded;
-		} else if (state.lastHostExpanded !== hostExpanded) {
+		const initialized = this.initializeExpansion(state, name, hostExpanded);
+		if (!initialized && state.lastHostExpanded !== hostExpanded) {
 			state.lastHostExpanded = hostExpanded;
-			state.expanded = !state.expanded;
+			state.expanded = hostExpanded;
+			// A non-auto-compacted row collapses back to its bounded preview. Hiding it
+			// here removes the clicked row from under the pointer, so the next click can
+			// accidentally hit the Thinking block that moved into the same coordinates.
+			state.preview = !hostExpanded && !this.configValue.auto_compact[name];
 		}
 		return state.expanded ?? false;
 	}
@@ -111,8 +94,8 @@ export class ToolRuntime {
 		const started = !ctx.argsComplete || ctx.executionStarted || running;
 		if (started && state.startedAt === undefined) state.startedAt = Date.now();
 		if (finished && state.startedAt !== undefined && state.endedAt === undefined) state.endedAt = Date.now();
+		if (finished) this.removeIndicator(ctx.toolCallId);
 		this.persistTiming(state, ctx.toolCallId);
-		this.syncSpinner(state, running, ctx.invalidate);
 		return state;
 	}
 
@@ -133,37 +116,28 @@ export class ToolRuntime {
 		};
 	}
 
-	private initializeExpansion(state: RowState, name: CompactToolName): boolean {
-		if (state.configRevision === this.configRevision) return false;
-		state.configRevision = this.configRevision;
-		state.expanded = !this.configValue.auto_compact[name];
-		return true;
+	private removeIndicator(toolCallId: string): void {
+		this.indicatorInvalidators.delete(toolCallId);
+		if (this.indicatorInvalidators.size > 0 || !this.indicatorTimer) return;
+		clearInterval(this.indicatorTimer);
+		this.indicatorTimer = undefined;
+		this.indicatorFrame = 0;
 	}
 
-	private stopSpinner(state: RowState): void {
-		if (state.timer) clearInterval(state.timer);
-		state.timer = undefined;
-		this.spinningRows.delete(state);
+	private stopIndicators(): void {
+		if (this.indicatorTimer) clearInterval(this.indicatorTimer);
+		this.indicatorTimer = undefined;
+		this.indicatorInvalidators.clear();
+		this.indicatorFrame = 0;
 	}
 
-	private syncSpinner(state: RowState, running: boolean, invalidate: () => void): void {
-		const spinner = this.configValue.spinner;
-		if (!running || !this.animateRows || spinner.frames.length < 2) {
-			this.stopSpinner(state);
-			return;
-		}
-		if (state.timer) return;
-		state.frame ??= 0;
-		state.timer = setInterval(() => {
-			state.frame = ((state.frame ?? 0) + 1) % spinner.frames.length;
-			try {
-				invalidate();
-			} catch {
-				this.stopSpinner(state);
-			}
-		}, spinner.intervalMs);
-		state.timer.unref?.();
-		this.spinningRows.add(state);
+	private initializeExpansion(state: RowState, name: CompactToolName, hostExpanded = false): boolean {
+		if (state.configRevision === this.configRevision) return false;
+		state.configRevision = this.configRevision;
+		state.lastHostExpanded = hostExpanded;
+		state.expanded = hostExpanded;
+		state.preview = !hostExpanded && !this.configValue.auto_compact[name];
+		return true;
 	}
 
 	private restoreTiming(state: RowState, toolCallId: string): boolean {

package/extensions/compact-tools-thinking.ts

@@ -17,7 +17,7 @@ export type ThinkingPhase = "summary" | "detail" | "summary-after-detail" | "hid
 type ThinkingRenderOptions = {
 	styleSummary?: (summary: string, sectionIndex: number) => string;
 	styleDetailPrefix?: (prefix: string) => string;
-	controls?: string;
+	controls?: string | ((hasDetail: boolean) => string | undefined);
 	styleControlPrefix?: (prefix: string) => string;
 };
 
@@ -56,7 +56,7 @@ function plainSummary(line: string): string {
 
 type ThinkingSection = { summary: string; detail: string };
 
-function splitThinkingSections(markdown: string, includeDetail: boolean): ThinkingSection[] {
+function splitThinkingSections(markdown: string): ThinkingSection[] {
 	const normalized = markdown.includes("\r") ? markdown.replace(/\r\n?/gu, "\n") : markdown;
 	const lines = normalized.split("\n");
 	let first = -1;
@@ -73,7 +73,7 @@ function splitThinkingSections(markdown: string, includeDetail: boolean): Thinki
 	let detail: string[] = [];
 	let inFence = false;
 	const flush = () => {
-		sections.push({ summary, detail: includeDetail ? detail.join("\n").trim() : "" });
+		sections.push({ summary, detail: detail.join("\n").trim() });
 		detail = [];
 	};
 	for (let index = first + 1; index < lines.length; index++) {
@@ -89,7 +89,7 @@ function splitThinkingSections(markdown: string, includeDetail: boolean): Thinki
 				continue;
 			}
 		}
-		if (includeDetail) detail.push(line);
+		detail.push(line);
 		if (fence) inFence = !inFence;
 	}
 	flush();
@@ -135,35 +135,59 @@ function hardBreak(lines: string[]): string {
 	return lines.map((line, index) => (index < lines.length - 1 ? `${line}  ` : line)).join("\n");
 }
 
-/** Display-only transformation; the original thinking remains unchanged in session/model context. */
-export function renderThinkingView(
-	markdown: string,
+function sectionsHaveDetail(sections: readonly ThinkingSection[]): boolean {
+	return sections.some(({ detail }) => detail.length > 0);
+}
+
+export function hasThinkingDetail(markdown: string): boolean {
+	return sectionsHaveDetail(splitThinkingSections(markdown));
+}
+
+function renderThinkingSections(
+	sections: readonly ThinkingSection[],
 	view: ThinkingView,
 	availableWidth: number,
 	options: ThinkingRenderOptions = {},
 ): string {
 	if (view === "hidden") return "Thinking...";
-	const controls = options.controls ?? "ctrl+t toggle • click to hide";
+	const controls = options.controls ?? ((hasDetail: boolean) =>
+		hasDetail ? "ctrl+t toggle • click to hide" : undefined);
 	const styleControlPrefix = options.styleControlPrefix ?? ((prefix: string) => prefix);
-	return splitThinkingSections(markdown, view === "detail")
+	return sections
 		.map(({ summary, detail }, sectionIndex) => {
 			const fittedSummary = stripTerminalSequences(
 				truncateToWidth(summary, Math.max(1, availableWidth), "…"),
 			);
 			const title = options.styleSummary?.(fittedSummary, sectionIndex) ?? fittedSummary;
-			const controlLines = wrapTextWithAnsi(controls, Math.max(1, availableWidth - 3)).map(
-				(line, index) => `${index === 0 ? styleControlPrefix("└─ ") : "   "}${line}`,
-			);
+			const sectionControls = view === "detail"
+				? typeof controls === "function" ? controls(detail.length > 0) : controls
+				: undefined;
+			const controlLines = sectionControls
+				? wrapTextWithAnsi(sectionControls, Math.max(1, availableWidth - 3)).map(
+						(line, index) => `${index === 0 ? styleControlPrefix("└─ ") : "   "}${line}`,
+					)
+				: [];
 			if (view === "detail" && detail) {
 				const styleDetailPrefix = options.styleDetailPrefix ?? ((prefix: string) => prefix);
 				const connector = `${styleDetailPrefix("│")}  `;
-				return `${title}  \n${connector}\n${compactDetail(detail, availableWidth, styleDetailPrefix)}\n${hardBreak(controlLines)}`;
+				const detailOutput = `${title}  \n${connector}\n${compactDetail(detail, availableWidth, styleDetailPrefix)}`;
+				return controlLines.length > 0 ? `${detailOutput}\n${hardBreak(controlLines)}` : detailOutput;
 			}
 			return hardBreak([title, ...controlLines]);
 		})
 		.join("\n\n");
 }
 
+/** Display-only transformation; the original thinking remains unchanged in session/model context. */
+export function renderThinkingView(
+	markdown: string,
+	view: ThinkingView,
+	availableWidth: number,
+	options: ThinkingRenderOptions = {},
+): string {
+	return renderThinkingSections(splitThinkingSections(markdown), view, availableWidth, options);
+}
+
 function getInitialThinkingPhase(): ThinkingPhase {
 	try {
 		const settings = JSON.parse(readFileSync(join(getAgentDir(), "settings.json"), "utf8")) as {
@@ -175,108 +199,43 @@ function getInitialThinkingPhase(): ThinkingPhase {
 	}
 }
 
-export function isThinkingStreamEvent(eventType: string): boolean {
-	return eventType === "thinking_start" || eventType === "thinking_delta";
-}
-
-const SHIMMER_FRAME_INTERVAL_MS = 80;
-
-function shimmer(summary: string, theme: Theme, startedAt: number): string {
-	const characters = [...summary];
-	if (characters.length === 0) return summary;
-	const sweepTail = 5;
-	// Each logical section receives its own start time. The highlight therefore
-	// enters at its first character instead of inheriting another section's
-	// wall-clock phase.
-	const elapsed = Math.max(0, Date.now() - startedAt);
-	const center = Math.floor(elapsed / SHIMMER_FRAME_INTERVAL_MS) % (characters.length + sweepTail);
-	let currentColor: Parameters<Theme["fg"]>[0] | undefined;
-	let chunk = "";
-	let output = "";
-	for (let index = 0; index < characters.length; index++) {
-		const distance = Math.abs(index - center);
-		// Stay entirely in the sky-blue family: the active baseline is blue,
-		// and the sweep fades through light blue into a near-white core.
-		const color = distance === 0
-			? "userMessageText"
-			: distance === 1
-				? "text"
-				: distance === 2
-					? "thinkingMax"
-					: "thinkingXhigh";
-		if (currentColor !== undefined && color !== currentColor) {
-			output += theme.fg(currentColor, theme.bold(chunk));
-			chunk = "";
-		}
-		currentColor = color;
-		chunk += characters[index];
-	}
-	return currentColor === undefined ? output : output + theme.fg(currentColor, theme.bold(chunk));
-}
-
 export class ThinkingCycleController {
 	private phase: ThinkingPhase = "summary";
 	private unsubscribe: (() => void) | undefined;
 	private theme: Theme | undefined;
-	private thinkingStreamActive = false;
+	private hasToggleableThinking = false;
 	private refreshThinking: (() => void) | undefined;
-	private readonly summarySweepStartedAt = new Map<number, number>();
 
 	constructor(pi: ExtensionAPI) {
-		pi.on("message_start", () => this.resetSweep());
-		pi.on("message_update", (event) => {
-			// `context.isStreaming` describes the whole assistant message. Tool-call
-			// argument streaming therefore remains true after thinking has ended.
-			// Track the actual provider event so the sweep ends on thinking_end.
-			const eventType = event.assistantMessageEvent.type;
-			if (eventType === "thinking_start") this.summarySweepStartedAt.clear();
-			this.thinkingStreamActive = isThinkingStreamEvent(eventType);
-		});
-		pi.on("message_end", () => this.resetSweep());
-		pi.on("tool_call", () => this.resetSweep());
-
 		pi.registerMarkdownTransformer((markdown, context) => {
 			if (context.messageType !== "assistant-thinking") return markdown;
+			const sections = splitThinkingSections(markdown);
+			this.hasToggleableThinking ||= sectionsHaveDetail(sections);
 			const theme = this.theme;
 			const detailTextPrefix = theme?.getFgAnsi("thinkingText");
-			return renderThinkingView(markdown, thinkingViewForPhase(this.phase), context.availableWidth, {
-				styleSummary: theme
-					? context.isStreaming && this.thinkingStreamActive
-						? (summary, sectionIndex) => {
-								let startedAt = this.summarySweepStartedAt.get(sectionIndex);
-								if (startedAt === undefined) {
-									startedAt = Date.now();
-									this.summarySweepStartedAt.set(sectionIndex, startedAt);
-								}
-								return shimmer(summary, theme, startedAt);
-							}
-						: (summary) => theme.fg("thinkingMax", theme.bold(summary))
-					: undefined,
+			return renderThinkingSections(sections, thinkingViewForPhase(this.phase), context.availableWidth, {
+				styleSummary: theme ? (summary) => theme.fg("thinkingMax", theme.bold(summary)) : undefined,
 				// border styling resets the foreground; resume detail gray immediately.
 				styleDetailPrefix: theme && detailTextPrefix
 					? (prefix) => theme.fg("border", prefix) + detailTextPrefix
 					: undefined,
 				controls: theme
-					? theme.fg(
-							"borderAccent",
-							`${theme.italic("ctrl+t")} toggle • ${theme.italic("click")} to hide`,
-						)
+					? (hasDetail) => hasDetail
+						? theme.fg(
+								"borderAccent",
+								`${theme.italic("ctrl+t")} toggle • ${theme.italic("click")} to hide`,
+							)
+						: undefined
 					: undefined,
 				styleControlPrefix: theme ? (prefix) => theme.fg("border", prefix) : undefined,
 			});
 		});
 	}
 
-	private resetSweep(): void {
-		this.thinkingStreamActive = false;
-		this.summarySweepStartedAt.clear();
-	}
-
 	bind(ctx: ExtensionContext): void {
 		this.unsubscribe?.();
 		this.theme = ctx.ui.theme;
-		this.thinkingStreamActive = false;
-		this.summarySweepStartedAt.clear();
+		this.hasToggleableThinking = false;
 		// Match Pi's persisted host visibility after startup or /reload. When the
 		// host is hidden, Markdown transformers are not invoked at all. Pi wraps
 		// this label in thinkingText, so an inner thinkingMax span is required to
@@ -294,6 +253,9 @@ export class ThinkingCycleController {
 			// Kitty-capable macOS terminals report held keys as repeat events. Treating
 			// those as presses can skip detail before the user sees it.
 			if (input === "release" || input === "repeat") return { consume: true };
+			// With no provider-supplied detail, leave Ctrl+T to Pi's normal
+			// visible/hidden toggle instead of inserting an identical detail phase.
+			if (!this.hasToggleableThinking) return undefined;
 			this.phase = nextThinkingPhase(this.phase);
 			if (this.phase === "detail" || this.phase === "summary-after-detail") {
 				// Visible-to-visible transitions are owned by this extension. Rebuild the
@@ -312,8 +274,7 @@ export class ThinkingCycleController {
 		this.unsubscribe?.();
 		this.unsubscribe = undefined;
 		this.refreshThinking = undefined;
-		this.thinkingStreamActive = false;
-		this.summarySweepStartedAt.clear();
+		this.hasToggleableThinking = false;
 		this.theme = undefined;
 	}
 }

package/extensions/compact-tools-types.ts

@@ -1,5 +1,4 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { Component } from "@earendil-works/pi-tui";
 
 export const SUPPORTED_TOOLS = ["read", "write", "edit", "bash", "powershell", "grep", "find", "ls"] as const;
 export const SUPPORTED_TOOL_SET = new Set<string>(SUPPORTED_TOOLS);
@@ -12,22 +11,26 @@ export type BuiltInDefinition = ToolDefinition<any, any, any>;
 export interface CompactToolsConfig {
 	tools: CompactToolName[];
 	auto_compact: Record<CompactToolName, boolean>;
-	spinner: {
-		frames: string[];
-		intervalMs: number;
-	};
+	previewLines: number;
 }
 
 export interface RowState {
 	expanded?: boolean;
+	preview?: boolean;
 	hasResult?: boolean;
 	lastHostExpanded?: boolean;
 	configRevision?: object;
-	frame?: number;
 	startedAt?: number;
 	endedAt?: number;
-	timer?: ReturnType<typeof setInterval>;
-	originalResultComponent?: Component;
+	resultLineSummary?: string;
+	resultLineSummaryComputed?: boolean;
+	lastResultContent?: unknown;
+	lastResultDetails?: unknown;
+	lastResultPartial?: boolean;
+	lastResultExpanded?: boolean;
+	lastResultPreview?: boolean;
+	lastResultError?: boolean;
+	lastResultConfigRevision?: object;
 }
 
 type BaseRenderContext = Parameters<NonNullable<BuiltInDefinition["renderCall"]>>[2];