pi-crew 0.9.37 → 0.9.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.9.37",
+  "version": "0.9.39",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/config/config.ts

@@ -694,7 +694,7 @@ function parseIsolationPolicy(value: unknown): CrewRuntimeConfig["isolationPolic
 
 function parseRuntimeConfig(value: unknown): CrewRuntimeConfig | undefined {
 	const obj = asRecord(value);
-	if (!obj) return undefined;
+	if (!obj) return { inheritContext: true } as CrewRuntimeConfig;
 	const runtime: CrewRuntimeConfig = {
 		mode: parseWithSchema(
 			Type.Union([Type.Literal("auto"), Type.Literal("scaffold"), Type.Literal("child-process"), Type.Literal("live-session")]),
@@ -704,7 +704,7 @@ function parseRuntimeConfig(value: unknown): CrewRuntimeConfig | undefined {
 		allowChildProcessFallback: parseWithSchema(Type.Boolean(), obj.allowChildProcessFallback),
 		maxTurns: parsePositiveInteger(obj.maxTurns, LIMIT_CEILINGS.runtimeMaxTurns),
 		graceTurns: parsePositiveInteger(obj.graceTurns, LIMIT_CEILINGS.runtimeGraceTurns),
-		inheritContext: parseWithSchema(Type.Boolean(), obj.inheritContext),
+		inheritContext: parseWithSchema(Type.Boolean(), obj.inheritContext) ?? true,
 		promptMode: parseWithSchema(Type.Union([Type.Literal("replace"), Type.Literal("append")]), obj.promptMode),
 		groupJoin: parseWithSchema(Type.Union([Type.Literal("off"), Type.Literal("group"), Type.Literal("smart")]), obj.groupJoin),
 		groupJoinAckTimeoutMs: parsePositiveInteger(obj.groupJoinAckTimeoutMs, 86_400_000),

package/src/extension/crew-vibes/figures.ts

@@ -1,5 +1,5 @@
 import type { SpeedConfig } from "./config.ts";
-import { isWebTerminal } from "./font-detect.ts";
+import { hasCrewFontFile, isWebTerminal } from "./font-detect.ts";
 
 /**
  * Crew figures replacing the original cat glyphs from pi-speeed / pi-chonk.
@@ -57,12 +57,19 @@ const PUA_CREW_FRAMES: readonly string[] = [
 /**
  * Return the indicator frames for the given style.
  *
- * - `"braille"` (default): standard Unicode braille spinner, works everywhere
- * - `"pua"`: runner-pose glyphs from crew-vibes.ttf, requires font install
+ * Default is `"braille"` — standard Unicode braille spinner (⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏)
+ * that renders correctly on every terminal, every platform, with zero
+ * font dependency. PUA runner-glyphs require crew-vibes.ttf installed AND
+ * a terminal that does font fallback for Private Use Area codepoints —
+ * Windows Terminal does NOT do this reliably, showing garbage chars even
+ * with the font installed.
+ *
+ * To opt into the PUA runner look, pass `style: "pua"` explicitly.
  */
-export function crewFrames(style: "braille" | "pua" = "pua"): readonly string[] {
-	// Web terminals (gotty, wetty) cannot render PUA glyphs — fall back to braille
-	if (style === "pua" && isWebTerminal()) return BRAILLE_FRAMES;
+export function crewFrames(style: "braille" | "pua" = "braille"): readonly string[] {
+	// Even when explicitly requested, fall back to braille if the font is
+	// missing or we're on a web terminal (which can't render PUA at all).
+	if (style === "pua" && (isWebTerminal() || !hasCrewFontFile())) return BRAILLE_FRAMES;
 	return style === "pua" ? PUA_CREW_FRAMES : BRAILLE_FRAMES;
 }
 

package/src/extension/crew-vibes/index.ts

@@ -1,5 +1,24 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { requestRender, setFooter } from "../../ui/pi-ui-compat.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+
+/**
+ * Wrap a pi UI call in try/catch. If the call throws (e.g. terminal doesn't
+ * support PUA glyphs, theme helper returns undefined, or pi's API signature
+ * changed), log it and silently fall back to pi's default behavior — which
+ * is simply "do nothing", letting pi show its own built-in indicator.
+ *
+ * Crew-vibes must NEVER break the user's session. A broken spinner is not
+ * worth a crashed pi.
+ */
+function safeUiCall(scope: string, fn: () => void): void {
+	try {
+		fn();
+	} catch (error) {
+		logInternalError(`crew-vibes.${scope}`, error, undefined, "warn");
+	}
+}
+
 import { type CrewVibesConfig, loadConfig, PROVIDER_STATUS_ID, saveConfig } from "./config.ts";
 import { intervalForSpeed } from "./figures.ts";
 import { type CrewVibesFooterSource, createCrewVibesFooter } from "./footer.ts";
@@ -72,44 +91,48 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 	function installFooter(ctx: ExtensionContext): void {
 		if (!ctx?.hasUI) return;
 		if (!metersActive()) {
-			setFooter(ctx, undefined);
+			safeUiCall("clear-footer", () => setFooter(ctx, undefined));
 			return;
 		}
-		setFooter(ctx, (tui, theme, footerData) => createCrewVibesFooter({ tui, theme, footerData, ctx, source: footerSource }));
-		requestRender(ctx);
+		safeUiCall("install-footer", () => {
+			setFooter(ctx, (tui, theme, footerData) => createCrewVibesFooter({ tui, theme, footerData, ctx, source: footerSource }));
+			requestRender(ctx);
+		});
 	}
 
 	/** Trigger a footer repaint; the footer recomputes capacity/quota on render. */
 	function refreshFooter(ctx: ExtensionContext): void {
-		if (ctx?.hasUI) requestRender(ctx);
+		if (ctx?.hasUI) safeUiCall("refresh-footer", () => requestRender(ctx));
 	}
 
 	function publishSpeedFooter(ctx: ExtensionContext, speed = footerAnimator.value()): void {
 		if (!config.enabled || !config.speed.enabled || !config.speed.footer) {
-			setSpeedStatus(ctx, config, undefined);
+			safeUiCall("clear-speed-status", () => setSpeedStatus(ctx, config, undefined));
 			return;
 		}
-		setSpeedStatus(ctx, config, renderSpeedFooter(themeOf(ctx), config.speed, speed));
+		safeUiCall("publish-speed-status", () => setSpeedStatus(ctx, config, renderSpeedFooter(themeOf(ctx), config.speed, speed)));
 	}
 
 	function applyIndicator(ctx: ExtensionContext, speed: number | null, force = false): void {
 		if (!ctx.hasUI || !ctx.ui.setWorkingIndicator) return;
 		if (!config.enabled || !config.speed.enabled || !config.speed.indicator) {
-			ctx.ui.setWorkingIndicator();
+			safeUiCall("reset-indicator", () => ctx.ui.setWorkingIndicator?.());
 			return;
 		}
 		const next = intervalForSpeed(config.speed, speed);
 		if (!force && Math.abs(next - currentIntervalMs) < 10) return;
-		ctx.ui.setWorkingIndicator({
-			frames: crewIndicatorFrames(themeOf(ctx)),
-			intervalMs: next,
-		});
+		safeUiCall("set-indicator", () =>
+			ctx.ui.setWorkingIndicator?.({
+				frames: crewIndicatorFrames(themeOf(ctx)),
+				intervalMs: next,
+			}),
+		);
 		currentIntervalMs = next;
 	}
 
 	function renderWorking(ctx: ExtensionContext, speed: number | null): void {
 		if (!config.enabled || !config.speed.enabled || !ctx.hasUI) return;
-		ctx.ui.setWorkingMessage(renderWorkingMessage(themeOf(ctx), config.speed, speed));
+		safeUiCall("set-working-message", () => ctx.ui.setWorkingMessage?.(renderWorkingMessage(themeOf(ctx), config.speed, speed)));
 	}
 
 	function stopLiveTimer(): void {
@@ -315,7 +338,7 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		stopLiveTimer();
 		if (ctx && config.enabled && ctx.hasUI) {
 			applyIndicator(ctx, speedTracker.lastTokS);
-			ctx.ui.setWorkingMessage();
+			safeUiCall("clear-working-message", () => ctx.ui.setWorkingMessage?.());
 		}
 	});
 

package/src/extension/register.ts

@@ -130,7 +130,6 @@ function purgeStaleActiveRunIndexSyncIfLoaded(): void {
 
 import { pruneFinishedRuns, pruneUserLevelRuns } from "../extension/run-maintenance.ts";
 import { initI18n } from "../i18n.ts";
-import { globalProgressTracker } from "../runtime/progress-tracker.ts";
 // H3-L2 split: DeliveryCoordinator + OverflowRecoveryTracker moved to registration/lifecycle.ts.
 import { tryRegisterSessionCleanup } from "../runtime/session-resources.ts";
 import { createSessionSnapshot } from "../runtime/session-snapshot.ts";
@@ -703,6 +702,58 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		};
 	});
 
+	/**
+	 * Cleanup session resources WITHOUT aborting foreground team runs.
+	 * Used during session switch (reason="resume"/"new"/"fork") to let foreground
+	 * runs complete naturally when the session context is torn down.
+	 */
+	const cleanupSessionResourcesOnly = (): void => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		if (preloadTimer) {
+			clearTimeout(preloadTimer);
+			preloadTimer = undefined;
+		}
+		crewRunWatchers?.closeAll();
+		crewRunWatchers = undefined;
+		userCrewWatchers?.closeAll();
+		userCrewWatchers = undefined;
+		stopSessionBoundSubagents();
+		// P0 fix: Do NOT abort foreground team runs on session switch.
+		// Foreground team runs run in the same process as the session; they naturally clean up
+		// when the session context is torn down. Only subagents need explicit abort on switch.
+		// Foreground runs will be aborted by cleanupRuntime() during actual session shutdown.
+		crewScheduler?.stop();
+		stopAsyncRunNotifier(notifierState);
+
+		// P0: Purge all stale active-run-index entries on session cleanup.
+		purgeStaleActiveRunIndexSyncIfLoaded();
+
+		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
+		clearPiCrewPowerbar(pi.events);
+		disposePowerbarCoalescer();
+		disposeObservability(observabilityState, cleanedUp);
+		lifecycleState.deliveryCoordinator?.dispose();
+		clearHooksScoped();
+		uninstallCrewGlobalRegistry();
+		lifecycleState.overflowTracker?.dispose();
+		lifecycleState.deliveryCoordinator = undefined;
+		lifecycleState.overflowTracker = undefined;
+		manifestCache.dispose();
+		runSnapshotCache.dispose?.();
+		clearProjectRootCache();
+		renderScheduler?.dispose();
+		renderScheduler = undefined;
+		autoRecoveryLast.clear();
+		disposeNotifications(lifecycleState);
+		rpcHandle?.unsubscribe();
+		rpcHandle = undefined;
+		disposeI18n();
+		sessionGeneration += 1;
+		currentCtx = undefined;
+		if (globalStore[runtimeCleanupStoreKey] === cleanupSessionResourcesOnly) delete globalStore[runtimeCleanupStoreKey];
+	};
+
 	const cleanupRuntime = (): void => {
 		if (cleanedUp) return;
 		cleanedUp = true;
@@ -775,6 +826,20 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	};
 	globalStore[runtimeCleanupStoreKey] = cleanupRuntime;
 
+	// P0 fix: Check session_shutdown reason to determine whether to abort foreground runs.
+	// - reason="quit" or "reload": Actual shutdown — abort foreground runs.
+	// - reason="resume"/"new"/"fork": Session switch — let foreground runs complete.
+	pi.on("session_shutdown", (event) => {
+		const reason = typeof event === "object" && event !== null && "reason" in event ? (event as { reason: string }).reason : undefined;
+		if (reason === "quit" || reason === "reload") {
+			// Actual shutdown — abort foreground runs and cleanup everything
+			cleanupRuntime();
+		} else {
+			// Session switch (resume/new/fork) — cleanup resources but preserve foreground runs
+			cleanupSessionResourcesOnly();
+		}
+	});
+
 	pi.on("session_start", (_event, ctx) => {
 		runArtifactCleanup(ctx.cwd);
 
@@ -1386,7 +1451,6 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		stopAsyncRunNotifier(notifierState);
 		stopSessionBoundSubagents();
 	});
-	pi.on("session_shutdown", () => cleanupRuntime());
 
 	// Phase 11a: Dynamic resource discovery — inject pi-crew skill paths.
 	try {
@@ -1475,11 +1539,6 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			const record = event as Record<string, unknown>;
 			const eventType = typeof record.type === "string" ? record.type : undefined;
 			if (eventType) lifecycleState.overflowTracker?.feedEvent(taskId, runId, eventType);
-			// Phase 2: forward worker events to progress tracker for real-time
-			// widget display (tool calls, assistant text) on child-process runtime.
-			if (record && typeof record === "object") {
-				globalProgressTracker.handleWorkerEvent(taskId, runId, record);
-			}
 		},
 	});
 	registerSubagentTools(pi, subagentManager, {

package/src/extension/registration/subagent-tools.ts

@@ -23,7 +23,6 @@ import { loadConfig } from "../../config/config.ts";
 import { t } from "../../i18n.ts";
 import type { BatchBarrier } from "../../runtime/batch-barrier.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
-import { globalProgressTracker } from "../../runtime/progress-tracker.ts";
 import { checkSubagentSpawnPermission, currentCrewRole } from "../../runtime/role-permission.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
 import {
@@ -445,23 +444,7 @@ function startAgentToolProgress(cwd: string, agentRecordId: string, onUpdate: On
 				agents,
 				error: record.error,
 			});
-			// Phase 2C: enrich with real-time worker progress (tool calls, partial text)
-			// from globalProgressTracker. For foreground agents, find the task ID from
-			// the manifest and look up streaming progress.
-			let progressLine = text;
-			if (tasks && tasks.length > 0) {
-				const wp = globalProgressTracker.getWorkerProgress(tasks[0].id);
-				if (wp) {
-					const toolLine = wp.currentTool ? `\n  ⚡ tool: ${wp.currentTool}` : "";
-					const tokenLine =
-						wp.tokens.input + wp.tokens.output > 0
-							? `\n  📊 tokens: ${(wp.tokens.input / 1000).toFixed(1)}K in, ${(wp.tokens.output / 1000).toFixed(1)}K out`
-							: "";
-					const textLine = wp.partialText ? `\n  💬 ${wp.partialText.slice(-150).replace(/\n/g, " ")}` : "";
-					progressLine = `${text}${toolLine}${tokenLine}${textLine}`;
-				}
-			}
-			onUpdate({ content: [{ type: "text", text: progressLine }] });
+			onUpdate({ content: [{ type: "text", text }] });
 		} catch (error) {
 			logInternalError("subagent-tools.progress", error, `agentId=${agentRecordId}`);
 		}

package/src/extension/team-tool/context.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
 import type { PiTeamsConfig } from "../../config/config.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import type { RunSnapshotCache } from "../../ui/run-snapshot-cache.ts";

package/src/extension/team-tool/run.ts

@@ -832,6 +832,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 					runtime,
 					runtimeConfig: executedConfig.runtime,
 					parentContext: buildParentContext(ctx),
+
 					parentModel: ctx.model,
 					modelRegistry: ctx.modelRegistry,
 					modelOverride: params.model,

package/src/runtime/progress-tracker.ts

@@ -9,8 +9,6 @@ export interface AgentProgress {
 	turns: number;
 	tokens: { input: number; output: number };
 	status: "idle" | "running" | "completed" | "error";
-	/** Most recent partial assistant text (for live streaming display). */
-	partialText?: string;
 }
 
 export class ProgressTracker {
@@ -120,145 +118,7 @@ export class ProgressTracker {
 	getProgress(agentId: string): AgentProgress | undefined {
 		return this.sessions.get(agentId)?.progress;
 	}
-
-	// ── Child-process worker event bridge ──────────────────────────────────
-	//
-	// For child-process runtime, events arrive as raw JSON from the child pi
-	// process's stdout (via onJsonEvent). These methods bridge those events into
-	// the same crewEventBus stream that live-session uses, so the widget shows
-	// real-time tool calls and assistant text for BOTH runtimes.
-
-	private workerProgress = new Map<string, AgentProgress>();
-
-	/** Throttle: don't emit more than 1 progress event per 500ms per worker. */
-	private lastEmitTs = new Map<string, number>();
-	private static readonly EMIT_THROTTLE_MS = 500;
-
-	/**
-	 * Handle a raw child-process JSON event (from onJsonEvent callback).
-	 * Processes tool_execution_start/end, agent_start/end, and assistant text.
-	 */
-	handleWorkerEvent(taskId: string, runId: string, event: Record<string, unknown>): void {
-		let progress = this.workerProgress.get(taskId);
-		if (!progress) {
-			progress = {
-				toolCalls: 0,
-				currentTool: null,
-				toolStartTime: null,
-				errors: [],
-				turns: 0,
-				tokens: { input: 0, output: 0 },
-				status: "running",
-			};
-			this.workerProgress.set(taskId, progress);
-		}
-
-		const eventType = typeof event.type === "string" ? event.type : undefined;
-
-		switch (eventType) {
-			case "tool_execution_start": {
-				progress.toolCalls++;
-				progress.currentTool = typeof event.toolName === "string" ? event.toolName : "unknown";
-				progress.toolStartTime = Date.now();
-				this.emitThrottled(taskId, runId, progress);
-				break;
-			}
-			case "tool_execution_end": {
-				progress.currentTool = null;
-				progress.toolStartTime = null;
-				if (event.isError) {
-					progress.errors.push(String(event.result ?? "Unknown error"));
-					crewEventBus.emit({
-						type: "agent:error",
-						runId,
-						agentId: taskId,
-						payload: String(event.result ?? "Unknown error"),
-						timestamp: Date.now(),
-					});
-				}
-				this.emitThrottled(taskId, runId, progress);
-				break;
-			}
-			case "turn_start":
-			case "turn_end":
-				progress.turns++;
-				break;
-			case "agent_start":
-				progress.status = "running";
-				break;
-			case "agent_end":
-			case "agent_settled":
-				progress.status = "completed";
-				this.emitThrottled(taskId, runId, progress);
-				break;
-			case "message":
-			case "message_end": {
-				// Extract assistant text for streaming display.
-				const message = event.message as { role?: string; content?: unknown } | undefined;
-				if (message?.role === "assistant") {
-					const text = extractWorkerText(message.content);
-					if (text) {
-						progress.partialText = text.slice(-2000); // keep last 2K chars
-						this.emitThrottled(taskId, runId, progress);
-					}
-				}
-				// Track usage from message_end events.
-				if (eventType === "message_end" && event.usage && typeof event.usage === "object") {
-					const usage = event.usage as { input?: number; output?: number };
-					if (typeof usage.input === "number") progress.tokens.input += usage.input;
-					if (typeof usage.output === "number") progress.tokens.output += usage.output;
-				}
-				break;
-			}
-		}
-	}
-
-	/** Get the accumulated progress for a child-process worker task. */
-	getWorkerProgress(taskId: string): AgentProgress | undefined {
-		return this.workerProgress.get(taskId);
-	}
-
-	/** Remove a worker from tracking after completion. */
-	untrackWorker(taskId: string): void {
-		this.workerProgress.delete(taskId);
-		this.lastEmitTs.delete(taskId);
-	}
-
-	/**
-	 * Emit a progress event to crewEventBus, throttled to avoid flooding
-	 * the widget with re-renders (max 1 event per EMIT_THROTTLE_MS per worker).
-	 */
-	private emitThrottled(taskId: string, runId: string, progress: AgentProgress): void {
-		const now = Date.now();
-		const last = this.lastEmitTs.get(taskId) ?? 0;
-		if (now - last < ProgressTracker.EMIT_THROTTLE_MS) return;
-		this.lastEmitTs.set(taskId, now);
-		crewEventBus.emit({
-			type: "agent:progress",
-			runId,
-			agentId: taskId,
-			payload: { ...progress },
-			timestamp: now,
-		});
-	}
 }
 
 // Export singleton instance
 export const globalProgressTracker = new ProgressTracker();
-
-/**
- * Extract text content from a worker message's content field.
- * Handles string content and array-of-parts (like extractTextContent in context.ts).
- */
-function extractWorkerText(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content
-		.map((part) =>
-			part && typeof part === "object" && !Array.isArray(part) && typeof (part as { text?: unknown }).text === "string"
-				? (part as { text: string }).text
-				: "",
-		)
-		.filter(Boolean)
-		.join("\n");
-}

package/src/state/locks.ts

@@ -79,6 +79,29 @@ function isLockHolderAlive(filePath: string): boolean {
  * Returns `{ canSteal: true }` if the lock is stale OR the holder is dead
  * (safe to forcibly remove); `{ canSteal: false }` if it is fresh AND held by
  * a live process (must keep waiting).
+ *
+ * ## EPERM Handling (Accepted Risk)
+ *
+ * When `process.kill(pid, 0)` returns EPERM, it means the holder process
+ * EXISTS but we lack permission to signal it. We treat this as "not alive"
+ * (stealable) because:
+ *
+ * 1. **Blocking indefinitely is worse** — on shared systems, a holder running
+ *    under a different user/permission context would block us forever.
+ * 2. **EPERM requires elevated privileges** — on single-user workstations
+ *    (the typical pi-crew environment), EPERM is rare.
+ * 3. **Defense in depth** — the lock staleness check provides a secondary
+ *    safeguard; we only steal if the lock is also stale.
+ *
+ * **Trade-off:** On multi-user systems, this could theoretically allow two
+ * processes in the critical section simultaneously if: (a) holder is alive
+ * under different permissions, AND (b) our steal attempt races with holder's
+ * release. The practical risk is low because:
+ * - Lock holders typically complete quickly
+ * - Stale timeout provides a safety window
+ * - Critical sections are designed to tolerate rare races
+ *
+ * See also: SECURITY-ISSUES.md SEC-008 for documented acceptance.
  */
 function readLockSnapshot(filePath: string, staleMs: number): { canSteal: boolean } {
 	let stat: fs.Stats | undefined;

package/src/state/state-store.ts

@@ -203,6 +203,9 @@ function validateRunManifestPaths(cwd: string, runId: string, manifest: TeamRunM
 }
 
 export function createRunPaths(cwd: string, runId = createRunId()): RunPaths {
+	if (!cwd || typeof cwd !== "string") {
+		throw new Error(`Invalid cwd: ${cwd}`);
+	}
 	assertSafePathId("runId", runId);
 	const baseRoot = scopeBaseRoot(cwd);
 	const stateRoot = resolveContainedRelativePath(path.join(baseRoot, DEFAULT_PATHS.state.runsSubdir), runId, "runId");

package/src/ui/tool-renderers/index.ts

@@ -9,6 +9,7 @@
 import { type Container, Text, visibleWidth } from "@earendil-works/pi-tui";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
 import { truncateToWidth } from "../../utils/visual.ts";
+import { spinnerFrame } from "../spinner.ts";
 import type { CrewTheme } from "../theme-adapter.ts";
 import { formatDuration, formatTokens, truncLine } from "../tool-render.ts";
 import { briefToolResult, isBrief } from "./brief-mode.ts";
@@ -373,9 +374,25 @@ function renderAgentResult(result: Record<string, unknown>, options: unknown, th
 	// isPartial = agent still running
 	const isPartial = (options as Record<string, unknown>)?.isPartial === true;
 	if (isPartial && !ctx.expanded) {
-		const spinner = theme.fg("warning", "◉");
-		const label = theme.fg("muted", "agent working...");
-		contentLines.push(padVisual(` ${spinner} ${label}`, innerW));
+		const spinner = theme.fg("accent", spinnerFrame(d.agentId as string));
+		const parts: string[] = [theme.fg("muted", "working")];
+
+		// Extract progress from onUpdate content (formatCompactToolProgress output)
+		const progressText = extractContentText(result?.content);
+		if (progressText) {
+			const elapsedMatch = progressText.match(/elapsed=(\d+)s/);
+			const tokenMatch = progressText.match(/tokens=(\d+)/);
+			const toolMatch = progressText.match(/tool:\s+(\S+)/);
+			const elapsedSec = elapsedMatch ? parseInt(elapsedMatch[1]!, 10) : 0;
+			const tokens = tokenMatch ? parseInt(tokenMatch[1]!, 10) : 0;
+			const tps = elapsedSec > 0 ? Math.round(tokens / elapsedSec) : 0;
+
+			if (elapsedSec > 0) parts.push(theme.fg("dim", formatDuration(elapsedSec * 1000)));
+			if (tps > 0) parts.push(theme.fg("dim", `${formatTokens(tps)} tok/s`));
+			if (toolMatch) parts.push(theme.fg("dim", `· ${toolMatch[1]}`));
+		}
+
+		contentLines.push(padVisual(` ${spinner} ${parts.join("  ")}`, innerW));
 		return buildFrameBottom(contentLines, w, theme, "borderAccent", "borderAccent");
 	}
 

package/src/ui/widget/widget-formatters.ts

@@ -18,6 +18,7 @@ import { computeLiveDurationMs } from "../live-duration.ts";
 // verbatim (no truncation/crash) — these are rare one-off states, not jitter.
 const TOOLS_METRIC_WIDTH = 8; // "127 tools"
 const TOKENS_METRIC_WIDTH = 10; // "1.2k tok", "12.3M tok"
+const TPS_METRIC_WIDTH = 9; // "411 tok/s"
 const CTX_METRIC_WIDTH = 7; // "100% ctx"
 const DURATION_METRIC_WIDTH = 6; // "120.0s"
 
@@ -139,10 +140,19 @@ export function agentStats(agent: CrewAgentRecord, liveHandle?: LiveAgentHandle)
 			/* ignore */
 		}
 		const ms = computeLiveDurationMs(act);
+		if (total > 0 && ms > 1000) {
+			const tps = Math.round(total / (ms / 1000));
+			if (tps > 0) parts.push(alignMetric(`${formatTokensCompact(tps)}/s`, TPS_METRIC_WIDTH));
+		}
 		parts.push(alignMetric(`${(ms / 1000).toFixed(1)}s`, DURATION_METRIC_WIDTH));
 	} else {
 		if (agent.toolUses) parts.push(alignMetric(`${agent.toolUses} tools`, TOOLS_METRIC_WIDTH));
 		if (agent.progress?.tokens) parts.push(alignMetric(formatTokensCompact(agent.progress.tokens), TOKENS_METRIC_WIDTH));
+		const ageMs = agent.startedAt ? Math.max(0, Date.now() - new Date(agent.startedAt).getTime()) : 0;
+		if (agent.progress?.tokens && ageMs > 1000) {
+			const tps = Math.round(agent.progress.tokens / (ageMs / 1000));
+			if (tps > 0) parts.push(alignMetric(`${formatTokensCompact(tps)}/s`, TPS_METRIC_WIDTH));
+		}
 		const age = elapsed(agent.completedAt ?? agent.startedAt);
 		if (age) parts.push(alignMetric(age, DURATION_METRIC_WIDTH));
 	}