pi-claude-code-ui 1.0.70 → 1.0.72

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 > [!IMPORTANT]
 > **1.0.69 — package rename (permanent).** Canonical npm name is now [`pi-claude-code-ui`](https://www.npmjs.com/package/pi-claude-code-ui). `pi-claude-style-tools` is legacy and will not receive further releases. Install with `pi install npm:pi-claude-code-ui` or `npm i pi-claude-code-ui`.
 
+## 1.0.72 — 2026-07-18
+
+### Changed
+
+- **Agent tools breathe** — `Agent` / subagent tools use a size cycle while pending (`⬤ → ● → • → (invisible) → • → ●`) instead of the ordinary on/off `●` blink, so agent work reads as a different kind of tool.
+
+## 1.0.71 — 2026-07-18
+
+### Fixed
+
+- **Long-running tools no longer freeze their status dots** — the 15s stale watchdog was treating quiet tools (no `tool_execution_update`) as leaked and killing the blink timer mid-run. While an agent is live the timer now heartbeats itself; stale cleanup only runs after the agent finishes. Also stop clearing blink state on `turn_end` (turns end before tools run).
+
 ## 1.0.70 — 2026-07-17
 
 ### Fixed

package/extensions/index.ts

@@ -434,10 +434,16 @@ function isToolExecutionLike(value: unknown): value is { toolName: string; toolC
 	return typeof candidate.toolName === "string" && typeof candidate.toolCallId === "string";
 }
 
+const AGENT_FAMILY_TOOL_NAMES = new Set(["Agent", "Agents", "get_subagent_result", "steer_subagent"]);
+
+function isAgentFamilyToolName(name: unknown): boolean {
+	return typeof name === "string" && AGENT_FAMILY_TOOL_NAMES.has(name);
+}
+
 function shouldIndentToolExecution(value: unknown): boolean {
 	if (!value || typeof value !== "object") return false;
 	const toolName = (value as Record<string, unknown>).toolName;
-	return typeof toolName === "string" && ["Agent", "Agents", "get_subagent_result", "steer_subagent"].includes(toolName);
+	return isAgentFamilyToolName(toolName);
 }
 
 function isTerminalImageLine(line: string): boolean {
@@ -541,9 +547,11 @@ function getToolGroupOverallStatus(tools: any[]): ToolStatus {
 
 // Claude Code: solid filled circle that is either fully present or fully gone
 // while pending — never a hollow outlined ○. Classic ● + bold is the sweet
-// spot (⬤ was too large in most mono fonts).
+// spot for ordinary tools. Agent-family tools use a breathing size cycle.
 const STATUS_DOT_FILLED = "●";
 const STATUS_DOT_BOLD = "\x1b[1m";
+// big → medium → small → invisible → small → medium (then back to big)
+const AGENT_BREATHE_GLYPHS = ["⬤", "●", "•", " ", "•", "●"] as const;
 
 function paintStatusDot(colorAnsi: string): string {
 	return `${colorAnsi}${STATUS_DOT_BOLD}${STATUS_DOT_FILLED}${TRANSPARENT_RESET}`;
@@ -554,6 +562,12 @@ function themeStatusDot(theme: Theme, colorKey: "success" | "error" | "dim" | "m
 	return theme.fg(colorKey, `${STATUS_DOT_BOLD}${STATUS_DOT_FILLED}`);
 }
 
+function agentBreatheDot(theme: Theme): string {
+	const glyph = AGENT_BREATHE_GLYPHS[_globalBlinkPhaseIndex % AGENT_BREATHE_GLYPHS.length];
+	if (glyph === " ") return " ";
+	return theme.fg("success", `${STATUS_DOT_BOLD}${glyph}`);
+}
+
 function groupStatusLight(status: ToolStatus): string {
 	const color = status === "success" ? TOOL_STATUS_SUCCESS : status === "error" ? TOOL_STATUS_ERROR : TOOL_STATUS_PENDING;
 	if (status === "pending") {
@@ -2590,9 +2604,10 @@ function indentBranchBlock(block: string): string {
 
 const MAX_BLINKING_TOOLS = 5;
 const BLINK_INTERVAL_MS = 500;
-// If no streaming event occurs for this long, assume blink entries are leaked
-// (a tool completed without clearing, or the turn ended without turn_end) and
-// stop the re-render storm. Prevents idle TUI crashes and unbounded memory growth.
+// Safety net ONLY for leaked entries after the agent has stopped. Quiet
+// long-running tools (sleep, sparse builds, waiting on network) legitimately
+// emit no tool_execution_update for minutes — treating that silence as "stale"
+// is what made their ● freeze mid-run.
 const BLINK_STALE_TIMEOUT_MS = 15000;
 let _lastBlinkActivity = 0;
 
@@ -2605,6 +2620,9 @@ type BlinkEntry = { key: any; order: number; invalidate: () => void };
 const _blinkContexts = new Map<any, BlinkEntry>();
 let _globalBlinkTimer: ReturnType<typeof setTimeout> | null = null;
 let _blinkOrder = 0;
+// Shared phase for all blinkers. Ordinary tools use even/odd (on/off ●).
+// Agent-family tools map the index onto a 6-step size breath cycle.
+let _globalBlinkPhaseIndex = 0;
 let _globalBlinkPhase = true;
 
 function getBlinkIntervalMs(): number {
@@ -2632,6 +2650,18 @@ function updateBlinkActiveStates(): void {
 	}
 }
 
+function _clearAllBlinkContexts(): void {
+	for (const entry of _blinkContexts.values()) {
+		try { entry.key._blinkActive = false; } catch { /* noop */ }
+	}
+	_blinkContexts.clear();
+	if (_globalBlinkTimer) {
+		clearTimeout(_globalBlinkTimer);
+		_globalBlinkTimer = null;
+	}
+	updateBlinkActiveStates();
+}
+
 function _scheduleGlobalBlinkTimer(): void {
 	if (_globalBlinkTimer) return;
 	const intervalMs = getBlinkIntervalMs();
@@ -2642,18 +2672,17 @@ function _scheduleGlobalBlinkTimer(): void {
 			updateBlinkActiveStates();
 			return;
 		}
-		// Watchdog: if nothing has streamed for a while, the remaining entries are
-		// almost certainly leaked. Clear them and stop re-arming so we don't keep
-		// forcing full TUI re-renders while idle (render-assertion crash / OOM).
-		if (_lastBlinkActivity && Date.now() - _lastBlinkActivity > BLINK_STALE_TIMEOUT_MS) {
-			for (const entry of _blinkContexts.values()) {
-				try { entry.key._blinkActive = false; } catch { /* noop */ }
-			}
-			_blinkContexts.clear();
-			updateBlinkActiveStates();
+		// While an agent run is live, quiet tools are still in flight — keep blinking.
+		// Heartbeat here so sparse/no-output commands never look "stale".
+		if (currentAgentWorkStartMs !== undefined) {
+			markBlinkActivity();
+		} else if (_lastBlinkActivity && Date.now() - _lastBlinkActivity > BLINK_STALE_TIMEOUT_MS) {
+			// Agent already finished; leftover entries are leaks. Stop the re-render storm.
+			_clearAllBlinkContexts();
 			return;
 		}
-		_globalBlinkPhase = !_globalBlinkPhase;
+		_globalBlinkPhaseIndex = (_globalBlinkPhaseIndex + 1) % AGENT_BREATHE_GLYPHS.length;
+		_globalBlinkPhase = _globalBlinkPhaseIndex % 2 === 0;
 		for (const entry of getBlinkingEntries()) {
 			try { entry.invalidate(); } catch { /* noop */ }
 		}
@@ -2675,12 +2704,18 @@ function setupBlinkTimer(ctx: any): void {
 	const invalidate = typeof ctx?.invalidate === "function" ? () => safeInvalidate(ctx) : () => {};
 	const existing = _blinkContexts.get(key);
 	if (existing) {
-		// Already tracked — just refresh the invalidate fn, skip expensive recalc
+		// Already tracked — refresh invalidate + ensure the global timer is alive.
+		// If a prior watchdog/pass stopped the timer without removing this entry
+		// (or the timer simply died), a quiet long-running tool would otherwise
+		// stay registered forever with a frozen ●.
 		existing.invalidate = invalidate;
+		markBlinkActivity();
+		_scheduleGlobalBlinkTimer();
 		return;
 	}
 	_blinkContexts.set(key, { key, order: ++_blinkOrder, invalidate });
 	key._blinkActive = false;
+	markBlinkActivity();
 	updateBlinkActiveStates();
 	_stopGlobalBlinkTimerIfEmpty();
 	_scheduleGlobalBlinkTimer();
@@ -2709,9 +2744,13 @@ function blinkDot(ctx: any, theme: Theme): string {
 	}
 	setupBlinkTimer(ctx);
 	const key = getBlinkKey(ctx);
+	if (key?._blinkActive !== true) return " ";
+	// Agent-family tools breathe through sizes; ordinary tools still on/off ●.
+	if (ctx?.state?._agentBreathe === true) {
+		return agentBreatheDot(theme);
+	}
 	// Claude Code: solid filled circle that either shows or fully disappears —
 	// never a hollow outlined ○ in the off phase.
-	if (key?._blinkActive !== true) return " ";
 	return _globalBlinkPhase ? themeStatusDot(theme, "success") : " ";
 }
 
@@ -4905,6 +4944,8 @@ function genericToolLabel(name: string): string {
 function renderGenericToolCall(name: string, args: any, theme: Theme, ctx: any): Text {
 	syncToolCallStatus(ctx);
 	ctx.state._openAiPatchFiles = [];
+	// Agent / subagent tools get a size-breathing pending marker, not on/off ●.
+	if (isAgentFamilyToolName(name)) ctx.state._agentBreathe = true;
 	const sp = (path: string) => shortPath(ctx.cwd ?? process.cwd(), path);
 	const summary = stableCallSummary(ctx, "_callSummary", () => summarizeGenericToolCall(name, args, theme, sp));
 	return makeText(
@@ -6768,66 +6809,40 @@ export default function (pi: ExtensionAPI) {
 		registerMcpToolOverrides();
 	});
 
-	// Streaming activity keeps the blink timer alive; agent_end clears leaked
-	// entries so the re-render loop can't keep running while idle.
+	// Streaming activity keeps the blink timer alive. Do NOT clear blink contexts
+	// on turn_end — a turn ends when the assistant message finishes, BEFORE its
+	// tools run. agent_end / agent_settled are the real "work finished" signals.
 	pi.on("turn_start", async () => { markBlinkActivity(); });
 	pi.on("message_start", async () => { markBlinkActivity(); });
 	pi.on("message_update", async () => { markBlinkActivity(); });
 	pi.on("tool_execution_start", async () => { markBlinkActivity(); });
 	// Partial tool output is the main long-running signal (bash streams for minutes).
-	// Without this, the 15s stale watchdog can kill blink while a quiet command runs.
 	pi.on("tool_execution_update", async () => { markBlinkActivity(); });
 	pi.on("tool_execution_end", async () => { markBlinkActivity(); });
+	// agent_end fires when a low-level run finishes (tools for that assistant message
+	// are done). registerThinkingLabels clears currentAgentWorkStartMs on the same
+	// event; defer so we only wipe blink state once the work marker is gone.
+	// Do not use agent_settled here — older peer types don't include it, and the
+	// live-agent heartbeat already keeps quiet long tools blinking until agent_end.
 	pi.on("agent_end", async () => {
-		markBlinkActivity();
-		for (const entry of _blinkContexts.values()) {
-			entry.key._blinkActive = false;
-		}
-		_blinkContexts.clear();
-		if (_globalBlinkTimer) {
-			clearTimeout(_globalBlinkTimer);
-			_globalBlinkTimer = null;
-		}
-	});
-
-	// Safety net: clear blink timers after a turn's tools finish.
-	// Keep Shiki hlCache across turns — it's an LRU (CACHE_LIMIT=48) and
-	// re-highlighting the same diffs every turn was a free long-chat tax.
-	// Full clear still happens on session_shutdown / theme rebind.
-	pi.on("turn_end", async () => {
-		for (const entry of _blinkContexts.values()) {
-			entry.key._blinkActive = false;
-		}
-		_blinkContexts.clear();
-		if (_globalBlinkTimer) {
-			clearTimeout(_globalBlinkTimer);
-			_globalBlinkTimer = null;
-		}
+		queueMicrotask(() => {
+			if (currentAgentWorkStartMs !== undefined) {
+				markBlinkActivity();
+				return;
+			}
+			_clearAllBlinkContexts();
+		});
 	});
 	// Session rebuild (resume/reload/fork) must not leave history partials blinking.
 	pi.on("session_start", async () => {
-		for (const entry of _blinkContexts.values()) {
-			entry.key._blinkActive = false;
-		}
-		_blinkContexts.clear();
-		if (_globalBlinkTimer) {
-			clearTimeout(_globalBlinkTimer);
-			_globalBlinkTimer = null;
-		}
+		_clearAllBlinkContexts();
 	});
 	pi.on("session_shutdown", async () => {
-		for (const entry of _blinkContexts.values()) {
-			entry.key._blinkActive = false;
-		}
-		_blinkContexts.clear();
+		_clearAllBlinkContexts();
 		clearRtkRewriteState();
 		WRITE_EXISTED_BEFORE.clear();
 		clearHighlightCache();
 		invalidateThemePaletteCache();
 		bumpToolBranchVisualEpoch();
-		if (_globalBlinkTimer) {
-			clearTimeout(_globalBlinkTimer);
-			_globalBlinkTimer = null;
-		}
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-claude-code-ui",
-  "version": "1.0.70",
+  "version": "1.0.72",
   "description": "Claude Code-style grouped tool rows for pi with Ctrl+O/Ctrl+Shift+O previews, math rendering, and consistent built-in, MCP, and custom tool rendering",
   "keywords": [
     "pi-package",