pi-cc-extensions 0.8.29 → 0.8.31

package/extensions/claude-code-style.ts

@@ -1017,7 +1017,7 @@ function fixedEditorContextScore(
 }
 
 /** Summary markers used by Pi and ccstyle; unlike the trailing hint, these survive truncation. */
-const COLLAPSED_TOOL_SUMMARY = /^\s*(?:↳|└|⎿|●|✓|✗)/;
+const COLLAPSED_TOOL_SUMMARY = /^\s*(?:↳|└|⎿|●|✓|✗|…)/;
 /** fixedEditorContextScore max ≈ 100 + 2*(5+4+3+2); stop once we hit a near-perfect match. */
 const TOOL_CLICK_EARLY_EXIT_SCORE = 120;
 
@@ -1511,7 +1511,8 @@ function visibleMouseLine(tui: any, packet: SgrMousePacket): string {
 }
 
 function isCollapsedHintAtColumn(line: string, col: number): boolean {
-	const match = /(\([^()\n]* \/ click\)|click to show more)\s*$/.exec(line);
+	// Rich diff hints place "click to show more" inside a trailing parenthesis.
+	const match = /(\([^()\n]* \/ click\)|click to show more)(?=\)?\s*$)/.exec(line);
 	if (!match?.[1] || col <= 0) return false;
 	const start = visibleWidth(line.slice(0, match.index)) + 1;
 	return col >= start && col < start + visibleWidth(match[1]);
@@ -2575,19 +2576,25 @@ function createCcstyleTool(
 			}
 
 			if (options?.isPartial) {
-				return new Text(theme.fg("muted", "   ⎿ Pending…"), 0, 0);
+				return new Text(theme.fg("muted", "   ↳ Pending…"), 0, 0);
 			}
 
 			const isError = options?.isError || context?.isError;
 			setToolVisualState(context, isError ? "error" : "success");
 			const expanded = isToolExpanded(options, context);
+			const toolCallId = context?.toolCallId;
 			if (shouldRenderRichDiff(config.mode, toolName, Boolean(isError))) {
 				// Pass getter so Diff indicator / wrap / limits update on the next paint
 				// without recreating the tool result component.
 				const richResult = renderRichToolResult(
 					toolName,
 					result,
-					{ ...options, expanded },
+					{
+						...options,
+						expanded,
+						// Live hover state for the collapsed hint row (muted → text on hover).
+						isHovered: () => !!toolCallId && toolCallId === hoveredToolCallId,
+					},
 					theme,
 					context,
 					writeExecutionMetadata,
@@ -2629,7 +2636,6 @@ function createCcstyleTool(
 				);
 			}
 			if (context?.state) context.state.ccstyleIoView = undefined;
-			const toolCallId = context?.toolCallId;
 			let cachedWidth: number | undefined;
 			let cachedLine: string | undefined;
 			let cachedHoveredLine: string | undefined;
@@ -2997,13 +3003,26 @@ export default function (pi: ExtensionAPI, configOverride?: Partial<Config>) {
 	// The optional override keeps integration tests independent from the user's global config.
 	if (configOverride) config = normalizeConfig({ ...config, ...configOverride });
 	const writeExecutionMetadata = installWriteOverride(pi, new WriteExecutionMetadataStore());
-	const globalToolRendering = installGlobalToolRendering(writeExecutionMetadata);
-	const toolGrouping = installToolGrouping(() => config.mode === "on");
-	deactivateLegacyCompactionRendering();
-	const compactStyle: CompactStyleHooks = installCompactStyle(pi, {
-		getMode: () => config.mode,
-		getExcludeRenderers: () => config.excludeRenderers,
-	});
+	let installation:
+		| {
+				globalToolRendering: GlobalToolRenderPatch;
+				toolGrouping: ToolGroupingHooks;
+				compactStyle: CompactStyleHooks;
+		  }
+		| undefined;
+	const ensureTuiInstallation = (ctx: any) => {
+		if (ctx?.mode !== "tui" || !ctx?.hasUI) return undefined;
+		if (installation) return installation;
+		const globalToolRendering = installGlobalToolRendering(writeExecutionMetadata);
+		const toolGrouping = installToolGrouping(() => config.mode === "on");
+		deactivateLegacyCompactionRendering();
+		const compactStyle = installCompactStyle(pi, {
+			getMode: () => config.mode,
+			getExcludeRenderers: () => config.excludeRenderers,
+		});
+		installation = { globalToolRendering, toolGrouping, compactStyle };
+		return installation;
+	};
 
 	pi.registerCommand("ccstyle", {
 		description: "Configure Claude Code style, fixed editor, and rich diff options",
@@ -3020,11 +3039,15 @@ export default function (pi: ExtensionAPI, configOverride?: Partial<Config>) {
 		handler: async (args, ctx) => {
 			const arg = args.trim().toLowerCase();
 			if (!arg || arg === "panel") {
-				await showCcstylePanel(ctx, compactStyle, toolGrouping);
+				const hooks = ensureTuiInstallation(ctx);
+				if (hooks) await showCcstylePanel(ctx, hooks.compactStyle, hooks.toolGrouping);
+				else ctx.ui?.notify?.("/ccstyle requires TUI mode", "warning");
 				return;
 			}
 			if (arg === "on" || arg === "off" || arg === "compact") {
-				applyStyleMode(arg, ctx, compactStyle, toolGrouping);
+				const hooks = ensureTuiInstallation(ctx);
+				if (hooks) applyStyleMode(arg, ctx, hooks.compactStyle, hooks.toolGrouping);
+				else ctx.ui?.notify?.("/ccstyle requires TUI mode", "warning");
 				return;
 			}
 			if (arg === "status") {
@@ -3036,69 +3059,81 @@ export default function (pi: ExtensionAPI, configOverride?: Partial<Config>) {
 	});
 
 	pi.on("session_start", async (event, ctx) => {
-		toolGrouping.setTheme(ctx.ui.theme);
-		compactStyle?.onSessionStart(event, ctx);
+		const hooks = ensureTuiInstallation(ctx);
+		if (!hooks) return;
+		hooks.toolGrouping.setTheme(ctx.ui.theme);
+		hooks.compactStyle.onSessionStart(event, ctx);
 		pendingScrollMessages = 0;
 		assistantMessageActive = false;
 		ctx.ui.setStatus("ccstyle", undefined);
 		installToolMouseInteraction(ctx);
-		scheduleSessionRender(compactStyle.refresh);
+		scheduleSessionRender(hooks.compactStyle.refresh);
 	});
 
 	pi.on("session_compact", async (event, ctx) => {
-		toolGrouping.setTheme(ctx.ui.theme);
-		compactStyle?.onSessionCompact(event, ctx);
+		const hooks = ensureTuiInstallation(ctx);
+		if (!hooks) return;
+		hooks.toolGrouping.setTheme(ctx.ui.theme);
+		hooks.compactStyle.onSessionCompact(event, ctx);
 		// Compaction rebuilds the transcript without session_start. Rebind after
 		// other TUI extensions may have replaced the root input dispatcher.
 		installToolMouseInteraction(ctx);
-		scheduleSessionRender(compactStyle.refresh);
+		scheduleSessionRender(hooks.compactStyle.refresh);
 	});
 
 	pi.on("message_start", async (event) => {
-		notePendingScrollMessage(event?.message?.role);
+		if (installation) notePendingScrollMessage(event?.message?.role);
 	});
 
 	pi.on("message_update", async (event, ctx) => {
-		compactStyle?.onMessageUpdate(event, ctx);
-		if (event?.message?.role === "assistant") notePendingScrollMessage("assistant");
+		installation?.compactStyle.onMessageUpdate(event, ctx);
+		if (installation && event?.message?.role === "assistant") notePendingScrollMessage("assistant");
 	});
 
 	pi.on("message_end", async (event) => {
-		if (event?.message?.role === "assistant") assistantMessageActive = false;
+		if (installation && event?.message?.role === "assistant") assistantMessageActive = false;
 	});
 
 	pi.on("agent_start", async (event, ctx) => {
-		compactStyle?.onAgentStart(event, ctx);
+		installation?.compactStyle.onAgentStart(event, ctx);
 	});
 
 	pi.on("agent_end", async (event, ctx) => {
-		compactStyle?.onAgentEnd(event, ctx);
+		installation?.compactStyle.onAgentEnd(event, ctx);
 	});
 
 	pi.on("turn_start", async (event, ctx) => {
-		compactStyle?.onTurnStart(event, ctx);
+		installation?.compactStyle.onTurnStart(event, ctx);
 	});
 
 	pi.on("tool_execution_start", async (event, ctx) => {
-		toolGrouping.setTheme(ctx.ui.theme);
-		compactStyle?.onToolExecutionStart(event, ctx);
+		installation?.toolGrouping.setTheme(ctx.ui.theme);
+		installation?.compactStyle.onToolExecutionStart(event, ctx);
 	});
 
 	pi.on("tool_execution_update", async (event, ctx) => {
-		compactStyle?.onToolExecutionUpdate(event, ctx);
+		installation?.compactStyle.onToolExecutionUpdate(event, ctx);
 	});
 
 	pi.on("tool_execution_end", async (event, ctx) => {
-		compactStyle?.onToolExecutionEnd(event, ctx);
+		installation?.compactStyle.onToolExecutionEnd(event, ctx);
 	});
 
 	pi.on("session_shutdown", async (event, ctx) => {
-		compactStyle?.onSessionShutdown(event, ctx);
 		writeExecutionMetadata.clear();
+		const current = installation;
+		if (
+			!current ||
+			(globalThis as any)[GLOBAL_TOOL_RENDER_PATCH] !== current.globalToolRendering ||
+			!current.globalToolRendering.active
+		)
+			return;
+		current.compactStyle.onSessionShutdown(event, ctx);
 		teardownToolMouseInteraction();
-		deactivateGlobalToolRendering(globalToolRendering);
-		toolGrouping.shutdown();
+		deactivateGlobalToolRendering(current.globalToolRendering);
+		current.toolGrouping.shutdown();
 		deactivateLegacyCompactionRendering();
 		clearAllAnimations();
+		installation = undefined;
 	});
 }

package/extensions/index.ts

@@ -7,12 +7,14 @@ import piAliases from "./pi-aliases.ts";
 import piStartupHeader from "./pi-startup-header.ts";
 import sessionReference from "./session-reference.ts";
 import subagentNotification from "./subagent-notification.ts";
+import workingMessage from "./working-message.ts";
 
 export default function (pi: ExtensionAPI): void {
 	piAliases(pi);
 	piStartupHeader(pi);
 	claudeCodeStyle(pi);
 	subagentNotification(pi);
+	workingMessage(pi);
 	context(pi);
 	sessionReference(pi);
 	agentAutocomplete(pi);

package/extensions/subagent-notification.ts

@@ -84,31 +84,38 @@ export function formatSubagentNotificationLines(lines: string[], width: number):
 }
 
 export default function subagentNotificationExtension(pi: ExtensionAPI): void {
-	const prototype = CustomMessageComponent.prototype as any;
-	const host = globalThis as any;
-	const previous = host[PATCH_KEY] as Patch | undefined;
-	if (previous) previous.active = false;
-	const originalRender =
-		previous && prototype.render === previous.installedRender
-			? previous.originalRender
-			: prototype.render;
-	const patch = {
-		active: true,
-		prototype,
-		originalRender,
-		installedRender: undefined as any,
-	} satisfies Patch;
-	patch.installedRender = function (this: any, width: number): string[] {
-		const lines = originalRender.call(this, width);
-		if (!patch.active || this?.message?.customType !== "subagent-notification") return lines;
-		return formatSubagentNotificationLines(lines, width);
-	};
-	prototype.render = patch.installedRender;
-	host[PATCH_KEY] = patch;
+	let patch: Patch | undefined;
+
+	pi.on("session_start", async (_event, ctx) => {
+		if (patch || ctx?.mode !== "tui" || !ctx?.hasUI) return;
+		const prototype = CustomMessageComponent.prototype as any;
+		const host = globalThis as any;
+		const previous = host[PATCH_KEY] as Patch | undefined;
+		if (previous) previous.active = false;
+		const originalRender =
+			previous && prototype.render === previous.installedRender
+				? previous.originalRender
+				: prototype.render;
+		patch = {
+			active: true,
+			prototype,
+			originalRender,
+			installedRender: undefined as any,
+		};
+		const installed = patch;
+		installed.installedRender = function (this: any, width: number): string[] {
+			const lines = originalRender.call(this, width);
+			if (!installed.active || this?.message?.customType !== "subagent-notification") return lines;
+			return formatSubagentNotificationLines(lines, width);
+		};
+		prototype.render = installed.installedRender;
+		host[PATCH_KEY] = installed;
+	});
 
 	pi.on("session_shutdown", async () => {
-		if (!patch.active) return;
+		if (!patch?.active) return;
 		patch.active = false;
-		if (prototype.render === patch.installedRender) prototype.render = originalRender;
+		if (patch.prototype.render === patch.installedRender)
+			patch.prototype.render = patch.originalRender;
 	});
 }

package/extensions/tool-diff/diff-renderer.ts

@@ -121,6 +121,8 @@ interface DiffRenderOptions {
 	previousContent?: string;
 	fileExistedBeforeWrite?: boolean;
 	headerLabel?: string;
+	/** Live hover state for the collapsed hint row (muted → text on hover). */
+	isHovered?: () => boolean;
 	invalidate?: () => void;
 }
 
@@ -2289,6 +2291,7 @@ function applyLineLimit(
 	 * remainder so the collapse hint still reflects total hidden content.
 	 */
 	unprocessedLogicalRows = 0,
+	hovered = false,
 ): string[] {
 	const limit = resolveDiffDisplayLimit(expanded, maxCollapsedLines, maxExpandedLines);
 	const safeUnprocessed = Math.max(0, unprocessedLogicalRows);
@@ -2319,7 +2322,10 @@ function applyLineLimit(
 	return [
 		...shown.map((row) => clampDiffLineToWidth(row.text, width)),
 		renderDiffSpacerLine(width),
-		clampDiffLineToWidth(theme.fg(expanded ? "warning" : "muted", hintText), width),
+		clampDiffLineToWidth(
+			theme.fg(expanded ? "warning" : hovered ? "text" : "muted", hintText),
+			width,
+		),
 	];
 }
 
@@ -2403,6 +2409,7 @@ function createDiffRenderCache() {
 	let cachedExpanded: boolean | undefined;
 	let cachedMode: DiffPresentationMode | undefined;
 	let cachedConfigKey: string | undefined;
+	let cachedHovered: boolean | undefined;
 	let cachedLines: string[] | undefined;
 
 	return {
@@ -2411,13 +2418,15 @@ function createDiffRenderCache() {
 			expanded: boolean,
 			mode: DiffPresentationMode,
 			configKey: string,
+			hovered: boolean,
 		): string[] | undefined {
 			if (
 				cachedLines &&
 				cachedWidth === width &&
 				cachedExpanded === expanded &&
 				cachedMode === mode &&
-				cachedConfigKey === configKey
+				cachedConfigKey === configKey &&
+				cachedHovered === hovered
 			) {
 				return cachedLines;
 			}
@@ -2428,12 +2437,14 @@ function createDiffRenderCache() {
 			expanded: boolean,
 			mode: DiffPresentationMode,
 			configKey: string,
+			hovered: boolean,
 			lines: string[],
 		): string[] {
 			cachedWidth = width;
 			cachedExpanded = expanded;
 			cachedMode = mode;
 			cachedConfigKey = configKey;
+			cachedHovered = hovered;
 			cachedLines = lines;
 			return lines;
 		},
@@ -2442,6 +2453,7 @@ function createDiffRenderCache() {
 			cachedExpanded = undefined;
 			cachedMode = undefined;
 			cachedConfigKey = undefined;
+			cachedHovered = undefined;
 			cachedLines = undefined;
 		},
 	};
@@ -2500,7 +2512,8 @@ export function renderEditDiffResult(
 			const configKey = displayConfigCacheKey(live);
 			const safeWidth = normalizeDiffRenderWidth(width);
 			const mode = resolveDiffPresentationMode(live, safeWidth, canRenderSplitLayout(safeWidth));
-			const cached = cache.get(safeWidth, options.expanded, mode, configKey);
+			const hovered = options.isHovered?.() ?? false;
+			const cached = cache.get(safeWidth, options.expanded, mode, configKey, hovered);
 			if (cached) {
 				return cached;
 			}
@@ -2511,6 +2524,7 @@ export function renderEditDiffResult(
 					options.expanded,
 					mode,
 					configKey,
+					hovered,
 					clampDiffLinesToWidth(
 						renderSingleDiffRow(
 							buildDiffSummaryText(parsed.stats, safeWidth),
@@ -2565,6 +2579,7 @@ export function renderEditDiffResult(
 				parsed.stats.hunks,
 				theme,
 				unprocessedLogicalRows,
+				hovered,
 			);
 			const frame = renderDiffFrameLine(safeWidth, theme);
 			const renderedLines =
@@ -2573,7 +2588,7 @@ export function renderEditDiffResult(
 					: [...headerRows.map((row) => row.text), ...bodyWithLimit];
 
 			const clampedLines = clampDiffLinesToWidth(renderedLines, safeWidth);
-			return cache.set(safeWidth, options.expanded, mode, configKey, clampedLines);
+			return cache.set(safeWidth, options.expanded, mode, configKey, hovered, clampedLines);
 		},
 		invalidate: cache.invalidate,
 	};
@@ -2893,7 +2908,8 @@ export function renderWriteDiffResult(
 				: resolvedMode === "split"
 					? "unified"
 					: resolvedMode;
-			const cached = cache.get(safeWidth, options.expanded, mode, configKey);
+			const hovered = options.isHovered?.() ?? false;
+			const cached = cache.get(safeWidth, options.expanded, mode, configKey, hovered);
 			if (cached) {
 				return cached;
 			}
@@ -2914,6 +2930,7 @@ export function renderWriteDiffResult(
 					options.expanded,
 					mode,
 					configKey,
+					hovered,
 					clampDiffLinesToWidth(
 						[header, ...renderWriteOverwriteGuardRows(overwriteGuard, safeWidth, theme)],
 						safeWidth,
@@ -2939,6 +2956,7 @@ export function renderWriteDiffResult(
 					options.expanded,
 					mode,
 					configKey,
+					hovered,
 					clampDiffLinesToWidth(summaryRows, safeWidth),
 				);
 			}
@@ -2989,12 +3007,13 @@ export function renderWriteDiffResult(
 				data.hunkCount,
 				theme,
 				unprocessedLogicalRows,
+				hovered,
 			);
 			const frame = renderDiffFrameLine(safeWidth, theme);
 			const renderedLines =
 				mode === "unified" ? [header, frame, ...bodyWithLimit, frame] : [header, ...bodyWithLimit];
 			const finalLines = clampDiffLinesToWidth(renderedLines, safeWidth);
-			return cache.set(safeWidth, options.expanded, mode, configKey, finalLines);
+			return cache.set(safeWidth, options.expanded, mode, configKey, hovered, finalLines);
 		},
 		invalidate: cache.invalidate,
 	};

package/extensions/tool-diff/index.ts

@@ -47,7 +47,12 @@ export function renderRichToolResult(
 	if (toolName === "edit") {
 		return renderEditDiffResult(
 			result?.details,
-			{ expanded, filePath, invalidate: () => context?.invalidate?.() },
+			{
+				expanded,
+				filePath,
+				isHovered: options?.isHovered,
+				invalidate: () => context?.invalidate?.(),
+			},
 			displayConfig,
 			theme,
 			resultText(result),
@@ -69,6 +74,7 @@ export function renderRichToolResult(
 			filePath,
 			previousContent: metadata.previousContent,
 			fileExistedBeforeWrite: metadata.fileExistedBeforeWrite,
+			isHovered: options?.isHovered,
 			invalidate: () => context?.invalidate?.(),
 		},
 		displayConfig,

package/extensions/tool-diff/line-width-safety.ts

@@ -71,7 +71,7 @@ export function buildCollapsedDiffHintText(
 				: undefined;
 
 		const candidates = [
-			`… (${[remainingText, hiddenHunksText, "Ctrl+O to expand"].filter(Boolean).join(" • ")})`,
+			`… (${[remainingText, hiddenHunksText, "click to show more"].filter(Boolean).join(" • ")})`,
 			`… (${[remainingText, hiddenHunksText].filter(Boolean).join(" • ")})`,
 			`… (${[shortRemainingText, shortHiddenHunksText].filter(Boolean).join(" • ")})`,
 			options.hiddenHunks > 0

package/extensions/tool-grouping.ts

@@ -1,5 +1,5 @@
 import { AssistantMessageComponent, ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, truncateToWidth } from "@earendil-works/pi-tui";
+import { Container, Spacer, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { TOOL_LOADING_INTERVAL_MS, toolLoadingIcon } from "./tool-loading-icon.ts";
 import { sanitizeToolResultText } from "./tool-result-sanitize.ts";
 
@@ -94,6 +94,42 @@ function stripLeadingStatusIcon(line: string): string {
 	);
 }
 
+function stripBackgroundAnsi(line: string): string {
+	return line.replace(/\x1b\[(?:4[0-9]|10[0-7]|48(?:(?:;|:)[0-9]+)+|49)m/g, "");
+}
+
+function stripLeadingSpaces(line: string, count: number): string {
+	let offset = 0;
+	let removed = 0;
+	let ansi = "";
+	while (offset < line.length) {
+		const control = line.slice(offset).match(/^\x1b\[[0-?]*[ -/]*[@-~]/)?.[0];
+		if (control) {
+			ansi += control;
+			offset += control.length;
+			continue;
+		}
+		if (removed < count && line[offset] === " ") {
+			removed++;
+			offset++;
+			continue;
+		}
+		break;
+	}
+	return ansi + line.slice(offset);
+}
+
+function paddedBackgroundRow(theme: any, slot: string, content: string, width: number): string {
+	const innerWidth = Math.max(0, width - 2);
+	const clipped = truncateToWidth(stripBackgroundAnsi(content), innerWidth, "");
+	const row = ` ${clipped}${" ".repeat(Math.max(0, innerWidth - visibleWidth(clipped)))} `;
+	if (typeof theme?.bg !== "function") return row;
+	const bgAnsi =
+		theme.getBgAnsi?.(slot) ?? theme.bg(slot, "").match(/^\x1b\[[0-?]*[ -/]*[@-~]/)?.[0] ?? "";
+	const stable = bgAnsi ? row.replace(/\x1b\[(?:0)?m/g, (reset) => reset + bgAnsi) : row;
+	return theme.bg(slot, stable);
+}
+
 function oneLine(value: unknown, max = 96): string {
 	const text = sanitizeToolResultText(String(value ?? ""), 4096)
 		.replace(/\s+/g, " ")
@@ -275,12 +311,13 @@ export class ToolGroupComponent extends Container {
 		const lines = [
 			"",
 			truncateToWidth(
-				` ${fg(overallColor, statusIcon(overall))} ${label}: ${countText}${nameList} ${hint}`,
+				` ${fg(overallColor, "●")} ${label}: ${countText}${nameList} ${hint}`,
 				width,
 				"…",
 			),
 		];
 		const total = this.children.length;
+		const expandedLines: string[] = [];
 		for (let index = 0; index < total; index++) {
 			const tool = this.children[index];
 			const toolStatus = status(tool);
@@ -291,14 +328,14 @@ export class ToolGroupComponent extends Container {
 				const summary = toolSummary(tool);
 				lines.push(
 					truncateToWidth(
-						` ${fg("dim", branch)} ${fg(color, "●")} ${fg("toolTitle", summary.main)}${fg("dim", summary.detail)}`,
+						` ${fg("dim", branch)} ${fg(color, statusIcon(toolStatus))} ${fg("toolTitle", summary.main)}${fg("dim", summary.detail)}`,
 						width,
 						"…",
 					),
 				);
 				continue;
 			}
-			const rendered = visibleLines(tool.render(Math.max(1, width - 5)));
+			const rendered = visibleLines(tool.render(Math.max(1, width - 2)));
 			if (rendered.length) {
 				rendered[0] = stripLeadingStatusIcon(rendered[0])
 					.replace(/^ +/, "")
@@ -306,14 +343,27 @@ export class ToolGroupComponent extends Container {
 			}
 			const childLines = rendered.length ? rendered : [toolSummary(tool).main];
 			for (let lineIndex = 0; lineIndex < childLines.length; lineIndex++) {
+				const content =
+					lineIndex === 0 ? childLines[lineIndex] : stripLeadingSpaces(childLines[lineIndex], 2);
 				const prefix =
 					lineIndex === 0
-						? ` ${fg("dim", branch)} ${fg(color, "●")} `
-						: ` ${fg("dim", continuation)}  `;
-				lines.push(truncateToWidth(prefix + childLines[lineIndex], width, ""));
+						? `${fg("dim", branch)} ${fg(color, statusIcon(toolStatus))} `
+						: fg("dim", continuation);
+				expandedLines.push(prefix + content);
+			}
+		}
+		if (this.expanded) {
+			const backgroundSlot =
+				overall === "error"
+					? "toolErrorBg"
+					: overall === "pending"
+						? "toolPendingBg"
+						: "toolSuccessBg";
+			for (const line of expandedLines) {
+				lines.push(paddedBackgroundRow(theme, backgroundSlot, line, width));
 			}
+			lines.push(paddedBackgroundRow(theme, backgroundSlot, "", width));
 		}
-		lines.push("");
 		return lines;
 	}
 }

package/extensions/working-message.ts

@@ -0,0 +1,213 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const REFRESH_INTERVAL_MS = 1_000;
+/** Elapsed time is only shown once the turn has run this long. */
+const SHOW_TIMER_AFTER_MS = 3_000;
+
+function formatDuration(ms: number): string {
+	const totalSec = Math.floor(ms / 1000);
+	const hours = Math.floor(totalSec / 3600);
+	const minutes = Math.floor((totalSec % 3600) / 60);
+	const seconds = totalSec % 60;
+	if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+	if (minutes > 0) return `${minutes}m ${seconds}s`;
+	return `${seconds}s`;
+}
+
+function formatCount(value: number): string {
+	return new Intl.NumberFormat("en-US").format(value);
+}
+
+function estimateTextLength(message: any): number {
+	if (!Array.isArray(message?.content)) return 0;
+	return message.content.reduce(
+		(sum: number, block: any) =>
+			sum + (block?.type === "text" && typeof block.text === "string" ? block.text.length : 0),
+		0,
+	);
+}
+
+function textBlockLengths(message: any): number[] {
+	if (!Array.isArray(message?.content)) return [];
+	const lengths: number[] = [];
+	for (let index = 0; index < message.content.length; index++) {
+		const block = message.content[index];
+		if (block?.type === "text" && typeof block.text === "string") {
+			lengths[index] = block.text.length;
+		}
+	}
+	return lengths;
+}
+
+function outputUsage(message: any): number {
+	const value = Number(message?.usage?.output);
+	return Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+}
+
+/**
+ * Extend Pi's footer working row while preserving its spinner and "Working...":
+ * `⠋ Working... (↓ 1,234 tokens · 12s)`
+ *
+ * Live tokens use the same chars/4 estimate as pi-claude-code-ui, then switch to
+ * provider `usage.output` whenever the stream exposes an actual count.
+ */
+export default function (pi: ExtensionAPI): void {
+	let turnActive = false;
+	let agentStartTime = 0;
+	let turnStartTime = 0;
+	let responseLength = 0;
+	let responseTextBlockLengths: number[] = [];
+	let providerOutputTokens = 0;
+	let refreshTimer: ReturnType<typeof setTimeout> | null = null;
+	let lastMessage: string | null = null;
+	let activeCtx: { ui: any; hasUI: boolean } | null = null;
+
+	function tokenCount(): number {
+		return providerOutputTokens || Math.max(0, Math.round(responseLength / 4));
+	}
+
+	function setTextBlockLength(index: number, length: number): void {
+		const previous = responseTextBlockLengths[index] ?? 0;
+		responseTextBlockLengths[index] = Math.max(0, length);
+		responseLength = Math.max(0, responseLength + responseTextBlockLengths[index] - previous);
+	}
+
+	function resetResponseTracking(message?: any): void {
+		responseTextBlockLengths = message ? textBlockLengths(message) : [];
+		responseLength = message ? estimateTextLength(message) : 0;
+		providerOutputTokens = message ? outputUsage(message) : 0;
+	}
+
+	function updateProviderUsage(message: any): void {
+		const output = outputUsage(message);
+		if (output > 0) providerOutputTokens = output;
+	}
+
+	function buildWorkingMessage(): string {
+		const elapsed = Date.now() - (agentStartTime || turnStartTime);
+		const tokens = tokenCount();
+		const parts: string[] = [];
+		if (tokens > 0) parts.push(`↓ ${formatCount(tokens)} tokens`);
+		if (elapsed >= SHOW_TIMER_AFTER_MS || tokens > 0) parts.push(formatDuration(elapsed));
+		return parts.length ? `Working... (${parts.join(" · ")})` : "";
+	}
+
+	function restoreDefaultWorkingMessage(): void {
+		lastMessage = null;
+		if (!activeCtx?.hasUI) return;
+		try {
+			activeCtx.ui.setWorkingMessage();
+		} catch {
+			// Noop when the TUI is unavailable.
+		}
+	}
+
+	function syncWorkingMessage(force = false): void {
+		if (!activeCtx?.hasUI) return;
+		const next = buildWorkingMessage();
+		if (!next) {
+			if (force) restoreDefaultWorkingMessage();
+			return;
+		}
+		if (!force && next === lastMessage) return;
+		lastMessage = next;
+		try {
+			activeCtx.ui.setWorkingMessage(next);
+		} catch {
+			// Noop when the TUI is unavailable.
+		}
+	}
+
+	function scheduleRefreshTick(): void {
+		if (!turnActive || refreshTimer) return;
+		refreshTimer = setTimeout(() => {
+			refreshTimer = null;
+			syncWorkingMessage();
+			scheduleRefreshTick();
+		}, REFRESH_INTERVAL_MS);
+		refreshTimer.unref?.();
+	}
+
+	function stopRefreshLoop(): void {
+		if (!refreshTimer) return;
+		clearTimeout(refreshTimer);
+		refreshTimer = null;
+	}
+
+	function clearDisplay(): void {
+		stopRefreshLoop();
+		agentStartTime = 0;
+		turnStartTime = 0;
+		resetResponseTracking();
+		restoreDefaultWorkingMessage();
+	}
+
+	pi.on("before_agent_start", async () => {
+		if (!agentStartTime) agentStartTime = Date.now();
+	});
+
+	pi.on("turn_start", async (_event, ctx) => {
+		turnActive = true;
+		activeCtx = ctx;
+		turnStartTime = Date.now();
+		if (!agentStartTime) agentStartTime = turnStartTime;
+		resetResponseTracking();
+		syncWorkingMessage(true);
+		scheduleRefreshTick();
+	});
+
+	pi.on("message_update", async (event, ctx) => {
+		activeCtx = ctx;
+		const evt = event?.assistantMessageEvent;
+		if (!evt) return;
+
+		if (evt.type === "start") {
+			resetResponseTracking(evt.partial);
+		} else if (evt.type === "text_start") {
+			setTextBlockLength(evt.contentIndex, 0);
+			updateProviderUsage(evt.partial);
+		} else if (evt.type === "text_delta") {
+			setTextBlockLength(
+				evt.contentIndex,
+				(responseTextBlockLengths[evt.contentIndex] ?? 0) +
+					(typeof evt.delta === "string" ? evt.delta.length : 0),
+			);
+			updateProviderUsage(evt.partial);
+		} else if (evt.type === "text_end") {
+			setTextBlockLength(
+				evt.contentIndex,
+				typeof evt.content === "string" ? evt.content.length : 0,
+			);
+			updateProviderUsage(evt.partial);
+		} else if (evt.type === "done") {
+			resetResponseTracking(evt.message);
+		} else if (evt.type === "error") {
+			resetResponseTracking(evt.error);
+		} else {
+			updateProviderUsage(evt.partial);
+		}
+
+		syncWorkingMessage();
+		scheduleRefreshTick();
+	});
+
+	pi.on("turn_end", async (_event, ctx) => {
+		turnActive = false;
+		activeCtx = ctx;
+		stopRefreshLoop();
+		resetResponseTracking();
+		// No completion message: return immediately to Pi's default idle state.
+		restoreDefaultWorkingMessage();
+	});
+
+	pi.on("agent_end", async () => {
+		turnActive = false;
+		clearDisplay();
+	});
+
+	pi.on("session_shutdown", async () => {
+		turnActive = false;
+		clearDisplay();
+		activeCtx = null;
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-extensions",
-	"version": "0.8.29",
+	"version": "0.8.31",
 	"description": "A Pi productivity suite with Claude Code-style UI, structured questionnaires, context inspection, and agent/session references",
 	"type": "module",
 	"keywords": [