@aeondave/pi-persona 1.15.2 → 1.16.0

package/src/ui/agent-overlay.ts

@@ -23,7 +23,7 @@ import {
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 
-import { type AgentNode, type AgentTree, type FlatRow, flattenTree, GLYPH, runningAnnotation } from "./agent-tree.ts";
+import { type AgentNode, type AgentTree, type FlatRow, deriveWaitingNodeIds, flattenTree, GLYPH, runningAnnotation } from "./agent-tree.ts";
 import { LiveClock } from "./live-clock.ts";
 import { visibleWindow } from "./model-picker.ts";
 import { compactInlineText, OPEN_SEQUENCE_TAIL, sanitizeTerminalText } from "./presentation.ts";
@@ -54,6 +54,7 @@ export interface AgentRowInput {
 	inner: number;
 	now: number;
 	stallMs: number;
+	waitingForSupervisor?: boolean;
 	theme: Theme;
 }
 
@@ -68,7 +69,7 @@ export interface AgentRowInput {
 export function composeAgentRow(input: AgentRowInput): string {
 	const { node, depth, selected, inner, now, stallMs, theme: t } = input;
 	const indent = "  ".repeat(depth);
-	const clock = runningAnnotation(node, now, stallMs);
+	const clock = runningAnnotation(node, now, stallMs, input.waitingForSupervisor);
 	// Reserve the clock's exact width plus its widest separator (" · ") up front — this portion
 	// of the row is never truncated.
 	const clockCols = clock ? visibleWidth(clock) + visibleWidth(" · ") : 0;
@@ -98,6 +99,8 @@ export interface AgentOverlayActions {
 	onSteer?: (nodeId: string, text: string) => boolean;
 	canSteer?: (nodeId: string) => boolean;
 	canStop?: (nodeId: string) => boolean;
+	/** Live predicate for the exact engine handle behind a row. */
+	isWaitingForSupervisor?: (nodeId: string) => boolean;
 	/** Stall threshold for the ⚠ badge; 0/omitted ⇒ no badge. */
 	stallMs?: number;
 	/** Clock; tests inject a fixed one. */
@@ -202,8 +205,11 @@ export class AgentOverlay extends Container {
 		return Math.max(6, termRows() - 10);
 	}
 
-	private leafRows(): FlatRow[] {
-		const snap = this.tree.snapshot();
+	private waitingNodeIds(nodes: readonly AgentNode[] = this.tree.snapshot()): Set<string> {
+		return deriveWaitingNodeIds(nodes, (id) => this.actions.isWaitingForSupervisor?.(id) === true);
+	}
+
+	private leafRows(snap: AgentNode[] = this.tree.snapshot()): FlatRow[] {
 		const parents = new Set(snap.map((n) => n.parentId).filter((p): p is string => p !== undefined));
 		return flattenTree(snap).filter((r) => !parents.has(r.node.id));
 	}
@@ -256,8 +262,9 @@ export class AgentOverlay extends Container {
 
 	private renderList(): void {
 		const t = this.theme;
-		const rows = flattenTree(this.tree.snapshot());
-		const selected = this.selectedLeaf(this.leafRows())?.node;
+		const nodes = this.tree.snapshot();
+		const rows = flattenTree(nodes);
+		const selected = this.selectedLeaf(this.leafRows(nodes))?.node;
 		this.addChild(new Text(t.fg("accent", t.bold("Agents")), 1, 0));
 		this.addChild(new Spacer(1));
 		if (rows.length === 0) {
@@ -265,6 +272,7 @@ export class AgentOverlay extends Container {
 		} else {
 			// Scroll window over the rows (a big fan-out must not overflow the screen);
 			// the window follows the selection, ▲/▼ markers show what's off-screen.
+			const waitingIds = this.waitingNodeIds(nodes);
 			const vp = this.listViewport();
 			const selIdx = Math.max(0, rows.findIndex((r) => r.node.id === selected?.id));
 			this.listScroll = visibleWindow(selIdx, vp, rows.length, this.listScroll);
@@ -278,6 +286,7 @@ export class AgentOverlay extends Container {
 					inner: this.inner(),
 					now: this.now(),
 					stallMs: this.actions.stallMs ?? 0,
+					waitingForSupervisor: waitingIds.has(row.node.id),
 					theme: t,
 				});
 				this.addChild(new Text(composed, 1, 0));

package/src/ui/agent-tree.ts

@@ -65,6 +65,8 @@ export interface RenderOptions {
 	now?: number;
 	/** Quiet time after which a running row shows the stall badge; 0/omitted ⇒ never. */
 	stallMs?: number;
+	/** Live ids whose exact engine handle currently has a pending supervisor ask. */
+	waitingForSupervisor?: ReadonlySet<string>;
 }
 
 /** Whether `detail` is the literal "queued" marker a seeded-but-not-yet-live leg carries — shared
@@ -78,14 +80,43 @@ export function isQueuedMarker(detail: string | undefined): boolean {
  *  for `stallMs`. Undefined for settled nodes, nodes without clock data, or a node still carrying
  *  the "queued" marker — it was seeded ahead of the concurrency gate and has not started running
  *  yet, so its clock (stamped at seed time) has nothing true to report. Pure. */
-export function runningAnnotation(node: Pick<AgentNode, "status" | "startedAt" | "lastAdvanceAt" | "detail">, now: number, stallMs: number): string | undefined {
+export function runningAnnotation(node: Pick<AgentNode, "status" | "startedAt" | "lastAdvanceAt" | "detail">, now: number, stallMs: number, waitingForSupervisor = false): string | undefined {
 	if (node.status !== "running" || node.startedAt === undefined) return undefined;
 	if (isQueuedMarker(node.detail)) return undefined;
+	if (waitingForSupervisor) return "waiting for supervisor";
 	const quietSince = node.lastAdvanceAt ?? node.startedAt;
 	if (stallMs > 0 && now - quietSince >= stallMs) return `⚠ stalled ${formatDuration(now - quietSince)}`;
 	return formatDuration(now - node.startedAt);
 }
 
+/** Derive waiting rows from exact live-handle predicates. A running parent is waiting only when
+ * every live leaf below it is waiting; a progressing or stalled sibling keeps the parent honest. */
+export function deriveWaitingNodeIds(nodes: readonly AgentNode[], isWaiting: (id: string) => boolean): Set<string> {
+	const children = new Map<string, AgentNode[]>();
+	for (const node of nodes) {
+		if (node.parentId === undefined) continue;
+		const list = children.get(node.parentId) ?? [];
+		list.push(node);
+		children.set(node.parentId, list);
+	}
+	const waitingLeaves = new Map<string, { hasLive: boolean; allWaiting: boolean }>();
+	const visit = (node: AgentNode): { hasLive: boolean; allWaiting: boolean } => {
+		if (node.status === "running" && isQueuedMarker(node.detail)) return { hasLive: false, allWaiting: false };
+		const descendants = (children.get(node.id) ?? []).map(visit).filter((state) => state.hasLive);
+		if (node.status !== "running") return { hasLive: descendants.length > 0, allWaiting: descendants.every((state) => state.allWaiting) };
+		if (descendants.length === 0) {
+			const waiting = isWaiting(node.id);
+			if (waiting) waitingLeaves.set(node.id, { hasLive: true, allWaiting: true });
+			return { hasLive: true, allWaiting: waiting };
+		}
+		const allWaiting = descendants.every((state) => state.allWaiting);
+		if (allWaiting) waitingLeaves.set(node.id, { hasLive: true, allWaiting: true });
+		return { hasLive: true, allWaiting };
+	};
+	for (const node of nodes) if (node.parentId === undefined) visit(node);
+	return new Set(waitingLeaves.keys());
+}
+
 /** The tree patch for one progress snapshot: every snapshot is an advance; activity wins over
  *  a bare token count as the visible detail. One helper for every progress site. */
 export function progressPatch(snap: { output?: string; activity?: string; tokens?: number }, now: number): AgentNodePatch {
@@ -121,7 +152,7 @@ export function renderAgentTree(nodes: AgentNode[], opts: RenderOptions = {}): s
 			const branch = isRoot ? "" : isLast ? "└─ " : "├─ ";
 			const label = safeInline(node.label) || safeInline(node.id) || "agent";
 			const detailText = node.detail ? safeInline(node.detail) : "";
-			const clock = opts.now !== undefined ? runningAnnotation(node, opts.now, opts.stallMs ?? 0) : undefined;
+			const clock = opts.now !== undefined ? runningAnnotation(node, opts.now, opts.stallMs ?? 0, opts.waitingForSupervisor?.has(node.id) ?? false) : undefined;
 			const tail = [detailText, clock].filter((s): s is string => Boolean(s)).join(" · ");
 			const detail = tail ? `  ${tail}` : "";
 			lines.push(`${prefix}${branch}${GLYPH[node.status]} ${label}${detail}`);
@@ -246,6 +277,12 @@ export class AgentTree {
 	update(id: string, patch: AgentNodePatch): void {
 		const node = this.nodes.find((n) => n.id === id);
 		if (!node) return;
+		// Parent progress clocks are refreshed on every child tick. They never emit a change;
+		// avoid cloning/comparing the whole node for that common clock-only path.
+		if (Object.keys(patch).every((key) => CLOCK_KEYS.has(key as keyof AgentNode))) {
+			applyPatch(node, patch);
+			return;
+		}
 		const before = { ...node };
 		applyPatch(node, patch);
 		if (!sameNode(before, node)) this.emit({ type: "updated", node: { ...node } });