@agnishc/edb-global-footer 0.8.1 → 0.10.3

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.10.3] - 2026-05-15
+
+## [0.9.0] - 2026-05-15
+
+### Added
+- **Working indicator** (`src/workingIndicator.ts`) — animated status line shown while the agent is processing
+  - Claude-style spinner frames (`· ✢ ✳ ✶ ✻ ✽`) at 150ms
+  - 162 rotating verbs ("Reticulating...", "Boondoggling...") with 2s rotation
+  - Per-character shimmer effect — accent color sweep across the verb text
+  - Live elapsed timer ticking every second
+  - Tool suffix with Nerd Font icon + rotating witty label (5–10 phrases per tool, 2s rotation)
+  - Completion message on agent end: `✓ · Crystallized · 23s`, shown for 3s then cleared
+  - Full tool coverage: `bash`, `read`, `write`, `edit`, `ls`, `find`, `grep`, `TaskCreate`, `TaskList`, `TaskGet`, `TaskUpdate`, `TaskOutput`, `TaskStop`, `Agent`, `get_subagent_result`, `steer_subagent`, `ask_user`
+
+### Changed
+- Cache read/write indicators now use Nerd Font icons (`󰩺` / `󱀚`) instead of plain `R`/`W` text, with `R`/`W` fallback when Nerd Fonts are unavailable
+
+## [0.8.2] - 2026-05-11
+
 ## [0.8.1] - 2026-05-11
 
 ## [0.6.0] - 2026-05-11

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agnishc/edb-global-footer",
-	"version": "0.8.1",
+	"version": "0.10.3",
 	"description": "Pi extension: two-line status footer showing path, git branch, token usage, and model",
 	"keywords": [
 		"pi-package",

package/src/footer.ts

@@ -8,15 +8,39 @@ import {
 	sanitizeStatusText,
 	shortenPath,
 } from "./format";
+import { iconCacheRead, iconCacheWrite, iconGit, iconThink, withIcon } from "./icons";
+import { formatTps } from "./tps";
 import type { GitStatus } from "./types";
 
+// ── Status blacklist ──────────────────────────────────────────────────────────
+// Keys in this set will not be shown in the extension statuses line (line 3).
+// Common uses:
+//   - "extmgr" - package manager status ("15 pkgs • auto update off")
+//   - Keys for extensions whose status you want to hide
+const STATUS_KEY_BLACKLIST = new Set<string>(["extmgr"]);
+
+// ── Live state types ───────────────────────────────────────────────────────────
+
+interface TpsState {
+	isStreaming: boolean;
+	tps: number;
+	lastOutputTokens: number;
+	lastInputTokens: number;
+}
+
 // ── Footer renderer factory ────────────────────────────────────────────────────
 
 /**
  * Returns the footer descriptor object accepted by ctx.ui.setFooter().
  * Encapsulates all render logic for the two-line status footer.
  */
-export function createFooterRenderer(ctx: any, getGitStatus: () => GitStatus | null, requestRender: () => void) {
+export function createFooterRenderer(
+	ctx: any,
+	getGitStatus: () => GitStatus | null,
+	requestRender: () => void,
+	hasNerdFonts: boolean,
+	getTpsState: () => TpsState,
+) {
 	return (_tui: any, theme: any, footerData: any) => {
 		const unsub = footerData.onBranchChange(() => {
 			requestRender();
@@ -29,35 +53,45 @@ export function createFooterRenderer(ctx: any, getGitStatus: () => GitStatus | n
 			invalidate() {},
 			render(width: number): string[] {
 				const sep = theme.fg("dim", " · ");
+				const groupSep = theme.fg("dim", " | ");
 				const sessionName = ctx.sessionManager.getSessionName();
 				const gitStatus = getGitStatus();
+				const tpsState = getTpsState();
 
-				// ── Line 1: path · branch · session name ──────────────────────
-				const locationParts: string[] = [theme.fg("accent", shortenPath(ctx.cwd))];
+				// ── Line 1: path · branch | session name ─────────────────────
+				const leftParts: string[] = [theme.fg("accent", shortenPath(ctx.cwd))];
 
 				if (gitStatus?.branch) {
 					let gitText = theme.fg(gitStatus.dirty ? "warning" : "success", gitStatus.branch);
 					if (gitStatus.dirty) gitText += theme.fg("warning", " *");
 					if (gitStatus.ahead) gitText += theme.fg("success", ` ↑${gitStatus.ahead}`);
 					if (gitStatus.behind) gitText += theme.fg("error", ` ↓${gitStatus.behind}`);
-					locationParts.push(gitText);
+					leftParts.push(gitText);
 				} else {
 					const branch = footerData.getGitBranch();
-					if (branch) locationParts.push(theme.fg("muted", branch));
+					if (branch) {
+						const branchText = hasNerdFonts ? withIcon(iconGit, branch) : branch;
+						leftParts.push(theme.fg("muted", branchText));
+					}
 				}
 
-				if (sessionName) locationParts.push(theme.fg("muted", sessionName));
-				const locationLine = truncateToWidth(locationParts.join(sep), width);
+				const rightParts: string[] = [];
+				if (sessionName) rightParts.push(theme.fg("dim", theme.italic(sessionName)));
+				const locationLine = renderFooterLine(width, leftParts.join(sep), rightParts.join(sep));
+
+				// ── Line 2: token stats · tps · model ────────────────────────
 
-				// ── Line 2: token stats · model ───────────────────────────────
+				// Aggregate token stats from all persisted entries
 				let totalInput = 0;
 				let totalOutput = 0;
 				let totalCacheRead = 0;
 				let totalCacheWrite = 0;
 				let totalCost = 0;
+
 				for (const entry of ctx.sessionManager.getEntries()) {
 					if (entry.type === "message" && entry.message.role === "assistant") {
 						const msg = entry.message as AssistantMessage;
+						if (msg.stopReason === "error" || msg.stopReason === "aborted") continue;
 						totalInput += msg.usage.input;
 						totalOutput += msg.usage.output;
 						totalCacheRead += msg.usage.cacheRead;
@@ -66,51 +100,89 @@ export function createFooterRenderer(ctx: any, getGitStatus: () => GitStatus | n
 					}
 				}
 
-				const statsParts: string[] = [];
-				if (totalInput) statsParts.push(`↑${formatTokens(totalInput)}`);
-				if (totalOutput) statsParts.push(`↓${formatTokens(totalOutput)}`);
-				if (totalCacheRead) statsParts.push(`R${formatTokens(totalCacheRead)}`);
-				if (totalCacheWrite) statsParts.push(`W${formatTokens(totalCacheWrite)}`);
+				// Build three groups separated by pipes
+				// Group 1: ↑input ↓output ⚡tps
+				// Group 2: Rcache Wcache $cost
+				// Group 3: context%
+				const { tps } = tpsState;
+				const showTps = tps > 0;
+
+				// Group 1: Read/Write + TPS
+				const group1Parts: string[] = [];
+				if (totalInput) group1Parts.push(`↑${formatTokens(totalInput)}`);
+				if (totalOutput) group1Parts.push(`↓${formatTokens(totalOutput)}`);
+				if (showTps) group1Parts.push(theme.fg("accent", `⚡${formatTps(tps)}`));
+				const group1 = group1Parts.length > 0 ? group1Parts.join(" ") : null;
 
+				// Group 2: Cache + Price
+				const group2Parts: string[] = [];
+				if (totalCacheRead) group2Parts.push(`${iconCacheRead}${formatTokens(totalCacheRead)}`);
+				if (totalCacheWrite) group2Parts.push(`${iconCacheWrite}${formatTokens(totalCacheWrite)}`);
 				const usingSubscription = ctx.model ? ctx.modelRegistry.isUsingOAuth(ctx.model) : false;
 				if (totalCost || usingSubscription) {
-					statsParts.push(`$${totalCost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`);
+					group2Parts.push(`$${totalCost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`);
 				}
+				const group2 = group2Parts.length > 0 ? group2Parts.join(" ") : null;
 
+				// Group 3: Context usage
 				const contextUsage = ctx.getContextUsage();
-				if (contextUsage) {
-					const percentValue = contextUsage.percent ?? 0;
-					const percent = contextUsage.percent !== null ? `${contextUsage.percent.toFixed(1)}%` : "?";
-					const contextWindow = formatTokens(contextUsage.contextWindow);
-					const contextText = `${percent}/${contextWindow}`;
-					if (percentValue > 90) statsParts.push(theme.fg("error", contextText));
-					else if (percentValue > 70) statsParts.push(theme.fg("warning", contextText));
-					else statsParts.push(contextText);
+				const contextWindow = contextUsage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+				let group3: string | null = null;
+
+				if (contextUsage && contextUsage.tokens !== null && contextWindow > 0) {
+					const percent =
+						contextUsage.percent !== null
+							? contextUsage.percent.toFixed(1)
+							: ((contextUsage.tokens / contextWindow) * 100).toFixed(1);
+					const contextText = `${percent}%/${formatTokens(contextWindow)}`;
+					const percentValue = contextUsage.percent ?? (contextUsage.tokens / contextWindow) * 100;
+					if (percentValue > 90) group3 = theme.fg("error", contextText);
+					else if (percentValue > 70) group3 = theme.fg("warning", contextText);
+					else group3 = contextText;
+				} else if (contextUsage && contextUsage.percent !== null) {
+					const percent = contextUsage.percent.toFixed(1);
+					const contextText = `${percent}%/${formatTokens(contextWindow)}`;
+					if (contextUsage.percent > 90) group3 = theme.fg("error", contextText);
+					else if (contextUsage.percent > 70) group3 = theme.fg("warning", contextText);
+					else group3 = contextText;
 				}
-				const leftStats = statsParts.join(" ");
 
+				// Combine groups with pipes
+				const groups = [group1, group2, group3].filter((g) => g !== null) as string[];
+				const leftStats = groups.join(groupSep);
+
+				// Model + thinking level with icons
 				const model = ctx.model;
-				const rightParts: string[] = [];
+				const rightPartsLine2: string[] = [];
 				if (model) {
 					if (model.provider && footerData.getAvailableProviderCount() > 1) {
-						rightParts.push(theme.fg("muted", `(${model.provider})`));
+						rightPartsLine2.push(theme.fg("muted", `(${model.provider})`));
 					}
 					let modelText = theme.bold(model.id || "unknown");
 					if (model.reasoning) {
 						const thinking = formatThinkingLabel(getThinkingLevel(ctx));
-						if (thinking) modelText += `${sep}${theme.fg("dim", thinking)}`;
+						if (thinking) {
+							const thinkLabel = hasNerdFonts ? withIcon(iconThink, thinking) : thinking;
+							modelText += `${sep}${theme.fg("dim", thinkLabel)}`;
+						}
 					}
-					rightParts.push(modelText);
+					rightPartsLine2.push(modelText);
 				}
-				const statsLine = renderFooterLine(width, leftStats, rightParts.join(sep));
+				const statsLine = renderFooterLine(width, leftStats, rightPartsLine2.join(sep));
 
 				// ── Line 3 (optional): extension statuses ─────────────────────
 				const lines = [locationLine, statsLine];
 				const extensionStatuses = footerData.getExtensionStatuses();
-				if (extensionStatuses.size > 0) {
-					const statusLine = (Array.from(extensionStatuses.entries()) as [string, string][])
-						.sort(([a], [b]) => a.localeCompare(b))
-						.map(([, text]) => sanitizeStatusText(text))
+				// Filter out blacklisted status keys
+				const visibleStatuses = new Map<string, string>(
+					Array.from(extensionStatuses.entries() as [string, string][]).filter(
+						([key]) => !STATUS_KEY_BLACKLIST.has(key),
+					),
+				);
+				if (visibleStatuses.size > 0) {
+					const statusLine = Array.from(visibleStatuses.values())
+						.map((text) => sanitizeStatusText(text))
+						.sort((a, b) => a.localeCompare(b))
 						.join(" ");
 					lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "...")));
 				}

package/src/icons.ts

@@ -0,0 +1,36 @@
+// ── Nerd Font detection ────────────────────────────────────────────────────────
+
+/**
+ * Detect if the terminal supports Nerd Fonts.
+ * Checks environment variables and common terminal identifiers.
+ */
+export function hasNerdFonts(): boolean {
+	if (process.env.POWERLINE_NERD_FONTS === "1") return true;
+	if (process.env.POWERLINE_NERD_FONTS === "0") return false;
+	if (process.env.GHOSTTY_RESOURCES_DIR) return true;
+	const term = (process.env.TERM_PROGRAM || "").toLowerCase();
+	return ["iterm", "wezterm", "kitty", "ghostty", "alacritty"].some((t) => term.includes(t));
+}
+
+const NERD = hasNerdFonts();
+
+// ── Icons (fallback to text symbols when Nerd Fonts unavailable) ─────────────
+
+/** Git branch icon */
+export const iconGit = NERD ? "\uF7A1" : ""; //  or fallback to empty (branch name is clear enough)
+
+/** Thinking/lightning icon (shown with thinking level) */
+export const iconThink = NERD ? "\uF0E7" : ""; //  or fallback to empty
+
+/** Cache read icon (󰩺 nf-md-cached — circular arrows) */
+export const iconCacheRead = NERD ? "\uDB82\uDE7A" : "R"; // 󰩺 or fallback to R
+
+/** Cache write icon (󱀚 nf-md-cloud-upload) */
+export const iconCacheWrite = NERD ? "\uDB84\uDC1A" : "W"; // 󱀚 or fallback to W
+
+/**
+ * Wrap text with an icon prefix if nerd fonts are available.
+ */
+export function withIcon(icon: string, text: string): string {
+	return icon ? `${icon} ${text}` : text;
+}

package/src/index.ts

@@ -3,24 +3,32 @@
  *
  * Renders a two-line status footer for every session:
  *   Line 1 — working directory · git branch (dirty/ahead/behind) · session name
- *   Line 2 — token usage · context window % · model name · thinking level
+ *   Line 2 — token usage · tps · context window % · model name · thinking level
  *   Line 3 — extension statuses (when any are active)
  *
  * Git status is refreshed after every turn and on branch change events.
+ * Token stats update in real-time during streaming.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createFooterRenderer } from "./footer";
 import { readGitStatus } from "./git";
+import { hasNerdFonts } from "./icons";
+import { TpsCalculator } from "./tps";
 import type { GitStatus } from "./types";
+import { installWorkingIndicator } from "./workingIndicator";
 
 // ── Extension ──────────────────────────────────────────────────────────────────
 
 export default function globalFooterExtension(pi: ExtensionAPI): void {
+	installWorkingIndicator(pi);
 	let tuiRef: { requestRender: () => void } | null = null;
 	let gitStatus: GitStatus | null = null;
 	let currentCwd = process.cwd();
 
+	// TPS calculator for live throughput
+	const tpsCalculator = new TpsCalculator();
+
 	const requestRender = () => tuiRef?.requestRender();
 	const refreshGit = () => {
 		gitStatus = readGitStatus(currentCwd);
@@ -34,7 +42,13 @@ export default function globalFooterExtension(pi: ExtensionAPI): void {
 		ctx.ui.setFooter((tui, theme, footerData) => {
 			tuiRef = tui;
 
-			const descriptor = createFooterRenderer(ctx, () => gitStatus, requestRender)(tui, theme, footerData);
+			const descriptor = createFooterRenderer(
+				ctx,
+				() => gitStatus,
+				requestRender,
+				hasNerdFonts(),
+				() => tpsCalculator.getState(),
+			)(tui, theme, footerData);
 
 			return {
 				dispose() {
@@ -57,4 +71,24 @@ export default function globalFooterExtension(pi: ExtensionAPI): void {
 		currentCwd = ctx.cwd;
 		requestRender();
 	});
+
+	// ── TPS tracking during streaming ─────────────────────────────────────────
+
+	pi.on("turn_start", () => {
+		tpsCalculator.resetForTurn();
+	});
+
+	pi.on("message_update", (event) => {
+		if (!tuiRef) return;
+		if (event.message.role !== "assistant") return;
+		tpsCalculator.onMessageUpdate(event.message);
+		requestRender();
+	});
+
+	pi.on("message_end", (event) => {
+		if (!tuiRef) return;
+		if (event.message.role !== "assistant") return;
+		tpsCalculator.onMessageEnd(event.message);
+		requestRender();
+	});
 }

package/src/tps.ts

@@ -0,0 +1,109 @@
+/**
+ * Token Per Second (TPS) Calculator
+ *
+ * Tracks streaming throughput and calculates TPS in real-time.
+ * - During streaming: estimates TPS from character count / 4
+ * - On completion: uses actual output tokens from message usage
+ */
+
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface TpsState {
+	/** Whether we're currently streaming */
+	isStreaming: boolean;
+	/** Estimated TPS during streaming, actual after completion */
+	tps: number;
+	/** Total output tokens from last message */
+	lastOutputTokens: number;
+	/** Total input tokens from last message */
+	lastInputTokens: number;
+}
+
+// ── Calculator ───────────────────────────────────────────────────────────────
+
+export class TpsCalculator {
+	private streaming = false;
+	private streamStart = 0;
+	private tps = 0;
+	private lastOutputTokens = 0;
+	private lastInputTokens = 0;
+
+	/**
+	 * Reset state at the start of a new turn.
+	 */
+	resetForTurn(): void {
+		this.streaming = false;
+		this.streamStart = 0;
+		this.tps = 0;
+	}
+
+	/**
+	 * Called when streaming starts (first message_update).
+	 */
+	streamStarted(): void {
+		this.streaming = true;
+		this.streamStart = performance.now();
+	}
+
+	/**
+	 * Called on each message_update during streaming.
+	 */
+	onMessageUpdate(message: AssistantMessage): void {
+		if (!this.streaming) {
+			this.streamStarted();
+		}
+
+		let chars = 0;
+		for (const block of message.content) {
+			if (block.type === "text") chars += block.text.length;
+			else if (block.type === "thinking") chars += block.thinking.length;
+		}
+
+		const elapsed = (performance.now() - this.streamStart) / 1000;
+		if (elapsed > 0.1) {
+			const estimatedTokens = chars / 4;
+			this.tps = estimatedTokens / elapsed;
+		}
+	}
+
+	/**
+	 * Called on message_end to finalize TPS with actual usage.
+	 */
+	onMessageEnd(message: AssistantMessage): void {
+		const elapsed = this.streamStart > 0 ? (performance.now() - this.streamStart) / 1000 : 0;
+		const outputTokens = message.usage?.output ?? 0;
+		this.lastInputTokens = message.usage?.input ?? 0;
+		this.lastOutputTokens = outputTokens;
+
+		if (elapsed > 0.1 && outputTokens > 0) {
+			this.tps = outputTokens / elapsed;
+		}
+
+		this.streaming = false;
+	}
+
+	/**
+	 * Get current TPS state for rendering.
+	 */
+	getState(): TpsState {
+		return {
+			isStreaming: this.streaming,
+			tps: this.tps,
+			lastOutputTokens: this.lastOutputTokens,
+			lastInputTokens: this.lastInputTokens,
+		};
+	}
+}
+
+// ── Formatting ───────────────────────────────────────────────────────────────
+
+/**
+ * Format TPS number for display.
+ */
+export function formatTps(tps: number): string {
+	if (tps < 1) return "0";
+	if (tps < 10) return tps.toFixed(1);
+	return tps.toFixed(0);
+}

package/src/workingIndicator.ts

@@ -0,0 +1,747 @@
+/**
+ * Working Indicator
+ *
+ * Displays an animated working message while the agent is processing:
+ *   ✳ Reticulating... · running bash · 4s
+ *
+ * On completion, briefly shows a static completion verb + time taken:
+ *   ✓ Crystallized · 23s
+ *
+ * Features:
+ *   - Claude-style spinner frames (· ✢ ✳ ✶ ✻ ✽) at 150ms
+ *   - Random verb from Claude's list, rotates every 2s
+ *   - Per-character shimmer (accent color sweep) across the verb
+ *   - Active tool suffix (e.g. "running bash", "editing file")
+ *   - Elapsed timer ticking every 1s
+ *   - Completion verb (past-tense) + total time, shown for 3s then cleared
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+// ── Spinner frames (Claude Code style) ────────────────────────────────────────
+
+const SPINNER_FRAMES = ["·", "✢", "✳", "✶", "✻", "✽"] as const;
+const SPINNER_INTERVAL_MS = 150;
+
+// ── Verbs ─────────────────────────────────────────────────────────────────────
+
+const VERBS: string[] = [
+	"Accomplishing",
+	"Actioning",
+	"Actualizing",
+	"Architecting",
+	"Baking",
+	"Beaming",
+	"Beboppin'",
+	"Befuddling",
+	"Billowing",
+	"Blanching",
+	"Bloviating",
+	"Boogieing",
+	"Boondoggling",
+	"Booping",
+	"Bootstrapping",
+	"Brewing",
+	"Bunning",
+	"Burrowing",
+	"Calculating",
+	"Canoodling",
+	"Caramelizing",
+	"Cascading",
+	"Catapulting",
+	"Cerebrating",
+	"Channeling",
+	"Choreographing",
+	"Churning",
+	"Coalescing",
+	"Cogitating",
+	"Combobulating",
+	"Composing",
+	"Computing",
+	"Concocting",
+	"Considering",
+	"Contemplating",
+	"Cooking",
+	"Crafting",
+	"Creating",
+	"Crunching",
+	"Crystallizing",
+	"Cultivating",
+	"Deciphering",
+	"Deliberating",
+	"Determining",
+	"Dilly-dallying",
+	"Discombobulating",
+	"Doing",
+	"Doodling",
+	"Drizzling",
+	"Ebbing",
+	"Elucidating",
+	"Embellishing",
+	"Enchanting",
+	"Envisioning",
+	"Fermenting",
+	"Fiddle-faddling",
+	"Finagling",
+	"Flowing",
+	"Flummoxing",
+	"Forging",
+	"Forming",
+	"Frolicking",
+	"Gallivanting",
+	"Galloping",
+	"Generating",
+	"Gesticulating",
+	"Germinating",
+	"Gitifying",
+	"Grooving",
+	"Harmonizing",
+	"Hashing",
+	"Hatching",
+	"Herding",
+	"Hullaballooing",
+	"Hyperspacing",
+	"Ideating",
+	"Imagining",
+	"Improvising",
+	"Incubating",
+	"Inferring",
+	"Infusing",
+	"Jitterbugging",
+	"Kneading",
+	"Leavening",
+	"Levitating",
+	"Lollygagging",
+	"Manifesting",
+	"Marinating",
+	"Meandering",
+	"Metamorphosing",
+	"Moonwalking",
+	"Moseying",
+	"Mulling",
+	"Mustering",
+	"Musing",
+	"Nebulizing",
+	"Nesting",
+	"Noodling",
+	"Orbiting",
+	"Orchestrating",
+	"Perambulating",
+	"Percolating",
+	"Perusing",
+	"Philosophising",
+	"Pollinating",
+	"Pondering",
+	"Pontificating",
+	"Precipitating",
+	"Prestidigitating",
+	"Processing",
+	"Propagating",
+	"Puttering",
+	"Puzzling",
+	"Razzle-dazzling",
+	"Razzmatazzing",
+	"Recombobulating",
+	"Reticulating",
+	"Roosting",
+	"Ruminating",
+	"Scampering",
+	"Schlepping",
+	"Scurrying",
+	"Seasoning",
+	"Shenaniganing",
+	"Shimmying",
+	"Simmering",
+	"Skedaddling",
+	"Sketching",
+	"Spelunking",
+	"Spinning",
+	"Sprouting",
+	"Stewing",
+	"Sublimating",
+	"Swirling",
+	"Swooping",
+	"Synthesizing",
+	"Tempering",
+	"Thinking",
+	"Tinkering",
+	"Tomfoolering",
+	"Transfiguring",
+	"Transmuting",
+	"Twisting",
+	"Undulating",
+	"Unfurling",
+	"Unravelling",
+	"Vibing",
+	"Waddling",
+	"Wandering",
+	"Warping",
+	"Whirlpooling",
+	"Whirring",
+	"Whisking",
+	"Wibbling",
+	"Working",
+	"Wrangling",
+	"Zesting",
+	"Zigzagging",
+];
+
+const COMPLETION_VERBS: string[] = [
+	"Done",
+	"Complete",
+	"Finished",
+	"Baked",
+	"Brewed",
+	"Crunched",
+	"Crafted",
+	"Forged",
+	"Generated",
+	"Crystallized",
+	"Transmuted",
+	"Synthesized",
+	"Wrangled",
+	"Zigzagged",
+	"Spelunked",
+	"Orchestrated",
+];
+
+function randomItem<T>(arr: T[]): T {
+	return arr[Math.floor(Math.random() * arr.length)]!;
+}
+
+// ── Tool label config ─────────────────────────────────────────────────────────
+
+interface ToolConfig {
+	icon: string;
+	labels: string[];
+}
+
+const TOOL_CONFIG: Record<string, ToolConfig> = {
+	bash: {
+		icon: "\uF489", //  nf-dev-terminal
+		labels: ["piping dreams", "dropping to bash", "herding cats", "petting the shell", "melting faces"],
+	},
+	read: {
+		icon: "\uF0F6", //  nf-fa-file_text_o
+		labels: [
+			"squinting at text",
+			"hunting for clues",
+			"snuggling with code",
+			"cracking open files",
+			"devouring content",
+		],
+	},
+	write: {
+		icon: "\uF0C7", //  nf-fa-floppy_o
+		labels: [
+			"birthing code",
+			"crafting masterpieces",
+			"channeling the muse",
+			"dropping truth bombs",
+			"deflowering files",
+		],
+	},
+	edit: {
+		icon: "\uF044", //  nf-fa-pencil_square_o
+		labels: ["playing god", "twiddling bits", "tucking in code", "surgically altering", "violating the code"],
+	},
+	ls: {
+		icon: "\uF07C", //  nf-fa-folder_open_o
+		labels: ["peeking at files", "snooping around", "counting sheep", "creeping directories", "pillaging folders"],
+	},
+	find: {
+		icon: "\uF422", //  nf-oct-search
+		labels: [
+			"tracking things down",
+			"following breadcrumbs",
+			"finding lost socks",
+			"hunting high and low",
+			"raiding the filesystem",
+		],
+	},
+	grep: {
+		icon: "\uF002", //  nf-fa-search
+		labels: [
+			"string hunting",
+			"needle in a haystack",
+			"patting for patterns",
+			"pillaging with regex",
+			"gutting files",
+		],
+	},
+	// ── Task tools (shared pool) ───────────────────────────────────────────────
+	TaskCreate: {
+		icon: "\uF0AE", //  nf-fa-tasks
+		labels: [
+			"scribbling notes",
+			"jotting things down",
+			"dropping to-dos",
+			"tagging along",
+			"slinging tasks",
+			"making lists",
+			"brewing trouble",
+			"naming a puppy",
+			"spawning tasks",
+			"planting seeds",
+		],
+	},
+	TaskList: {
+		icon: "\uF0AE",
+		labels: [
+			"making lists",
+			"slinging tasks",
+			"scribbling notes",
+			"tagging along",
+			"jotting things down",
+			"dropping to-dos",
+			"counting heads",
+			"brewing trouble",
+			"naming a puppy",
+			"herding to-dos",
+		],
+	},
+	TaskGet: {
+		icon: "\uF0AE",
+		labels: [
+			"jotting things down",
+			"tagging along",
+			"scribbling notes",
+			"making lists",
+			"dropping to-dos",
+			"slinging tasks",
+			"peeking at tasks",
+			"brewing trouble",
+			"naming a puppy",
+			"fetching the scroll",
+		],
+	},
+	TaskUpdate: {
+		icon: "\uF0AE",
+		labels: [
+			"dropping to-dos",
+			"slinging tasks",
+			"tagging along",
+			"scribbling notes",
+			"jotting things down",
+			"making lists",
+			"tweaking the plan",
+			"brewing trouble",
+			"naming a puppy",
+			"re-scribbling",
+		],
+	},
+	TaskOutput: {
+		icon: "\uF0AE",
+		labels: [
+			"tagging along",
+			"dropping to-dos",
+			"making lists",
+			"scribbling notes",
+			"slinging tasks",
+			"jotting things down",
+			"stamping done",
+			"brewing trouble",
+			"naming a puppy",
+			"filing the report",
+		],
+	},
+	TaskStop: {
+		icon: "\uF0AE",
+		labels: [
+			"brewing trouble",
+			"slinging tasks",
+			"dropping to-dos",
+			"scribbling notes",
+			"tagging along",
+			"making lists",
+			"pulling the plug",
+			"naming a puppy",
+			"jotting things down",
+			"calling it quits",
+		],
+	},
+	// ── Agent tools ───────────────────────────────────────────────────────────
+	Agent: {
+		icon: "\uF544", //  nf-fa5-robot
+		labels: [
+			"cloning myself",
+			"spreading the workload",
+			"making friends",
+			"herding agents",
+			"summoning bots",
+			"pulling strings",
+			"spawning minions",
+			"delegating chaos",
+			"multiplying",
+			"outsourcing brilliance",
+		],
+	},
+	get_subagent_result: {
+		icon: "\uF544",
+		labels: [
+			"peeking at results",
+			"pulling strings",
+			"collecting the loot",
+			"herding agents",
+			"checking in",
+			"fetching the wisdom",
+			"reading the oracle",
+			"gathering intel",
+			"unpacking the goods",
+			"seeing what happened",
+		],
+	},
+	steer_subagent: {
+		icon: "\uF544",
+		labels: [
+			"whispering secrets",
+			"nudging along",
+			"pulling strings",
+			"backseat driving",
+			"herding agents",
+			"micromanaging",
+			"sending smoke signals",
+			"course correcting",
+			"steering the ship",
+			"poking the bot",
+		],
+	},
+	// ── User interaction ──────────────────────────────────────────────────────
+	ask_user: {
+		icon: "\uF27A", //  nf-fa-comment_o
+		labels: [
+			"poking the human",
+			"disturbing the peace",
+			"breaking the flow",
+			"interrogating the human",
+			"cornering the user",
+		],
+	},
+};
+
+// Per-tool label rotation state
+const toolLabelIndices = new Map<string, number>();
+
+function getToolDisplay(toolName: string): string {
+	const config = TOOL_CONFIG[toolName];
+	if (!config) return `\uF489 running ${toolName}`; // fallback: terminal icon
+
+	// Pick next label in rotation
+	const idx = toolLabelIndices.get(toolName) ?? Math.floor(Math.random() * config.labels.length);
+	toolLabelIndices.set(toolName, (idx + 1) % config.labels.length);
+
+	return `${config.icon} ${config.labels[idx]}`;
+}
+
+function rotateToolLabel(toolName: string): string {
+	const config = TOOL_CONFIG[toolName];
+	if (!config) return `\uF489 running ${toolName}`;
+	const idx = toolLabelIndices.get(toolName) ?? 0;
+	toolLabelIndices.set(toolName, (idx + 1) % config.labels.length);
+	return `${config.icon} ${config.labels[idx % config.labels.length]}`;
+}
+
+// ── Elapsed time formatting ────────────────────────────────────────────────────
+
+function formatElapsed(ms: number): string {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+	const seconds = totalSeconds % 60;
+	const totalMinutes = Math.floor(totalSeconds / 60);
+	const minutes = totalMinutes % 60;
+	const hours = Math.floor(totalMinutes / 60);
+
+	if (hours > 0) return `${hours}h ${String(minutes).padStart(2, "0")}m ${String(seconds).padStart(2, "0")}s`;
+	if (totalMinutes > 0) return `${totalMinutes}m ${String(seconds).padStart(2, "0")}s`;
+	return `${seconds}s`;
+}
+
+// ── Shimmer ───────────────────────────────────────────────────────────────────
+
+const SHIMMER_BAND_WIDTH = 4;
+
+function hexToRgb(hex: string): [number, number, number] {
+	const h = hex.replace("#", "");
+	return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+
+function blendColors(c1: [number, number, number], c2: [number, number, number], t: number): [number, number, number] {
+	return [
+		Math.round(c1[0] + (c2[0] - c1[0]) * t),
+		Math.round(c1[1] + (c2[1] - c1[1]) * t),
+		Math.round(c1[2] + (c2[2] - c1[2]) * t),
+	];
+}
+
+function lightenRgb(r: number, g: number, b: number, amount: number): [number, number, number] {
+	return [
+		Math.min(255, Math.round(r + (255 - r) * amount)),
+		Math.min(255, Math.round(g + (255 - g) * amount)),
+		Math.min(255, Math.round(b + (255 - b) * amount)),
+	];
+}
+
+function getAccentHex(ctx: ExtensionContext): string | null {
+	const sample = ctx.ui.theme.fg("accent", "\u2588");
+	const match = sample.match(/\x1b\[38;2;(\d+);(\d+);(\d+)m/);
+	if (!match) return null;
+	const r = parseInt(match[1]!, 10).toString(16).padStart(2, "0");
+	const g = parseInt(match[2]!, 10).toString(16).padStart(2, "0");
+	const b = parseInt(match[3]!, 10).toString(16).padStart(2, "0");
+	return `#${r}${g}${b}`;
+}
+
+function applyShimmer(text: string, frame: number, baseHex: string, shimmerHex: string): string {
+	const base = hexToRgb(baseHex);
+	const shimmer = hexToRgb(shimmerHex);
+	const totalWidth = text.length + SHIMMER_BAND_WIDTH * 2;
+	const pos = frame % totalWidth;
+
+	let result = "";
+	for (let i = 0; i < text.length; i++) {
+		const dist = Math.abs(i - pos);
+		const t = Math.max(0, 1 - dist / SHIMMER_BAND_WIDTH);
+		const color = blendColors(base, shimmer, t);
+		result += `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${text[i]}\x1b[0m`;
+	}
+	return result;
+}
+
+// ── Working Indicator ─────────────────────────────────────────────────────────
+
+export function installWorkingIndicator(pi: ExtensionAPI): void {
+	let ctx: ExtensionContext | null = null;
+	let isActive = false;
+
+	// Timers
+	let spinnerTimer: ReturnType<typeof setInterval> | null = null;
+	let verbTimer: ReturnType<typeof setInterval> | null = null;
+	let tickTimer: ReturnType<typeof setInterval> | null = null;
+	let completionTimer: ReturnType<typeof setTimeout> | null = null;
+
+	// State
+	let spinnerFrame = 0;
+	let shimmerFrame = 0;
+	let currentVerb = "Working";
+	let startedAt = 0;
+	let elapsedMs = 0;
+	let toolSuffix: string | undefined;
+	const activeTools = new Map<string, string>(); // toolCallId -> toolName
+	let toolLabelTimer: ReturnType<typeof setInterval> | null = null;
+
+	// Shimmer colors (resolved once per session from theme)
+	let accentHex: string | null = null;
+	let shimmerHex: string | null = null;
+
+	// ── Color resolution ──────────────────────────────────────────────────────
+
+	function resolveColors(): void {
+		if (!ctx) return;
+		accentHex = getAccentHex(ctx);
+		if (accentHex) {
+			const [r, g, b] = hexToRgb(accentHex);
+			const [lr, lg, lb] = lightenRgb(r, g, b, 0.55);
+			shimmerHex = `#${lr.toString(16).padStart(2, "0")}${lg.toString(16).padStart(2, "0")}${lb.toString(16).padStart(2, "0")}`;
+		}
+	}
+
+	// ── Render ────────────────────────────────────────────────────────────────
+
+	function render(): void {
+		if (!ctx || !isActive) return;
+
+		const theme = ctx.ui.theme;
+		const sep = theme.fg("dim", " · ");
+
+		// Spinner frame (accent colored)
+		const frame = theme.fg("accent", SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length]!);
+
+		// Verb with shimmer
+		const verbText = `${currentVerb}...`;
+		let verbStyled: string;
+		if (accentHex && shimmerHex) {
+			verbStyled = applyShimmer(verbText, shimmerFrame, accentHex, shimmerHex);
+		} else {
+			verbStyled = theme.fg("accent", verbText);
+		}
+
+		// Timer
+		const timer = theme.fg("dim", formatElapsed(elapsedMs));
+
+		// Assemble parts
+		const parts: string[] = [frame, verbStyled];
+		if (toolSuffix) parts.push(toolSuffix);
+		parts.push(timer);
+
+		ctx.ui.setWorkingMessage(parts.join(sep));
+	}
+
+	// ── Timer management ──────────────────────────────────────────────────────
+
+	function startTimers(): void {
+		// Spinner + shimmer: 150ms
+		spinnerTimer = setInterval(() => {
+			spinnerFrame++;
+			shimmerFrame++;
+			render();
+		}, SPINNER_INTERVAL_MS);
+
+		// Verb rotation: 2s
+		verbTimer = setInterval(() => {
+			currentVerb = randomItem(VERBS);
+			render();
+		}, 2000);
+
+		// Elapsed tick: 1s
+		tickTimer = setInterval(() => {
+			elapsedMs = Date.now() - startedAt;
+			render();
+		}, 1000);
+	}
+
+	function stopTimers(): void {
+		if (spinnerTimer) {
+			clearInterval(spinnerTimer);
+			spinnerTimer = null;
+		}
+		if (verbTimer) {
+			clearInterval(verbTimer);
+			verbTimer = null;
+		}
+		if (tickTimer) {
+			clearInterval(tickTimer);
+			tickTimer = null;
+		}
+		if (toolLabelTimer) {
+			clearInterval(toolLabelTimer);
+			toolLabelTimer = null;
+		}
+	}
+
+	function cancelCompletionTimer(): void {
+		if (completionTimer) {
+			clearTimeout(completionTimer);
+			completionTimer = null;
+		}
+	}
+
+	// ── Completion ────────────────────────────────────────────────────────────
+
+	function showCompletion(totalMs: number): void {
+		if (!ctx) return;
+		cancelCompletionTimer();
+
+		const theme = ctx.ui.theme;
+		const check = theme.fg("success", "✓");
+		const verb = theme.fg("accent", randomItem(COMPLETION_VERBS));
+		const time = theme.fg("dim", formatElapsed(totalMs));
+		const sep = theme.fg("dim", " · ");
+
+		ctx.ui.setWorkingMessage(`${check}${sep}${verb}${sep}${time}`);
+		ctx.ui.setStatus("working-indicator", `${check} ${verb}`);
+
+		completionTimer = setTimeout(() => {
+			completionTimer = null;
+			ctx?.ui.setWorkingMessage(undefined);
+			ctx?.ui.setStatus("working-indicator", "");
+		}, 3000);
+	}
+
+	// ── Spinner frames (apply to pi's working indicator widget) ───────────────
+
+	function applySpinnerFrames(): void {
+		if (!ctx) return;
+		const colored = SPINNER_FRAMES.map((f) => ctx!.ui.theme.fg("accent", f));
+		ctx.ui.setWorkingIndicator({ frames: colored, intervalMs: SPINNER_INTERVAL_MS });
+	}
+
+	// ── Event hooks ───────────────────────────────────────────────────────────
+
+	pi.on("session_start", async (_event, sessionCtx) => {
+		ctx = sessionCtx;
+		resolveColors();
+		applySpinnerFrames();
+	});
+
+	pi.on("agent_start", async (_event, agentCtx) => {
+		ctx = agentCtx;
+		cancelCompletionTimer();
+		stopTimers();
+
+		isActive = true;
+		startedAt = Date.now();
+		elapsedMs = 0;
+		spinnerFrame = 0;
+		shimmerFrame = 0;
+		toolSuffix = undefined;
+		activeTools.clear();
+		toolLabelIndices.clear();
+		currentVerb = randomItem(VERBS);
+
+		resolveColors();
+		applySpinnerFrames();
+		render();
+		startTimers();
+	});
+
+	pi.on("tool_execution_start", (event) => {
+		if (!isActive) return;
+		const e = event as { toolCallId?: string; toolName?: string };
+		if (e.toolCallId && e.toolName) {
+			activeTools.set(e.toolCallId, e.toolName); // store tool name, not display string
+			toolSuffix = getToolDisplay(e.toolName);
+
+			// Start rotating the label for this tool every 2s
+			if (toolLabelTimer) {
+				clearInterval(toolLabelTimer);
+				toolLabelTimer = null;
+			}
+			const _activeName = e.toolName;
+			toolLabelTimer = setInterval(() => {
+				// Only rotate if this tool is still active
+				const currentToolName = Array.from(activeTools.values()).at(-1);
+				if (currentToolName) {
+					toolSuffix = rotateToolLabel(currentToolName);
+					render();
+				}
+			}, 2000);
+
+			render();
+		}
+	});
+
+	pi.on("tool_execution_end", (event) => {
+		if (!isActive) return;
+		const e = event as { toolCallId?: string };
+		if (e.toolCallId) activeTools.delete(e.toolCallId);
+		const remainingTool = Array.from(activeTools.values()).at(-1);
+		if (remainingTool) {
+			toolSuffix = getToolDisplay(remainingTool);
+		} else {
+			toolSuffix = undefined;
+			if (toolLabelTimer) {
+				clearInterval(toolLabelTimer);
+				toolLabelTimer = null;
+			}
+		}
+		render();
+	});
+
+	pi.on("agent_end", async (_event, agentCtx) => {
+		ctx = agentCtx;
+		const totalMs = startedAt > 0 ? Date.now() - startedAt : 0;
+
+		stopTimers();
+		isActive = false;
+		toolSuffix = undefined;
+		activeTools.clear();
+
+		showCompletion(totalMs);
+	});
+
+	pi.on("session_shutdown", async () => {
+		stopTimers();
+		cancelCompletionTimer();
+		isActive = false;
+		ctx = null;
+	});
+}