pi-umbra 0.3.1 → 0.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 Every pi-umbra package in one install: seven dark themes, tool calls drawn as cards, a
 status footer, an input bar with the session name, a working line that names the running
-tool, parallel read-only branches with a live panel, and the `/umb-*` commands.
+tool, parallel pi branches (read-only, or editing in their own git worktree) with a live agent tree, and the `/umb-*` commands.
 
 ![A one-minute tour: tool cards and diffs, the working line, a question from the model, parallel branches, the card settings and the seven themes](https://raw.githubusercontent.com/grknbyk/pi-umbra/main/assets/demo.webp)
 
@@ -10,7 +10,7 @@ tool, parallel read-only branches with a live panel, and the `/umb-*` commands.
 pi install npm:pi-umbra
 ```
 
-The ten packages ship bundled inside this one tarball. Three of them patch pi's bundle, so
+The nine packages ship bundled inside this one tarball. Three of them patch pi's bundle, so
 run the three scripts once now and again after every pi update, then restart pi:
 
 ```sh
@@ -26,11 +26,10 @@ node ~/.pi/agent/npm/node_modules/pi-umbra/node_modules/pi-umbra-subagents/patch
 | [pi-umbra-ask](https://www.npmjs.com/package/pi-umbra-ask) | a tool the model calls to ask you a question and wait |
 | [pi-umbra-shimmer](https://www.npmjs.com/package/pi-umbra-shimmer) | a wave of colour through the working line, `/umb-shimmer` |
 | [pi-umbra-skill-matcher](https://www.npmjs.com/package/pi-umbra-skill-matcher) | `/name` runs `skill:name`, completion mid-sentence |
-| [pi-umbra-rename](https://www.npmjs.com/package/pi-umbra-rename) | `/umb-rename`, session name and terminal title |
 | [pi-umbra-copy-chat](https://www.npmjs.com/package/pi-umbra-copy-chat) | `/umb-copy-chat`, the session on the clipboard |
 | [pi-umbra-preview](https://www.npmjs.com/package/pi-umbra-preview) | `/umb-preview`, render a document in the browser |
 | [pi-umbra-help](https://www.npmjs.com/package/pi-umbra-help) | `/umb-help` and `/umb-doctor` |
-| [pi-umbra-subagents](https://www.npmjs.com/package/pi-umbra-subagents) | parallel read-only pi branches with a live panel, `/umb-fan`, `/umb-loop` |
+| [pi-umbra-subagents](https://www.npmjs.com/package/pi-umbra-subagents) | parallel pi branches, read-only or in their own git worktree, with a live agent tree, `/umb-fan`, `/umb-loop` |
 
 Full documentation: [github.com/grknbyk/pi-umbra](https://github.com/grknbyk/pi-umbra).
 

package/node_modules/pi-umbra-copy-chat/README.md

@@ -47,12 +47,9 @@ When it is done, pi shows the size, for example `42 KB on the clipboard.`
 
 ## Clipboard
 
-| System | Program |
-|---|---|
-| Linux | `xclip` (X11 only) |
-| macOS | `pbcopy` |
-| Windows | `clip` |
-
-On Wayland, change the `linux` entry of the `COPY` table in the extension to `["wl-copy"]`.
+The text goes through pi's own clipboard writer, the one `/copy` uses: `wl-copy`, `xclip` or
+`xsel` on Linux, the native clipboard on macOS and Windows, and OSC 52 over SSH. When none
+works, pi says which program to install. pi caps OSC 52 at about 73 KB of text, so over SSH a long
+session may be too big to copy.
 
 MIT.

package/node_modules/pi-umbra-copy-chat/extensions/umbra-copy-chat.ts

@@ -1,7 +1,4 @@
-import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { platform } from "node:os";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 
 // /umb-copy-chat puts this session on the clipboard as markdown, in full, and does nothing else.
 // No file is written, no model turn is spent, nothing is uploaded.
@@ -26,30 +23,9 @@ const PREAMBLE = `> Kaydedilmiş bir pi oturumu, bağlam olarak yapıştırıld
 > da terk edilmiş olabilir), \`## call\` / \`## result\` gerçekten çalışmış araç
 > çağrıları. Oku, sonra asıl isteği bekle.`;
 
-// One copy command per platform. On Linux this is the X11 one; swap it for
-// ["wl-copy"] on a Wayland session.
-const COPY: Record<string, string[]> = {
-	win32: ["clip"],
-	darwin: ["pbcopy"],
-	linux: ["xclip", "-selection", "clipboard"],
-};
-
 type Block = { type: string; text?: string; thinking?: string; name?: string; arguments?: unknown };
 type Message = { role: string; content: unknown; toolName?: string; isError?: boolean };
-type Entry = { id?: string; parentId?: string; type?: string; timestamp?: string; message?: Message };
-
-/** The turns still on the board. */
-// A rewind (pi's /fork) does not delete anything: it writes the new turn with its parentId
-// pointing at an older message, and the turns it walked back over stay in the file. Reading
-// the lines in order would hand the reader both the abandoned attempt and the one that
-// replaced it, with nothing marking which is which. Walking parentId back from the last
-// entry is what the runtime itself is showing on screen.
-export const activeBranch = (rows: Entry[]): Entry[] => {
-	const byId = new Map(rows.map((row) => [row.id, row]));
-	const chain: Entry[] = [];
-	for (let row = rows[rows.length - 1]; row !== undefined; row = byId.get(row.parentId ?? "")) chain.unshift(row);
-	return chain;
-};
+type Entry = { type?: string; timestamp?: string; message?: Message };
 
 /** `2026-09-07 00:31` the first time and on each new day, `00:31` in between. */
 export const stamp = (iso: string, lastDay: string | undefined): [string, string] => {
@@ -81,15 +57,13 @@ const textOf = (content: unknown): string =>
 				.join("")
 				.trim();
 
-export const transcribe = (jsonl: string): string => {
-	const rows = jsonl
-		.split("\n")
-		.filter((line) => line.trim() !== "")
-		.map((line) => JSON.parse(line) as Entry);
-
+/** The branch on screen, as pi hands it over: root to leaf, the turns a rewind or a /tree walked
+ *  back over already left out. Taken from pi rather than from the session file, because only pi
+ *  knows the leaf after a /tree with no new message yet. */
+export const transcribe = (branch: Entry[]): string => {
 	const out: string[] = [];
 	let day: string | undefined;
-	for (const row of activeBranch(rows)) {
+	for (const row of branch) {
 		// session, model_change, thinking_level_change, custom_message and session_info.
 		if (row.type !== "message" || row.message === undefined) continue;
 		const { role, content, toolName, isError } = row.message;
@@ -121,34 +95,22 @@ export const transcribe = (jsonl: string): string => {
 	return out.join("\n");
 };
 
-const copy = (text: string) =>
-	new Promise<boolean>((resolve) => {
-		const argv = COPY[platform()];
-		if (!argv) return resolve(false);
-		const child = spawn(argv[0] as string, argv.slice(1));
-		// A missing binary arrives as an "error" event, not a throw, so both paths resolve.
-		child.on("error", () => resolve(false));
-		child.on("close", (code) => resolve(code === 0));
-		child.stdin.end(text);
-	});
-
 export default function (pi: ExtensionAPI) {
 	pi.registerCommand("umb-copy-chat", {
 		description: "Copy this whole session to the clipboard as markdown",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
-			const sessionFile = ctx.sessionManager.getSessionFile();
-			if (!sessionFile) return ctx.ui.notify("No session file yet - send one message first.", "warning");
-
-			const body = transcribe(readFileSync(sessionFile, "utf8"));
+			const body = transcribe(ctx.sessionManager.getBranch() as Entry[]);
 			if (body === "") return ctx.ui.notify("Nothing to copy yet.", "warning");
 
 			const markdown = `${PREAMBLE}\n\n${body}`;
-			const copied = await copy(markdown);
-			const kb = Math.max(1, Math.round(markdown.length / 1024));
-			ctx.ui.notify(
-				copied ? `${kb} KB on the clipboard.` : `Could not reach the clipboard on ${platform()}.`,
-				copied ? "info" : "error",
-			);
+			// pi's own /copy writer: wl-copy, xclip, xsel, the native clipboard or OSC 52, whichever
+			// works here. It throws with the install hint when none does.
+			try {
+				await copyToClipboard(markdown);
+			} catch (error) {
+				return ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+			ctx.ui.notify(`${Math.max(1, Math.round(markdown.length / 1024))} KB on the clipboard.`, "info");
 		},
 	});
 }

package/node_modules/pi-umbra-copy-chat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-copy-chat",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "/copy-chat puts the conversation on the clipboard.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-help/checks/umbra-help.check.ts

@@ -6,6 +6,7 @@ import assert from "node:assert";
 import { type Facts, PROBES, announcesTruecolor, diagnose, renderDoctor, renderHelp, shadowed } from "../extensions/umbra-help.ts";
 
 const clean: Facts = {
+	packages: ["pi-umbra", "pi-claude-bridge"],
 	patches: Object.fromEntries(PROBES.map((probe) => [probe.id, true])),
 	commands: ["umb-shimmer", "umb-bg", "umb-help"],
 	skillRoots: [{ root: "/a", names: ["adhd"] }],
@@ -112,4 +113,12 @@ assert.match(help, /"background": "auto"/, "the live settings, not a description
 assert.match(help, /umb-doctor/, "and a pointer to the other half");
 assert.match(renderHelp([], {}, "dark"), /No umb- command is registered/);
 
-console.log("umbra-help.check.ts ok - diagnose 11 cases, truecolor 7, shadowed 4, help 6");
+// A package umbra dropped still loads without a word from pi, so the doctor names it.
+const stale = diagnose(at({ packages: ["pi-umbra", "pi-umbra-rename"] }));
+assert.equal(stale.length, 1, "a retired package listed in settings is reported");
+assert.match(stale[0]!.title, /pi-umbra-rename is no longer part of umbra/);
+assert.match(stale[0]!.detail, /pi remove npm:pi-umbra-rename/, "with the command that removes it");
+const loose = diagnose(at({ commands: [...clean.commands, "umb-rename"] }));
+assert.match(loose[0]!.detail, /still registered by something/, "a leftover file is found by its command");
+
+console.log("umbra-help.check.ts ok - diagnose 14 cases, truecolor 7, shadowed 4, help 6");

package/node_modules/pi-umbra-help/extensions/umbra-help.ts

@@ -49,7 +49,15 @@ export const PROBES: Probe[] = [
 	},
 ];
 
+// Packages that were umbra once and are not any more, with what replaced them. An install that
+// still carries one runs code nobody maintains, and pi never says so: the package loads fine.
+export const RETIRED: { name: string; command: string; why: string }[] = [
+	{ name: "pi-umbra-rename", command: "umb-rename", why: "pi's own /name sets the session name and the terminal title since pi 1.0" },
+];
+
 export type Facts = {
+	/** The npm packages listed in the global and the project settings, without the `npm:` prefix. */
+	packages: string[];
 	/** Probe id to whether its marker is in place. */
 	patches: Record<string, boolean>;
 	/** The umb- commands this session actually registered. */
@@ -86,6 +94,18 @@ export const shadowed = (roots: Facts["skillRoots"]): { name: string; winner: st
 export const diagnose = (facts: Facts): Finding[] => {
 	const findings: Finding[] = [];
 
+	for (const retired of RETIRED) {
+		const listed = facts.packages.includes(retired.name);
+		if (!listed && !facts.commands.includes(retired.command)) continue;
+		findings.push({
+			level: "warn",
+			title: `${retired.name} is no longer part of umbra`,
+			detail: listed
+				? `${retired.why}. Remove it: pi remove npm:${retired.name}`
+				: `${retired.why}, but /${retired.command} is still registered by something. Delete the file that adds it.`,
+		});
+	}
+
 	for (const probe of PROBES) {
 		if (facts.patches[probe.id] !== false) continue;
 		// A patch nothing depends on is not a fault. Only say so when the feature is installed.
@@ -210,9 +230,20 @@ export const gather = (cwd: string, theme: string, commands: Command[]): Facts =
 		for (const probe of PROBES) patches[probe.id] = has(chunks, probe.marker);
 	}
 
+	// Settings list a package as "npm:name", "npm:name@1.2" or { source: "npm:name" }.
+	const packages = [join(AGENT, "settings.json"), join(cwd, ".pi", "settings.json")].flatMap((file) => {
+		try {
+			const list = (JSON.parse(readFileSync(file, "utf8")).packages ?? []) as (string | { source?: string })[];
+			return list.map((entry) => (typeof entry === "string" ? entry : (entry.source ?? "")));
+		} catch {
+			return [];
+		}
+	});
+
 	// The order pi resolves them in, which is the order that decides a collision.
 	const roots = [join(AGENT, "skills"), join(cwd, ".pi", "skills"), join(homedir(), ".agents", "skills")];
 	return {
+		packages: packages.filter((source) => source.startsWith("npm:")).map((source) => source.slice(4).replace(/(.)@.*$/, "$1")),
 		patches,
 		commands: commands.map((command) => command.name),
 		skillRoots: roots.map((root) => ({ root, names: namesIn(root) })).filter((entry) => entry.names.length > 0),

package/node_modules/pi-umbra-help/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-help",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Two commands over the pi-umbra family: /umb-help lists what is installed and how to configure it, /umb-doctor reports the faults that would otherwise stay silent.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-inputbar/README.md

@@ -33,7 +33,7 @@ The colour is kept in `~/.pi/agent/input-color` and applies to every session.
 
 ## Session name
 
-The name set with `/name` or `/umb-rename` sits at the right end of the top border and shows
+The name set with `/name` sits at the right end of the top border and shows
 on the next repaint. When the border has no room for it, it is left out.
 
 ## For extension authors

package/node_modules/pi-umbra-inputbar/extensions/umbra-inputbar.ts

@@ -1,7 +1,7 @@
 // The input bar: the session name on its top border (right side) and /umb-color for its border
 // colour. Both ride on pi's own extension point - ctx.ui.setEditorComponent with a subclass of
 // CustomEditor - so no bundle patch is involved. The name is read from pi.getSessionName() at
-// every render, so /umb-rename shows on the next repaint; /umb-color persists in
+// every render, so /name shows on the next repaint; /umb-color persists in
 // ~/.pi/agent/input-color.
 import { CustomEditor, type ExtensionAPI, type ExtensionContext, type KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import { isKeyRepeat, visibleWidth, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";

package/node_modules/pi-umbra-inputbar/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-umbra-inputbar",
-  "version": "0.1.4",
-  "description": "pi's input bar, rebuilt: a chevron prompt, the session name on the border, a colour you pick, and a command to rename the session.",
+  "version": "0.1.5",
+  "description": "pi's input bar, rebuilt: a chevron prompt, the session name on the border, a colour you pick.",
   "keywords": [
     "pi-package",
     "pi",

package/node_modules/pi-umbra-shimmer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-shimmer",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A wave of colour running through pi's working indicator, over both the spinner and the text. Needs the umbra bundle patches; without them it does nothing.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-shimmer/patch.mjs

@@ -60,8 +60,11 @@ const PATCHES = [
 		// wave: the spinner colour function was skipped for them while the message kept being
 		// repainted every frame. Verbatim still holds when no shimmer is installed.
 		reason: "and paints the custom frames too",
-		from: `return this.renderIndicatorVerbatim?frame2:this.spinnerColorFn(frame2)`,
-		to: `return this.renderIndicatorVerbatim&&!globalThis.__umbraShimmer?frame2:this.spinnerColorFn(frame2)`,
+		// pi 1.0 bundles the same line with the local named `frame` rather than `frame2`.
+		variants: ["frame2", "frame"].map((name) => ({
+			from: `return this.renderIndicatorVerbatim?${name}:this.spinnerColorFn(${name})`,
+			to: `return this.renderIndicatorVerbatim&&!globalThis.__umbraShimmer?${name}:this.spinnerColorFn(${name})`,
+		})),
 	},
 	{
 		// The working indicator paints its spinner with `accent` and its message with `muted`, both
@@ -79,33 +82,32 @@ const CHECK = process.argv.includes("--check");
 const unapplied = [];
 const gone = [];
 
-for (const patch of PATCHES) {
-	let done = false;
+// One patch, every file read once: "applied", "unapplied" (--check), or undefined when gone.
+const apply = (patch) => {
 	for (const path of files) {
 		const source = readFileSync(path, "utf8");
 		// A multi-line patch is written with newline escapes; match whatever line ending the file uses.
 		const eol = source.includes("\r\n") ? "\r\n" : "\n";
-		const from = patch.from.split("\n").join(eol);
-		const to = patch.to.split("\n").join(eol);
-		if (source.includes(to)) {
-			if (!CHECK) console.log(`already patched: ${patch.reason}`);
-			done = true;
-			break;
-		}
-		if (!source.includes(from)) continue;
-		if (CHECK) {
-			unapplied.push(patch.reason);
-			done = true;
-			break;
+		for (const variant of patch.variants ?? [patch]) {
+			const from = variant.from.split("\n").join(eol);
+			const to = variant.to.split("\n").join(eol);
+			if (source.includes(to)) return "applied";
+			if (!source.includes(from)) continue;
+			if (CHECK) return "unapplied";
+			writeFileSync(path, source.replace(from, to));
+			console.log(`patched: ${patch.reason}`);
+			return "applied";
 		}
-		writeFileSync(path, source.replace(from, to));
-		console.log(`patched: ${patch.reason}`);
-		done = true;
-		break;
 	}
+	return undefined;
+};
+
+for (const patch of PATCHES) {
+	const result = apply(patch);
+	if (result === "unapplied") unapplied.push(patch.reason);
 	// Neither the original text nor the patched text is there, so pi changed the code this
 	// patch names. Report it rather than force anything.
-	if (!done) gone.push(patch.reason);
+	else if (!result) gone.push(patch.reason);
 }
 
 for (const reason of unapplied) console.log(`NOT APPLIED: ${reason}`);

package/node_modules/pi-umbra-skill-matcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-skill-matcher",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Type /huh and reach skill:huh. pi lists every skill under its bare name, which is not the name that dispatches.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-skill-matcher/patch.mjs

@@ -58,6 +58,7 @@ const PATCHES = [
 	},
 	{
 		reason: "the command list names skills without the prefix too",
+		needs: "/huh instead of /skill:huh",
 		from: "skills=this._resourceLoader.getSkills().skills.map(skill=>({name:`skill:${skill.name}`,",
 		to: "skills=this._resourceLoader.getSkills().skills.map(skill=>({name:skill.name,",
 	},
@@ -83,6 +84,7 @@ const PATCHES = [
 		// `isAtStartOfMessage`. At that moment the token after the slash is still empty, which is
 		// exactly the shape `umbraMidSlash` accepts.
 		reason: "typing a mid-sentence slash opens the menu on the slash",
+		needs: "a mid-sentence /name opens the slash menu",
 		from: `char==="/"&&this.isAtStartOfMessage()`,
 		to: `char==="/"&&(this.isAtStartOfMessage()||this.umbraMidSlash((this.state.lines[this.state.cursorLine]||"").slice(0,this.state.cursorCol)))`,
 	},
@@ -94,6 +96,11 @@ const unapplied = [];
 const gone = [];
 
 for (const patch of PATCHES) {
+	// It would call a method, or offer a name, that only the patch it needs provides.
+	if (gone.includes(patch.needs)) {
+		gone.push(`${patch.reason} (held back: needs "${patch.needs}")`);
+		continue;
+	}
 	let done = false;
 	for (const path of files) {
 		const source = readFileSync(path, "utf8");

package/node_modules/pi-umbra-subagents/README.md

@@ -1,8 +1,10 @@
 # pi-umbra-subagents
 
-Parallel, read-only pi branches you can watch while they work. A branch is a separate `pi -p`
-process with an empty context; a live list above the input box shows what each one is doing,
-and their answers come back to the session when the last one ends. Also `/umb-loop`, which
+Parallel pi branches you can watch while they work. A branch is a separate `pi -p` process with
+an empty context; a live tree under the input box shows what each one is doing, and their answers
+come back to the session when the last one ends. Branches are read-only, unless one is marked
+`[write]`: that one works in its own git worktree, and its changes wait on a git branch until you
+say whether to merge them. Also `/umb-loop`, which
 sends a prompt again after every reply, on a count or a timer.
 
 ![Three branches running under the input box](https://raw.githubusercontent.com/grknbyk/pi-umbra/main/assets/subagents.webp)
@@ -33,6 +35,19 @@ design: Given the Map results, propose the change.
 `label@provider/model: task` picks a model for one branch, otherwise it runs on the session's
 model. The results arrive as a follow-up message at the start of the next turn.
 
+`label [write]: task` gives one branch `edit`, `write` and `bash`, in its own git worktree on a
+new `fan/<run>/<branch>` branch that starts from your working tree, uncommitted work included.
+Its changes are committed to that branch when it ends and its row reads `Changed +12 −3 · 2 files
+on fan/...`; nothing is merged until the session asks you and you say yes. It needs a git
+repository, and pi has no sandbox: bash can still reach outside the worktree, and only the
+branch's instructions forbid it.
+
+The worktree lives under `.git/fan-worktrees/`, where test runners, linters and `git clean` do not
+look. A write branch cannot stop on a question, because its worktree closes when it ends, so its
+task has to carry every decision. Every write branch starts from the tree as it was when the run started, so a later
+phase does not see an earlier phase's changes. A run you start with `/umb-fan` tells you when a write branch
+left changes; ask the session to merge or discard them.
+
 ## Commands and keys
 
 | Command or key | Effect |
@@ -70,7 +85,7 @@ wrote stays on disk.
 | Variable | Default | Effect |
 |---|---|---|
 | `FAN_MODEL` | the session's model | model for `fan` branches that do not name one |
-| `FAN_TOOLS` | `read,grep,find,ls` | tools a branch may use |
+| `FAN_TOOLS` | `read,grep,find,ls` | tools a read-only branch may use (`[write]` branches get `edit,write,bash` too) |
 | `FAN_LOAD` | `$LOAD` from `delegate.env` | extra `-e <path>` flags; branches start with `--no-extensions`, so a provider that comes from an extension has to be listed here |
 | `FAN_TIMEOUT_MS` | `$DELEGATE_TIMEOUT` × 1000, else `300000` | a branch still running after this long is cut off |
 

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

@@ -173,12 +173,19 @@ export const countsOf = (branches: BranchView[]) =>
 /** What the row says it is doing. A branch that was killed never got to write "done", so its
  *  own `activity` is frozen on whatever it was mid-way through — a row reading "Running cd"
  *  on a process that has been dead for four minutes. The exit file already knows better. */
-export const said = (branch: BranchView): string => {
+const endedAs = (branch: BranchView): string => {
 	if (branch.timedOut) return "Timed out";
 	if (branch.status === "error") return branch.error ? `Failed: ${branch.error}` : "Failed";
 	// Killed by hand or by a parent going away: a non-zero exit with no error text of its own.
 	if (branch.settled && branch.exitCode !== null && branch.exitCode !== 0 && !branch.report) return "Stopped";
-	return branch.activity ?? "";
+	return "";
+};
+
+export const said = (branch: BranchView): string => {
+	// A write branch's answer is its diff, committed even when it was stopped or timed out.
+	const { git } = branch;
+	const changed = git?.error ? `Not committed: ${git.error}` : git?.stat ? `Changed ${git.stat} on ${git.branch}` : "";
+	return [endedAs(branch), changed].filter(Boolean).join(" · ") || (branch.activity ?? "");
 };
 
 // A branch says what it is doing; a row with hidden agents under it says how they are doing

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

@@ -1,5 +1,5 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
-import { MAX_ROWS, countsOf, layoutList, linesFor, renderKey, renderLines, stateOf, windowOf, type View } 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
@@ -253,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/fan/index.ts

@@ -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.
@@ -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 };
 		},
 	});
 }