pi-umbra 0.3.0 → 0.4.0

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/bar.check.ts

@@ -1,12 +1,12 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
-import { MAX_ROWS, layoutList, renderKey, renderLines } from "./bar/bar-line.ts";
+import { MAX_ROWS, countsOf, layoutList, linesFor, renderKey, renderLines, said, stateOf, windowOf, type View } from "./bar/bar-line.ts";
 import type { BranchView, RunState } from "./skills/delegate/state.ts";
 
 // The widget sits directly above the input box, so two things can hurt and both are checked
 // here rather than argued in a comment:
 //
 //   1. a composed line one column too wide wraps in the terminal and pushes the box down
-//   2. the `❯` column pushing a row past the width does the same
+//   2. the `❯` column, the tree guides or the key hint pushing a row past the width does the same
 //
 // Everything under test is pure, so this needs no terminal, no theme and no pi.
 // Run with: bun run bar.check.ts
@@ -63,17 +63,15 @@ const run = (over: Partial<RunState> = {}): RunState =>
 
 const now = 278_000; // 4m 38s
 
-// A phased run draws the same list as a flat one; the panel is where its phases are.
-const phased = run({ branches: [branch()] });
 // A finished run inside its linger window, and the same run once it has faded.
 const settled = run({ live: false, done: 4, branches: [branch({ updatedAt: now, settled: true, alive: false })] });
 
-// ---------- reference 3, the flat list ----------
-
+// One phase: plain subagents, so the branches are the top level. `general-purpose` has one
+// agent under it, which stays folded until enter opens it.
 const flat = run({
-	phases: ["map"], // one phase: no workflow to collapse, so this is the list case
+	phases: ["map"],
 	done: 0,
-	total: 2,
+	total: 3,
 	branches: [
 		branch(),
 		branch({
@@ -86,22 +84,82 @@ const flat = run({
 			activity: "Confirming store.ts is unused",
 			tokens: 86_300,
 			elapsedMs: 172_000, // 2m 52s
-			// Hollow in the reference while its sibling is filled, and a branch that has not
-			// emitted for a quarter of a minute is the one state that can honestly produce that.
-			// The screen cannot tell us which of the two it was; the rule has to mean something,
-			// so it means the thing the panel already tracks.
 			idleMs: 20_000,
 		}),
+		branch({ name: "routes", stem: "map-routes", label: "map:routes", index: 3, activity: "Reading src/server.ts", settled: true, alive: false, status: "done", exitCode: 0 }),
+	],
+});
+
+// Two phases: a workflow, one row named after the run, phases under it, branches under those.
+const phased = run({
+	branches: [
+		branch(),
+		branch({ phase: "design", name: "proposal", stem: "design-proposal", label: "design:proposal", activity: "Writing it up" }),
 	],
 });
 
+const ink = { fg: (_color: unknown, text: string) => text, bold: (text: string) => text }; // measure the plain frame
+const typing: View = { picking: false, cursor: "main", open: [] };
+const pick = (cursor: string, open: string[] = []): View => ({ picking: true, cursor, open });
+
+// ---------- the tree ----------
+
+const top = linesFor(flat, now, []);
+if (top.map((line) => line.node.label).join() !== "general-purpose,routes") fail(`top level: ${top.map((line) => line.node.label)}`);
+if (!top[0]?.folded || top[1]?.folded) fail("only a row with agents under it is folded");
+const opened = linesFor(flat, now, ["b:map-general-purpose"]);
+if (opened.map((line) => `${line.guide}${line.node.label}`).join() !== "general-purpose,└ Explore,routes") fail(`opened: ${opened.map((line) => line.guide + line.node.label)}`);
+if (opened[1]?.path.join() !== "b:map-general-purpose") fail("a child's path is its parent");
+// The open path is one path: an id that is not on it opens nothing.
+if (linesFor(flat, now, ["b:map-routes"]).length !== 2) fail("a leaf in the open path grew rows");
+
+const workflow = linesFor(phased, now, []);
+if (workflow.length !== 1 || workflow[0]?.node.label !== "pi-toolcall-render") fail("a phased run is one workflow row");
+const phases = linesFor(phased, now, ["r:.pi-out/20260905-030000", "p:design"]);
+if (phases.map((line) => `${line.guide}${line.node.label}`).join() !== "pi-toolcall-render,├ Map,└ Design,  └ proposal") {
+	fail(`workflow open: ${phases.map((line) => line.guide + line.node.label)}`);
+}
+if (!phases[1]?.folded) fail("the phase that is not on the open path stays folded");
+
+// ---------- states and counts ----------
+
+if (stateOf(branch()) !== "running") fail("a branch that just wrote is running");
+if (stateOf(branch({ idleMs: 20_000 })) !== "idle") fail("a quiet branch is idle");
+if (stateOf(branch({ settled: true, exitCode: 0, status: "done" })) !== "done") fail("a clean exit is done");
+if (stateOf(branch({ settled: true, exitCode: 143 })) !== "stopped") fail("a killed branch is stopped");
+if (stateOf(branch({ status: "error", settled: true })) !== "stopped") fail("a failed branch is stopped");
+if (stateOf(branch({ pid: null, status: "starting" })) !== "waiting") fail("a branch with no process yet is waiting");
+if (countsOf(flat.branches) !== "1 done · 1 running · 1 idle") fail(`counts: ${countsOf(flat.branches)}`);
+
+// ---------- the window ----------
+
+// The cursor is always inside, and the window plus its "more" rows never outgrow the room.
+for (let n = 0; n <= 30; n++) {
+	for (let room = 0; room <= 10; room++) {
+		for (let at = 0; at < Math.max(1, n); at++) {
+			const [first, end] = windowOf(n, at, room);
+			if (n && room && (at < first || at >= end)) fail(`window ${n}/${room}/${at}: cursor outside [${first}, ${end})`);
+			const arrows = room >= 3 ? Number(first > 0) + Number(end < n) : 0;
+			if (end - first + arrows > room) fail(`window ${n}/${room}/${at}: ${end - first} rows + ${arrows} arrows over ${room}`);
+			if (n > room && room >= 3 && end - first + arrows !== room) fail(`window ${n}/${room}/${at}: a row left empty`);
+		}
+	}
+}
+
+// ---------- the list ----------
+
 for (let width = 8; width <= 200; width++) {
-	for (const state of [flat, undefined, settled]) {
-		const rows = layoutList(width, state, now, MAX_ROWS);
+	for (const [state, view] of [
+		[flat, typing],
+		[flat, pick("b:map-explore", ["b:map-general-purpose"])],
+		[phased, pick("p:design", ["r:.pi-out/20260905-030000", "p:design"])],
+		[undefined, typing],
+		[settled, typing],
+	] as [typeof flat | undefined, View][]) {
+		const rows = layoutList(width, state, now, MAX_ROWS, view);
 		if (rows.length === 0) fail(`list width ${width}: zero rows un-mounts the widget`);
 		for (const row of rows) {
-			const used =
-				visibleWidth(row.head) + visibleWidth(row.activity) + row.fill.length + visibleWidth(row.right);
+			const used = visibleWidth(row.head) + visibleWidth(row.activity) + row.fill.length + visibleWidth(row.right);
 			if (used !== width - 2) fail(`list width ${width}: row composed ${used}, expected ${width - 2}`);
 		}
 		// The activity column has to start in the same place on every row, or the sentences
@@ -111,80 +169,80 @@ for (let width = 8; width <= 200; width++) {
 	}
 }
 
-const list = layoutList(100, flat, now, MAX_ROWS);
-if (list.length !== 3) fail(`expected main + two agents, got ${list.length}`);
+const list = layoutList(120, flat, now, MAX_ROWS);
+if (list.length !== 3) fail(`expected main + two top-level agents, got ${list.length}`);
 // SAFETY: length checked immediately above.
-const [main, first, nested] = list as [(typeof list)[0], (typeof list)[0], (typeof list)[0]];
-if (main.head.trimEnd() !== "○ main") fail(`main row: ${JSON.stringify(main.head)}`);
-if (main.branch !== undefined) fail("the main row is not a branch");
-if (main.activity !== "" || main.right.trim() !== "") fail("the main row carries counters the reference does not show");
-if (first.head.trimEnd() !== "● general-purpose") fail(`agent row: ${JSON.stringify(first.head)}`);
-if (first.dotAt !== 0) fail(`dot column on a top-level row: ${first.dotAt}`);
-if (!first.activity.endsWith("Grepping localStorage keys in office-persist.ts")) fail(`activity: ${first.activity}`);
-if (first.right !== "3m 52s · ↓ 56.5k tokens") fail(`right column: ${JSON.stringify(first.right)}`);
-if (nested.head.trimEnd() !== "└ ○ Explore") fail(`nested row: ${JSON.stringify(nested.head)}`);
-if (nested.dotAt !== 2) fail(`dot column on a nested row: ${nested.dotAt}`);
-if (nested.right !== "2m 52s · ↓ 86.3k tokens") fail(`nested right column: ${JSON.stringify(nested.right)}`);
-
-// An idle session is one bare row.
-const idle = layoutList(100, undefined, now, MAX_ROWS);
-if (idle.length !== 1 || idle[0]?.head.trimEnd() !== "○ main") fail("idle is not exactly one `○ main` row");
-if (layoutList(100, settled, now + 31_000, MAX_ROWS).length !== 1) fail("finished run outstayed LINGER_MS in the list");
-
-// A quiet branch goes hollow, a working one is filled, and the row budget is a ceiling rather
-// than a suggestion.
+const [main, parent, leaf] = list as [(typeof list)[0], (typeof list)[0], (typeof list)[0]];
+if (main.head.trimEnd() !== "● main") fail(`main row: ${JSON.stringify(main.head)}`);
+if (main.activity !== "" || main.right.trim() !== "") fail("the main row carries counters it cannot stand behind");
+if (parent.head.trimEnd() !== "○ general-purpose (+1)") fail(`folded row: ${JSON.stringify(parent.head)}`);
+if (!parent.activity.includes("1 idle · Grepping localStorage keys")) fail(`folded activity: ${parent.activity}`);
+if (parent.right !== "3m 52s · ↓ 56.5k tokens") fail(`right column: ${JSON.stringify(parent.right)}`);
+if (parent.tone !== "accent") fail(`a running row is accent: ${parent.tone}`);
+if (leaf.tone !== "success") fail(`a done row is green: ${leaf.tone}`);
+// However tight the width, a truncated sentence keeps two columns before the clock.
+for (let width = 40; width <= 120; width++) {
+	for (const row of layoutList(width, flat, now, MAX_ROWS).slice(1)) {
+		if (row.activity && row.right.trim() && !/\S {2,}\S/.test(row.activity + row.fill + row.right)) fail(`width ${width}: the sentence runs into the clock`);
+	}
+}
+
 const quiet = layoutList(100, run({ phases: ["map"], branches: [branch({ idleMs: 60_000 })] }), now, MAX_ROWS);
-if (!quiet[1]?.head.startsWith("○")) fail(`an idle branch kept its filled dot: ${quiet[1]?.head}`);
+if (quiet[1]?.tone !== "warning") fail(`an idle branch is yellow: ${quiet[1]?.tone}`);
 
 const many = run({ phases: ["map"], branches: Array.from({ length: 40 }, (_, i) => branch({ stem: `map-b${i}` })) });
 const capped = layoutList(100, many, now, MAX_ROWS);
 if (capped.length !== MAX_ROWS) fail(`row budget ignored: ${capped.length}`);
-if (!capped[MAX_ROWS - 1]?.head.startsWith("+33 more")) fail(`no overflow row: ${capped[MAX_ROWS - 1]?.head}`);
-if (capped[MAX_ROWS - 1]?.dotAt !== -1) fail("the overflow row was given a status dot");
-// A budget of one is `○ main` and nothing else, not `○ main` plus an apology.
+if (!capped[MAX_ROWS - 1]?.head.startsWith("↓ 33 more")) fail(`no "more" row: ${capped[MAX_ROWS - 1]?.head}`);
+if (capped[MAX_ROWS - 1]?.dotAt !== -1) fail("the more row was given a status dot");
+const scrolled = layoutList(100, many, now, MAX_ROWS, pick("b:map-b20"));
+if (!scrolled[1]?.head.startsWith("↑ ") || !scrolled.some((row) => row.id === "b:map-b20")) fail("the window did not follow the cursor");
+// A budget of one is `● main` and nothing else.
 if (layoutList(100, many, now, 1).length !== 1) fail("a one-row budget grew a second row");
-if (layoutList(100, many, now, 2).length !== 2) fail("a two-row budget is main plus the overflow");
 
-// ---------- the fixed-height rule ----------
+// ---------- the frame ----------
 
-const paint = (_color: unknown, text: string) => text; // identity: measure the plain frame
 for (let width = 0; width <= 200; width++) {
-	// Every path through renderLines, at every width, with the cursor on main and on an agent.
 	for (const [label, lines] of [
-		["phased", renderLines(width, phased, now, MAX_ROWS, paint)],
-		["cursor on an agent", renderLines(width, flat, now, MAX_ROWS, paint, false, "map-explore")],
-		["panel open", renderLines(width, phased, now, MAX_ROWS, paint, true)],
-		["idle", renderLines(width, undefined, now, MAX_ROWS, paint)],
-		["list", renderLines(width, flat, now, MAX_ROWS, paint)],
-		["faded", renderLines(width, settled, now + 31_000, MAX_ROWS, paint)],
+		["panel open", renderLines(width, phased, now, MAX_ROWS, ink, true)],
+		["idle", renderLines(width, undefined, now, MAX_ROWS, ink)],
+		["typing", renderLines(width, flat, now, MAX_ROWS, ink)],
+		["picking", renderLines(width, flat, now, MAX_ROWS, ink, false, pick("b:map-explore", ["b:map-general-purpose"]))],
+		["workflow", renderLines(width, phased, now, MAX_ROWS, ink, false, pick("r:.pi-out/20260905-030000"))],
+		["faded", renderLines(width, settled, now + 31_000, MAX_ROWS, ink)],
 	] as [string, string[]][]) {
-		// idle and faded now draw NOTHING, at every width, and that is the assertion - not a
-		// blank line. The slot is belowEditor, where pi passes spacerWhenEmpty and leadingSpacer
-		// both false, so zero lines is zero rows and the footer above never moves. The check
-		// runs width 0..200 because the faded test sits ahead of the narrow-terminal guard;
-		// putting it after would have made a 5-column terminal the one place a bare row survived.
+		// idle and faded draw NOTHING, at every width. The slot is belowEditor, where pi passes
+		// spacerWhenEmpty and leadingSpacer both false, so zero lines is zero rows.
 		if (label === "idle" || label === "faded") {
 			if (lines.length !== 0) fail(`${label} drew ${lines.length} lines at width ${width}, expected none`);
 		} else if (lines.length < 1) {
 			fail(`${label} rendered nothing at width ${width}`);
 		}
 		for (const line of lines) {
-			if (visibleWidth(line) !== Math.max(0, width)) fail(`${label} overflowed at width ${width}: ${line.length}`);
+			if (visibleWidth(line) !== Math.max(0, width)) fail(`${label} overflowed at width ${width}: ${visibleWidth(line)}`);
 		}
 	}
 }
-if (renderLines(80, phased, now, MAX_ROWS, paint, true)[0]?.trim() !== "") fail("the open panel did not blank the widget");
+if (renderLines(80, phased, now, MAX_ROWS, ink, true)[0]?.trim() !== "") fail("the open panel did not blank the widget");
 
 // ---------- the cursor ----------
 
-// `❯` sits on `○ main` while the user types, and on exactly one agent once they move down.
-const onMain = renderLines(100, flat, now, MAX_ROWS, paint);
-if (!onMain[0]?.startsWith(" ❯ ○ main")) fail(`no cursor on main: ${onMain[0]}`);
-if (onMain.filter((line) => line.includes("❯")).length !== 1) fail("more than one cursor with none chosen");
-const onAgent = renderLines(100, flat, now, MAX_ROWS, paint, false, "map-explore");
-if (!onAgent[2]?.startsWith(" ❯ └ ○ Explore")) fail(`cursor not on the chosen agent: ${onAgent[2]}`);
-if (onAgent.filter((line) => line.includes("❯")).length !== 1) fail("the cursor stayed on main as well");
-if (!renderLines(100, phased, now, MAX_ROWS, paint)[1]?.includes("● general-purpose")) fail("a phased run did not draw its agents");
+// Typing: no `❯` and no hint. Picking: one `❯`, on the cursor's row, and the hint on top.
+const typed = renderLines(100, flat, now, MAX_ROWS, ink);
+if (typed.some((line) => line.includes("❯")) || typed.some((line) => line.includes("esc back"))) fail("typing drew the cursor or the hint");
+const picked = renderLines(100, flat, now, MAX_ROWS, ink, false, pick("b:map-explore", ["b:map-general-purpose"]));
+if (!picked[0]?.includes("↑↓ select") || picked[0]?.includes("enter")) fail(`hint on a leaf: ${picked[0]}`);
+if (!picked[3]?.startsWith(" ❯ └ ○ Explore")) fail(`cursor not on the chosen agent: ${picked[3]}`);
+if (picked.filter((line) => line.includes("❯")).length !== 1) fail("more than one cursor");
+const onMain = renderLines(100, flat, now, MAX_ROWS, ink, false, pick("main", ["b:map-general-purpose"]));
+if (!onMain[1]?.startsWith(" ❯ ● main") || !onMain[0]?.includes("enter collapse all")) fail(`cursor on main: ${onMain.slice(0, 2)}`);
+if (!renderLines(100, flat, now, MAX_ROWS, ink, false, pick("b:map-general-purpose"))[0]?.includes("enter expand")) fail("a folded row does not offer enter");
+
+// A declared phase with no branches yet has not run: grey, not a green "done".
+const declared = layoutList(120, run({ phases: ["map", "design"], branches: [branch()] }), now, MAX_ROWS, pick("p:design", ["r:.pi-out/20260905-030000"]));
+if (declared.find((row) => row.id === "p:design")?.tone !== "dim") fail("an empty phase looks finished");
+// An open path that matches nothing opens nothing, so main does not offer to fold it.
+if (renderLines(100, flat, now, MAX_ROWS, ink, false, pick("main", ["b:gone"]))[0]?.includes("collapse all")) fail("main offered to fold a tree that is not open");
 
 // ---------- the no-op frame ----------
 
@@ -195,4 +253,13 @@ if (renderKey(flat, now) === renderKey(flat, now + 1_000)) fail("the clock moved
 const rewritten = run({ ...flat, branches: [branch({ activity: "Reading hooks.server.ts and app.d.ts" }), ...flat.branches.slice(1)] });
 if (renderKey(flat, now) === renderKey(rewritten, now)) fail("the activity sentence changed and the key did not");
 
+// A write branch that finished with changes says where they are; a read-only one says what it said.
+const git = { root: "/r", branch: "fan/r/build-fix", base: "abc", stat: "+1 −0 · 1 file" };
+const wrote = branch({ settled: true, exitCode: 0, activity: "Done", git });
+if (said(wrote) !== "Changed +1 −0 · 1 file on fan/r/build-fix") fail(`write branch row: ${said(wrote)}`);
+// Committed work outlives a timeout, and the row says both.
+const late = branch({ settled: true, exitCode: 124, timedOut: true, activity: "Editing", git });
+if (said(late) !== "Timed out · Changed +1 −0 · 1 file on fan/r/build-fix") fail(`timed-out write row: ${said(late)}`);
+if (said(branch({ settled: true, exitCode: 0, activity: "Done" })) !== "Done") fail("a read-only branch keeps its own sentence");
+
 console.log("ok");

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/bar.ts

@@ -1,15 +1,16 @@
 import { CustomEditor, type ExtensionAPI, type ExtensionContext, type KeybindingsManager, type Theme } from "@earendil-works/pi-coding-agent";
 import { Editor, isKeyRelease, matchesKey, type Component, type EditorTheme, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
-import { faded, layoutList, MARK, MAX_ROWS, renderKey, renderLines } from "./bar/bar-line.ts";
-import type { RunState } from "./skills/delegate/state.ts";
+import { faded, linesFor, MAIN, MAX_ROWS, renderKey, renderLines, type Line } from "./bar/bar-line.ts";
+import type { BranchView, RunState } from "./skills/delegate/state.ts";
 
 // Part 3: everything the widget slot below the input box draws, and the ways it opens into the
 // full panel of reference 1.
 //
-// One shape, the way Claude Code draws it: `○ main` on top, one row per agent, `└` for a nested
-// one, and `❯` on the row the user is on. Down at the end of the editor moves the `❯` into the
-// list, ↑↓ walk it, enter opens the panel on that agent, and up past the first agent, esc or
-// any other key hands the keyboard back to the editor.
+// Claude Code's agent tree: `● main` on top, one row per agent, one level open at a time. Down at
+// the end of the editor moves the `❯` into the list; ↑↓ walk it, enter opens or closes the row
+// under the cursor (on main it folds everything), x stops the row and everything under it, and
+// alt+a opens the panel on it. Up past main, esc or any other key hands the keyboard back to the
+// editor.
 //
 // The widget is mounted once at session_start and never removed. It asks for belowEditor, and
 // repatch.mjs moves that slot below pi's status line. The slot grows a Spacer(1) the moment it holds anything, so registering and
@@ -37,10 +38,12 @@ class BarComponent implements Component {
 		private tui: TUI,
 		private theme: Theme,
 		private onOpen: (stem?: string) => void,
+		private onStop: (branch: BranchView) => void,
 	) {}
 
-	// The stems the last frame drew, in order: the cursor only walks rows the user can see.
-	private stems: string[] = [];
+	// Every row of the open tree, not just the ones in the window: the list scrolls to follow
+	// the cursor, so the cursor walks all of them.
+	private lines: Line[] = [];
 	private release: (() => void) | undefined;
 
 	render(width: number): string[] {
@@ -48,24 +51,27 @@ class BarComponent implements Component {
 		// it per frame costs nothing and keeps the list inside a shrunk window.
 		const budget = Math.max(1, Math.min(MAX_ROWS, this.tui.terminal.rows - RESERVE));
 		const now = Date.now();
-		this.stems = layoutList(width - MARK, current, now, budget).flatMap((row) => (row.branch ? [row.branch.stem] : []));
-		// A row that left the list (the run faded, the panel took over) takes the cursor with it.
-		if (cursor && !this.stems.includes(cursor)) this.leave();
-		return renderLines(width, current, now, budget, (color, text) => this.theme.fg(color, text), panelOpen, cursor);
+		this.lines = linesFor(current, now, open);
+		// A row that left the tree takes the cursor back to main; a tree with nothing left in it
+		// hands the keyboard back to the editor.
+		if (this.release && !this.lines.length) this.leave();
+		else if (cursor !== MAIN && !this.lines.some((line) => line.node.id === cursor)) cursor = MAIN;
+		return renderLines(width, current, now, budget, this.theme, panelOpen, { picking: !!this.release, cursor, open });
 	}
 
 	/** Down at the end of the editor: the `❯` moves onto the first agent. The keys go through an
 	 *  input listener rather than a focus change, because the editor keeps its text, its cursor
 	 *  and its focus while the user looks down the list. */
 	enter(): void {
-		if (this.release || panelOpen || !this.stems[0]) return;
-		cursor = this.stems[0];
+		const first = this.lines[0];
+		if (this.release || panelOpen || !first) return;
+		cursor = first.node.id;
 		this.release = this.tui.addInputListener((data) => this.key(data));
 		this.refresh();
 	}
 
 	private leave(): void {
-		cursor = undefined;
+		cursor = MAIN;
 		this.release?.();
 		this.release = undefined;
 		this.refresh();
@@ -81,15 +87,33 @@ class BarComponent implements Component {
 			this.leave();
 			return undefined;
 		}
-		const index = this.stems.indexOf(cursor ?? "");
-		if (matchesKey(data, "down")) cursor = this.stems[Math.min(index + 1, this.stems.length - 1)];
+		// Read now, not from the last frame: an enter that opened or closed a row may not have
+		// been painted yet when the next key arrives.
+		this.lines = linesFor(current, Date.now(), open);
+		const ids = [MAIN, ...this.lines.map((line) => line.node.id)];
+		const index = ids.indexOf(cursor);
+		const line = this.lines.find((candidate) => candidate.node.id === cursor);
+		if (matchesKey(data, "down")) cursor = ids[Math.min(index + 1, ids.length - 1)] ?? MAIN;
 		else if (matchesKey(data, "up")) {
+			// Up from main is up out of the list, and the key is spent: the editor would
+			// otherwise read it as a walk back through the prompt history.
 			if (index <= 0) this.leave();
-			else cursor = this.stems[index - 1];
-		} else if (matchesKey(data, "enter") || matchesKey(data, "right")) {
-			const stem = cursor;
+			else cursor = ids[index - 1] ?? MAIN;
+		} else if (matchesKey(data, "enter")) {
+			// Enter on main folds everything back to the top level. On a row with agents under
+			// it, it opens that row and closes every other, or closes it again. On a leaf there
+			// is nothing to open.
+			if (!line) open = [];
+			else if (line.node.children.length) open = open[line.path.length] === line.node.id ? line.path : [...line.path, line.node.id];
+		} else if (line && (matchesKey(data, "x") || matchesKey(data, "shift+x"))) {
+			// The row and everything under it. A settled branch's pid belongs to whatever the OS
+			// handed it to next, so it is skipped here as well as in the producer.
+			for (const branch of line.node.branches) if (!branch.settled) this.onStop(branch);
+		} else if (matchesKey(data, "alt+a")) {
+			const stem = line?.node.branch?.stem;
 			this.leave();
 			this.onOpen(stem);
+			return { consume: true };
 		} else if (matchesKey(data, "escape")) this.leave();
 		else {
 			// Typing goes on where it was: the key reaches the editor as if the list were not there.
@@ -162,13 +186,17 @@ let current: RunState | undefined;
 let panelOpen = false;
 let bar: BarComponent | undefined;
 let lastKey = "";
-// The stem the `❯` is on while the list has the keyboard; undefined leaves it on `○ main`.
-let cursor: string | undefined;
+// The row the `❯` is on while the list has the keyboard, and the one path of the tree that is
+// open. Both outlive a rebuilt widget, so a /reload does not fold the tree back up.
+let cursor = MAIN;
+let open: string[] = [];
 
 /** The bar holds no state and owns no timer: the reader that already polls `<cwd>/.pi-out` for
  *  the panel calls this every tick, so the two views can never disagree about the same run and
  *  only one thing is ever walking the disk. */
 export const setRun = (run: RunState | undefined) => {
+	// A different run starts folded: ids from the last one could match a new row by stem.
+	if (run?.dir !== current?.dir) open = [];
 	current = run;
 	const key = renderKey(run, Date.now());
 	if (key === lastKey) return;
@@ -176,11 +204,15 @@ export const setRun = (run: RunState | undefined) => {
 	bar?.refresh();
 };
 
-export const installBar = (pi: ExtensionAPI, openPanel: (ctx: ExtensionContext, stem?: string) => Promise<void> | void) => {
+export const installBar = (
+	pi: ExtensionAPI,
+	openPanel: (ctx: ExtensionContext, stem?: string) => Promise<void> | void,
+	stop: (branch: BranchView) => void,
+) => {
 	// `quiet` is the down arrow and the click: both fire whether or not a run exists, and a
 	// notification on every press of a key the user meant as "move the cursor" is noise. The
 	// command and the shortcut were typed on purpose, so those get told why nothing happened.
-	const open = (ctx: ExtensionContext, quiet = false, stem?: string) => {
+	const show = (ctx: ExtensionContext, quiet = false, stem?: string) => {
 		if (panelOpen) return quiet ? undefined : ctx.ui.notify("agent panel is already open");
 		// Opening on nothing would draw an empty box the user cannot fill. The quiet doors also
 		// skip a run the bar has already let go of: a key meant as "move the cursor" should not
@@ -210,7 +242,7 @@ export const installBar = (pi: ExtensionAPI, openPanel: (ctx: ExtensionContext,
 		ctx.ui.setWidget(
 			BAR_KEY,
 			(tui, theme) => {
-				bar = new BarComponent(tui, theme, (stem) => open(ctx, true, stem));
+				bar = new BarComponent(tui, theme, (stem) => show(ctx, true, stem), stop);
 				return bar;
 			},
 			{ placement: "belowEditor" },
@@ -224,6 +256,6 @@ export const installBar = (pi: ExtensionAPI, openPanel: (ctx: ExtensionContext,
 
 	// Not ctrl+<letter>: every one is already bound by pi, and extension shortcuts are matched
 	// before app keybindings, so one would silently shadow a built-in.
-	pi.registerShortcut("alt+a", { description: "Open the agent panel", handler: (ctx) => open(ctx) });
-	pi.registerCommand("umb-agents", { description: "Open the agent panel", handler: async (_args, ctx) => open(ctx) });
+	pi.registerShortcut("alt+a", { description: "Open the agent panel", handler: (ctx) => show(ctx) });
+	pi.registerCommand("umb-agents", { description: "Open the agent panel", handler: async (_args, ctx) => show(ctx) });
 };

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/fan/index.ts

@@ -2,8 +2,8 @@ import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@e
 import { installBar, setRun } from "../bar.ts";
 import { openPanel, type PanelSource } from "../panel.ts";
 import { canReach, describeOffer, fanSettings, forget, offerModels, reachableModels, RUN_SH, type Offer } from "./models.ts";
-import { findBlock, parseSpec, TEMPLATE, type RunSpec } from "./spec.ts";
-import { piCommand, reportOf, store } from "./store.ts";
+import { findBlock, parseSpec, TEMPLATE } from "./spec.ts";
+import { piCommand, reportOf, store, type RunSpec } from "./store.ts";
 import type { RunState } from "../skills/delegate/state.ts";
 
 // Wiring only. store.ts owns the branches, bar.ts and panel.ts render them.
@@ -16,7 +16,8 @@ import type { RunState } from "../skills/delegate/state.ts";
 // A branch that stopped on a question goes to the model first: most questions are answered by
 // the conversation the branch never saw, and only the rest reach the user.
 const askingNote = (run: RunState): string => {
-	const asking = run.branches.filter((branch) => branch.report === "ASKING");
+	// A write branch cannot be continued: its worktree closed when it ended.
+	const asking = run.branches.filter((branch) => branch.report === "ASKING" && !branch.git);
 	if (!asking.length) return "";
 	return (
 		`\n\n${asking.map((branch) => branch.stem).join(", ")} stopped on a question. Answer it from this ` +
@@ -27,6 +28,14 @@ const askingNote = (run: RunState): string => {
 	);
 };
 
+// A `[write]` branch leaves its work on a git branch, and merging it is always the user's call:
+// the model asks, then does what they chose. reportOf already carries each branch's merge and
+// discard commands.
+const mergeNote = (run: RunState): string =>
+	run.branches.some((branch) => branch.git?.stat)
+		? "\n\nAsk the user with ask_user_question, one question per changed branch, whether to merge it, and do only what they choose."
+		: "";
+
 // A branch starts with --no-extensions, so a model that only an extension provides is not there
 // for it. Rather than guess another one, the model asks the user: which model to spend on is
 // theirs to choose.
@@ -52,7 +61,7 @@ const source: PanelSource = {
 export default function (pi: ExtensionAPI) {
 	// The widget above the editor, the alt+a shortcut, the /umb-agents command and the down arrow
 	// out of the last editor line. All four open the same panel over the same source.
-	installBar(pi, (ctx, stem) => openPanel(ctx, source, stem));
+	installBar(pi, (ctx, stem) => openPanel(ctx, source, stem), source.stop);
 	// The bar is pushed to rather than polling a second time: store already ticks once a
 	// second while branches are live, and a second reader could only disagree with it.
 	store.subscribe(() => setRun(store.run()));
@@ -61,10 +70,19 @@ export default function (pi: ExtensionAPI) {
 	// A run the delegate skill started in bash is left alone: that caller reads $run/*.md
 	// itself, and a follow-up would hand the model the same text twice.
 	let awaiting: string | undefined;
+	// A run the user started with /umb-fan is theirs to read on the panel, but work a write
+	// branch committed must not go unmentioned once the row has faded.
+	let watching: { dir: string; ctx: ExtensionContext } | undefined;
 
 	// Branches must not outlive the pi that started them: nothing would be watching, and a
 	// branch left running keeps spending. Their reports are already on disk.
-	pi.on("session_shutdown", () => store.stopAll());
+	pi.on("session_shutdown", () => {
+		// A ctx from the session that is ending throws on every use once it is gone, and the
+		// children killed below still settle after this.
+		awaiting = undefined;
+		watching = undefined;
+		store.stopAll();
+	});
 
 	// A bash call may be the delegate skill mid-run. Arming the tick when one starts is what
 	// makes a skill-started run appear on the bar from its first frame rather than at the end;
@@ -93,7 +111,16 @@ export default function (pi: ExtensionAPI) {
 			if (reply) pi.sendUserMessage(modelNote(missing, offer), { deliverAs: "followUp" });
 			return undefined;
 		}
-		const dir = store.start(spec, fallback, ctx.cwd, brief, settings);
+		let dir: string | undefined;
+		try {
+			dir = store.start(spec, fallback, ctx.cwd, brief, settings);
+		} catch (error) {
+			// A [write] branch outside a git repo, a worktree git refused, a full disk: nothing started.
+			const reason = error instanceof Error ? error.message.split("\n")[0] : String(error);
+			ctx.ui.notify(`fan: ${reason}`, "warning");
+			if (reply) pi.sendUserMessage(`The fan run did not start: ${reason}`, { deliverAs: "followUp" });
+			return undefined;
+		}
 		if (!dir) ctx.ui.notify("fan: a run is already in flight — stop it from the panel first", "warning");
 		return dir;
 	};
@@ -121,9 +148,26 @@ export default function (pi: ExtensionAPI) {
 	// that asked for them already ended, so the model reads them at the top of the next one.
 	store.subscribe(() => {
 		const run = store.run();
+		if (run && run.dir === watching?.dir && !run.live) {
+			const { ctx } = watching;
+			watching = undefined;
+			const left = run.branches.filter((branch) => branch.git?.stat || branch.git?.error);
+			if (left.length) {
+				ctx.ui.notify(
+					`fan: ${left.map((branch) => (branch.git?.error ? `${branch.stem} could not be committed (${branch.git.error})` : `${branch.stem} changed ${branch.git?.stat} on ${branch.git?.branch}`)).join("; ")}. Ask the session about it.`,
+					"info",
+				);
+				// The session learns the branches and their merge commands with the next message the
+				// user sends, without a turn of its own: asked to merge, it must not guess `git merge`.
+				pi.sendMessage(
+					{ customType: "umbra-fan", content: `Branch results for ${run.name}, a run the user started:\n\n${reportOf(run)}`, display: false },
+					{ deliverAs: "nextTurn" },
+				);
+			}
+		}
 		if (!run || run.dir !== awaiting || run.live) return;
 		awaiting = undefined;
-		pi.sendUserMessage(`Branch results for ${run.name}:\n\n${reportOf(run)}${askingNote(run)}`, { deliverAs: "followUp" });
+		pi.sendUserMessage(`Branch results for ${run.name}:\n\n${reportOf(run)}${askingNote(run)}${mergeNote(run)}`, { deliverAs: "followUp" });
 	});
 
 	pi.registerCommand("umb-fan", {
@@ -135,7 +179,8 @@ export default function (pi: ExtensionAPI) {
 			if (!spec) return ctx.ui.notify("fan: no branches in that spec", "warning");
 			// Started by the user, so the results are theirs to read on the panel; the model is
 			// only told about a run it asked for itself. launch says why when nothing started.
-			await launch(spec, ctx, text, false);
+			const dir = await launch(spec, ctx, text, false);
+			if (dir) watching = { dir, ctx };
 		},
 	});
 }