pi-claude-code-ui 1.0.73 → 1.0.75

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.75 — 2026-07-29
+
+### Fixed
+
+- **Herdr progress with spinner verbs** — themed working messages (`Cooking…`, `Syncing…`, …) no longer break [herdr](https://herdr.dev) agent progress. Stock herdr pi screen detection only matches literal `Working...`; when `HERDR_ENV=1` the spinner now reports `working` / `idle` over herdr’s socket (same `herdr:pi` lifecycle authority as the official pi integration). Spinner UI and verbs are unchanged. Outside herdr the extension is a no-op for this path.
+
+## 1.0.74 — 2026-07-18
+
+### Fixed
+
+- **Grouped tool boxes keep Agent breathe aligned** — group rows strip all breathe glyphs (including `·` and the blank off-phase) before re-prefixing a fresh light, so titles no longer walk sideways. Group header/child lights also follow the shared blink phase (and Agent breathe) instead of wall-clock `isBlinkOn()`.
+
 ## 1.0.73 — 2026-07-18
 
 ### Fixed

package/extensions/index.ts

@@ -559,20 +559,33 @@ function themeStatusDot(theme: Theme, colorKey: "success" | "error" | "dim" | "m
 	return theme.fg(colorKey, `${STATUS_DOT_BOLD}${STATUS_DOT_FILLED}`);
 }
 
-function agentBreatheDot(theme: Theme): string {
+function agentBreatheGlyphRaw(): string {
 	// Always exactly one display cell — matches ordinary tool dots, keeps titles aligned.
-	const glyph = AGENT_BREATHE_GLYPHS[_globalBlinkPhaseIndex % AGENT_BREATHE_LEN];
+	return AGENT_BREATHE_GLYPHS[_globalBlinkPhaseIndex % AGENT_BREATHE_LEN];
+}
+
+function paintAgentBreatheDot(colorAnsi: string = TOOL_STATUS_SUCCESS): string {
+	const glyph = agentBreatheGlyphRaw();
 	if (glyph === " ") return " ";
 	// Bold only on the largest frame so weight changes without shifting the cell.
 	const bold = glyph === "●" ? STATUS_DOT_BOLD : "";
+	return `${colorAnsi}${bold}${glyph}${TRANSPARENT_RESET}`;
+}
+
+function agentBreatheDot(theme: Theme): string {
+	const glyph = agentBreatheGlyphRaw();
+	if (glyph === " ") return " ";
+	const bold = glyph === "●" ? STATUS_DOT_BOLD : "";
 	return theme.fg("success", `${bold}${glyph}`);
 }
 
-function groupStatusLight(status: ToolStatus): string {
+function groupStatusLight(status: ToolStatus, options?: { agentBreathe?: boolean }): string {
 	const color = status === "success" ? TOOL_STATUS_SUCCESS : status === "error" ? TOOL_STATUS_ERROR : TOOL_STATUS_PENDING;
 	if (status === "pending") {
-		// On phase: solid green. Off phase: disappear completely (space keeps alignment).
-		return isBlinkOn() ? paintStatusDot(TOOL_STATUS_SUCCESS) : " ";
+		// Prefer the shared blink phase over wall-clock so group lights stay in sync
+		// with the global timer (and Agent breathe). Space keeps column alignment.
+		if (options?.agentBreathe) return paintAgentBreatheDot(TOOL_STATUS_SUCCESS);
+		return _globalBlinkPhase ? paintStatusDot(TOOL_STATUS_SUCCESS) : " ";
 	}
 	return paintStatusDot(color);
 }
@@ -610,7 +623,13 @@ function stripToolChrome(lines: string[]): string[] {
 }
 
 function stripLeadingToolStatus(line: string): string {
-	return line.replace(/^((?:\x1b\[[0-9;]*m|[ \t]|[├└│─])*)(?:\x1b\[[0-9;]*m)*[●○✗■⬤•](?:\x1b\[[0-9;]*m)*\s+/, "$1");
+	// Drop the single-cell status marker so group rows can re-prefix a fresh light.
+	// Include Agent breathe glyphs (·) and the blank off-phase (space) so the title
+	// never keeps a leftover marker that shifts when size changes.
+	return line.replace(
+		/^((?:\x1b\[[0-9;]*m|[ \t]|[├└│─])*)(?:\x1b\[[0-9;]*m)*(?:[●○✗■⬤•·]| )(?:\x1b\[[0-9;]*m)*\s+/,
+		"$1",
+	);
 }
 
 function trimAnsiLeft(text: string): string {
@@ -684,19 +703,30 @@ function branchContinuation(index: number, total: number, theme?: Theme): string
 	return index === total - 1 ? "   " : ` ${rule}│${TRANSPARENT_RESET} `;
 }
 
-function formatBranchedToolLines(lines: string[], index: number, total: number, width: number, status: ToolStatus): string[] {
+function formatBranchedToolLines(
+	lines: string[],
+	index: number,
+	total: number,
+	width: number,
+	status: ToolStatus,
+	options?: { agentBreathe?: boolean },
+): string[] {
 	const output: string[] = [];
 	const content = lines.filter((line) => isTerminalImageLine(line) || stripAnsi(line).trim().length > 0);
 	const safeContent = content.length > 0 ? content : [""];
-	const light = groupStatusLight(status);
+	const light = groupStatusLight(status, options);
 	for (let lineIndex = 0; lineIndex < safeContent.length; lineIndex++) {
 		const line = safeContent[lineIndex];
 		if (isTerminalImageLine(line)) {
 			output.push(line);
 			continue;
 		}
+		// Always strip any leftover status marker from the child call line before
+		// re-prefixing. Agent breathe used · which the old stripper missed, so the
+		// title walked sideways as size changed inside groups.
+		const body = lineIndex === 0 ? removeGroupedToolPrefix(line) : trimAnsiLeft(line);
 		const prefix = lineIndex === 0 ? `${branchPrefix(index, total)}${light} ` : `${branchContinuation(index, total)}  `;
-		output.push(clampLineWidth(`${prefix}${trimAnsiLeft(line)}`, width));
+		output.push(clampLineWidth(`${prefix}${body}`, width));
 	}
 	return output;
 }
@@ -818,7 +848,11 @@ class ToolGroupComponent extends Container {
 		const label = getToolGroupLabel(this.tools);
 		const names = groupedName ? "" : formatToolNameList(this.tools);
 		const overall: ToolStatus = status.error > 0 ? "error" : status.pending > 0 ? "pending" : "success";
-		const light = groupStatusLight(overall);
+		// Group header breathes only when every pending member is Agent-family;
+		// mixed groups keep the ordinary on/off light.
+		const pendingTools = this.tools.filter((tool) => getToolStatusForGroup(tool) === "pending");
+		const headerBreathe = pendingTools.length > 0 && pendingTools.every((tool) => isAgentFamilyToolName(getToolName(tool)));
+		const light = groupStatusLight(overall, { agentBreathe: headerBreathe });
 		const summaryLabel = `${label}:`;
 		const countParts: string[] = [];
 		if (status.pending) countParts.push(statusText("pending", status.pending));
@@ -835,7 +869,14 @@ class ToolGroupComponent extends Container {
 			const rawLines = this.expanded
 				? getExpandedToolGroupLines(tool, childWidth, groupedName ? label : undefined)
 				: [getCompactToolLine(tool, childWidth, groupedName ? label : undefined)];
-			const branched = formatBranchedToolLines(rawLines, index, total, safeWidth, getToolStatusForGroup(tool));
+			const branched = formatBranchedToolLines(
+				rawLines,
+				index,
+				total,
+				safeWidth,
+				getToolStatusForGroup(tool),
+				{ agentBreathe: isAgentFamilyToolName(getToolName(tool)) },
+			);
 			for (let i = 0; i < branched.length; i++) {
 				lines.push(clampLineWidth(branched[i], safeWidth));
 			}

package/extensions/spinner.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import net from "node:net";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Loader } from "@earendil-works/pi-tui";
@@ -509,6 +510,162 @@ function statusText(text: string): string {
 	return `${STATUS_DIM}${text}${RESET}`;
 }
 
+// ---------------------------------------------------------------------------
+// Herdr lifecycle reporting
+//
+// Stock herdr pi screen detection only matches the literal "Working...".
+// This extension replaces that text with themed spinner verbs (Cooking…,
+// Syncing…, …), so herdr sidebars go idle/stale while pi is actually busy.
+// When running inside herdr (HERDR_ENV=1), report working/idle over the
+// socket the same way herdr's official pi integration does. UI is unchanged.
+// ---------------------------------------------------------------------------
+
+type HerdrAgentState = "working" | "idle";
+
+const HERDR_ENV = process.env.HERDR_ENV;
+const HERDR_SOCKET_PATH = process.env.HERDR_SOCKET_PATH;
+const HERDR_SOCKET_ENDPOINT =
+	process.platform === "win32" && HERDR_SOCKET_PATH
+		? `\\\\.\\pipe\\${HERDR_SOCKET_PATH}`
+		: HERDR_SOCKET_PATH;
+const HERDR_PANE_ID = process.env.HERDR_PANE_ID;
+// Must be exactly "herdr:pi" — herdr only grants full lifecycle authority
+// (skip screen-manifest fallback) to that official source pair with agent "pi".
+const HERDR_SOURCE = "herdr:pi";
+
+function herdrEnabled(): boolean {
+	return HERDR_ENV === "1" && !!HERDR_SOCKET_PATH && !!HERDR_PANE_ID;
+}
+
+function herdrSendAttempt(request: unknown, timeoutMs: number): Promise<boolean> {
+	if (!herdrEnabled()) return Promise.resolve(true);
+
+	return new Promise((resolve) => {
+		let done = false;
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		const finish = (delivered: boolean) => {
+			if (done) return;
+			done = true;
+			if (timeout) clearTimeout(timeout);
+			socket.destroy();
+			resolve(delivered);
+		};
+
+		const socket = net.createConnection(HERDR_SOCKET_ENDPOINT!);
+		socket.on("error", () => finish(false));
+		socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+		socket.on("data", () => finish(true));
+		socket.on("end", () => finish(false));
+		timeout = setTimeout(() => finish(false), timeoutMs);
+		unrefTimer(timeout);
+	});
+}
+
+async function herdrSend(request: unknown): Promise<void> {
+	if (await herdrSendAttempt(request, 500)) return;
+	await herdrSendAttempt(request, 1500);
+}
+
+let herdrReportSeq = Date.now() * 1000;
+let herdrSessionId: string | undefined;
+let herdrSessionPath: string | undefined;
+let herdrSendInFlight = false;
+let herdrQueued: { state: HerdrAgentState; seq: number } | undefined;
+let herdrLastState: HerdrAgentState | undefined;
+
+function herdrNextSeq(): number {
+	herdrReportSeq += 1;
+	return herdrReportSeq;
+}
+
+function herdrUpdateSessionRef(ctx: any): void {
+	try {
+		const file = ctx?.sessionManager?.getSessionFile?.();
+		herdrSessionPath =
+			typeof file === "string" && file.startsWith("/") ? file : undefined;
+	} catch {
+		herdrSessionPath = undefined;
+	}
+
+	try {
+		const id = ctx?.sessionManager?.getSessionId?.();
+		herdrSessionId = typeof id === "string" && id.length > 0 ? id : undefined;
+	} catch {
+		herdrSessionId = undefined;
+	}
+}
+
+function herdrWithSessionRef(params: Record<string, unknown>): Record<string, unknown> {
+	if (herdrSessionPath) return { ...params, agent_session_path: herdrSessionPath };
+	if (herdrSessionId) return { ...params, agent_session_id: herdrSessionId };
+	return params;
+}
+
+function herdrCurrentSessionRef(): Record<string, unknown> | undefined {
+	if (herdrSessionPath) return { agent_session_path: herdrSessionPath };
+	if (herdrSessionId) return { agent_session_id: herdrSessionId };
+	return undefined;
+}
+
+function herdrReportSession(sessionStartSource?: string): Promise<void> {
+	const sessionRef = herdrCurrentSessionRef();
+	if (!sessionRef) return Promise.resolve();
+
+	return herdrSend({
+		id: `${HERDR_SOURCE}:session:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+		method: "pane.report_agent_session",
+		params: {
+			pane_id: HERDR_PANE_ID,
+			source: HERDR_SOURCE,
+			agent: "pi",
+			seq: herdrNextSeq(),
+			session_start_source: sessionStartSource,
+			...sessionRef,
+		},
+	});
+}
+
+function herdrSendState(state: HerdrAgentState, seq = herdrNextSeq()): Promise<void> {
+	return herdrSend({
+		id: `${HERDR_SOURCE}:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+		method: "pane.report_agent",
+		params: herdrWithSessionRef({
+			pane_id: HERDR_PANE_ID,
+			source: HERDR_SOURCE,
+			agent: "pi",
+			state,
+			seq,
+		}),
+	});
+}
+
+function herdrQueueState(state: HerdrAgentState): void {
+	herdrQueued = { state, seq: herdrNextSeq() };
+	if (!herdrSendInFlight) void herdrDrainQueue();
+}
+
+async function herdrDrainQueue(): Promise<void> {
+	if (herdrSendInFlight) return;
+	herdrSendInFlight = true;
+	try {
+		while (herdrQueued) {
+			const next = herdrQueued;
+			herdrQueued = undefined;
+			await herdrSendState(next.state, next.seq);
+		}
+	} finally {
+		herdrSendInFlight = false;
+		if (herdrQueued) void herdrDrainQueue();
+	}
+}
+
+function herdrPublishState(state: HerdrAgentState, force = false): void {
+	if (!herdrEnabled()) return;
+	if (!force && state === herdrLastState) return;
+	herdrLastState = state;
+	herdrQueueState(state);
+}
+
 // ---------------------------------------------------------------------------
 // Extension
 // ---------------------------------------------------------------------------
@@ -545,6 +702,9 @@ export default function (pi: ExtensionAPI) {
 	let turnActive = false;
 	let lastWorkingMessage: string | null = null;
 	let activeCtx: { ui: any; hasUI: boolean } | null = null;
+	// Root interactive session only — nested/non-UI contexts must not fight
+	// herdr state authority for this pane.
+	let herdrRootSession = false;
 
 	function getEffortSuffix(): string {
 		try {
@@ -709,6 +869,31 @@ export default function (pi: ExtensionAPI) {
 		restoreDefaultWorkingMessage();
 	}
 
+	function herdrMarkWorking(ctx?: any): void {
+		if (!herdrRootSession) return;
+		if (ctx) herdrUpdateSessionRef(ctx);
+		void herdrReportSession();
+		herdrPublishState("working");
+	}
+
+	function herdrMarkIdle(ctx?: any, force = false): void {
+		if (!herdrRootSession) return;
+		if (ctx) herdrUpdateSessionRef(ctx);
+		herdrPublishState("idle", force);
+	}
+
+	// session_start: claim root UI session + announce native session identity.
+	pi.on("session_start", async (event, ctx) => {
+		if (!herdrEnabled()) return;
+		if (ctx?.hasUI !== true) return;
+		herdrRootSession = true;
+		herdrUpdateSessionRef(ctx);
+		await herdrReportSession((event as any)?.reason);
+		// Reload mid-run: isIdle() false means work is still in flight.
+		const working = ctx?.isIdle?.() === false;
+		herdrPublishState(working ? "working" : "idle", true);
+	});
+
 	function onThinkingEnd(): void {
 		if (thinkingStatus !== "thinking") return;
 		const duration = Date.now() - thinkingStartTime;
@@ -728,8 +913,9 @@ export default function (pi: ExtensionAPI) {
 		if (!agentStartTime) agentStartTime = Date.now();
 	});
 
-	pi.on("agent_start", async () => {
+	pi.on("agent_start", async (_event, ctx) => {
 		if (!agentStartTime) agentStartTime = Date.now();
+		herdrMarkWorking(ctx);
 	});
 
 	pi.on("turn_start", async (_event, ctx) => {
@@ -749,6 +935,9 @@ export default function (pi: ExtensionAPI) {
 			scheduleThoughtStatusClear();
 		}
 		startRefreshLoop();
+		// turn_start is the earliest UI-visible busy signal; cover cases where
+		// agent_start already fired or is ordering-sensitive across reloads.
+		herdrMarkWorking(ctx);
 	});
 
 	pi.on("message_update", async (event, ctx) => {
@@ -843,9 +1032,23 @@ export default function (pi: ExtensionAPI) {
 		clearDisplay();
 	});
 
+	// Prefer agent_settled over agent_end: pi may still auto-retry, compact, or
+	// drain a follow-up queue after agent_end. Settled means truly idle.
+	// Cast: agent_settled landed after some older @earendil-works/pi-coding-agent
+	// type packages still used for local typecheck; runtime pi has the event.
+	(pi as ExtensionAPI & {
+		on(event: "agent_settled", handler: (event: unknown, ctx: any) => void | Promise<void>): void;
+	}).on("agent_settled", async (_event, ctx) => {
+		if (!herdrRootSession) return;
+		if (ctx?.isIdle?.() !== true) return;
+		herdrMarkIdle(ctx);
+	});
+
 	pi.on("session_shutdown", async () => {
 		turnActive = false;
 		clearDisplay();
+		herdrMarkIdle(undefined, true);
+		herdrRootSession = false;
 		activeCtx = null;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-claude-code-ui",
-  "version": "1.0.73",
+  "version": "1.0.75",
   "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",