magus-cli 7.9.0 → 7.10.0

package/src/services/worktree-profiles.ts

@@ -0,0 +1,181 @@
+/**
+ * The other working trees of this repository that carry a magus manifest but
+ * have no profile in effect — and setting them up.
+ *
+ * A profiled project's generated files are git-ignored, so git never gives
+ * them to a new worktree. Claude Code treats the folder it starts in as the
+ * project and reads only that folder's settings, so a session started in such
+ * a worktree loads only the plugins turned on at USER scope. magus run in that
+ * worktree would fix it (`autoActivate`), but nothing tells the user to.
+ *
+ * So magus, run anywhere in the repository, looks at the other working trees
+ * too. Detection and apply are kept apart, and every surface — `magus update`,
+ * `magus doctor` and the TUI — uses these two functions; none of them decides
+ * anything of its own beyond how to show the result.
+ *
+ * Detection writes nothing, anywhere: it is `detectProfileStartupNeed` per
+ * working tree, which is detection only. Apply is the activation the normal
+ * gate runs for a fresh clone, against THAT worktree's own manifest — nothing
+ * is ever copied between worktrees.
+ */
+
+import { realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { listWorkingTrees } from "./git-worktree.js";
+import { getManifestPath, readManifest } from "./manifest.js";
+import {
+	type ProfileStartupState,
+	detectProfileStartupNeed,
+} from "./profile-startup.js";
+import { applyProfileChoice } from "./profile-state.js";
+import { SettingsParseError } from "./settings-file.js";
+
+export interface UnsetWorktree {
+	/** Absolute path of that working tree. */
+	path: string;
+	/** Its folder name, how the user knows it. */
+	name: string;
+	/** From `detectProfileStartupNeed(path)`; never "ok". */
+	state: ProfileStartupState;
+	declaredDefault: string | null;
+	/** The repo declares a profile and nothing would be replaced. */
+	autoActivate: boolean;
+}
+
+export type WorktreeSetupResult =
+	| { path: string; name: string; ok: true; profileId: string }
+	| { path: string; name: string; ok: false; reason: string };
+
+/** The canonical spelling of a path, so `/tmp` and `/private/tmp` compare equal. */
+async function canonical(p: string): Promise<string> {
+	try {
+		return await realpath(p);
+	} catch {
+		return path.resolve(p);
+	}
+}
+
+async function isDirectory(p: string): Promise<boolean> {
+	try {
+		return (await stat(p)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+async function isFile(p: string): Promise<boolean> {
+	try {
+		return (await stat(p)).isFile();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Read-only. The other working trees of `projectPath`'s repository that need
+ * setup, sorted by name.
+ *
+ * Left out: `projectPath`'s own working tree (the normal gate handles it), a
+ * working tree whose folder is gone, one with no manifest (not a magus
+ * project on that branch), and one already on a profile. Not a repository, or
+ * git failing, is `[]`.
+ */
+export async function findUnsetWorktrees(
+	projectPath: string,
+): Promise<UnsetWorktree[]> {
+	let listing: Awaited<ReturnType<typeof listWorkingTrees>>;
+	try {
+		listing = await listWorkingTrees(projectPath);
+	} catch {
+		return [];
+	}
+	if (listing === null) return [];
+	const self = await canonical(listing.self);
+
+	const found = await Promise.all(
+		listing.trees.map(async (tree): Promise<UnsetWorktree | null> => {
+			if (tree.prunable || !(await isDirectory(tree.path))) return null;
+			const at = await canonical(tree.path);
+			if (at === self) return null;
+			if (!(await isFile(getManifestPath(at)))) return null;
+			try {
+				const need = await detectProfileStartupNeed(at);
+				if (need.state === "ok") return null;
+				return {
+					path: at,
+					name: path.basename(at),
+					state: need.state,
+					declaredDefault: need.declaredDefault,
+					autoActivate: need.autoActivate && need.declaredDefault !== null,
+				};
+			} catch {
+				// One working tree magus cannot read says nothing about the others.
+				return null;
+			}
+		}),
+	);
+
+	const seen = new Set<string>();
+	return found
+		.filter((w): w is UnsetWorktree => {
+			if (w === null || seen.has(w.path)) return false;
+			seen.add(w.path);
+			return true;
+		})
+		.sort((a, b) =>
+			a.name === b.name
+				? a.path.localeCompare(b.path)
+				: a.name.localeCompare(b.name),
+		);
+}
+
+/** Why an activation failed, in one line that never ends on an absolute path. */
+function failureReason(error: unknown, worktree: string): string {
+	if (error instanceof SettingsParseError) {
+		return `${path.relative(worktree, error.path)} ${error.problem}`;
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	return message.split("\n")[0] ?? message;
+}
+
+/**
+ * Activate the declared profile in each worktree whose `autoActivate` is true,
+ * one after another. Entries that need a choice are skipped and not returned;
+ * one failure does not stop the others.
+ */
+export async function setUpWorktrees(
+	worktrees: UnsetWorktree[],
+): Promise<WorktreeSetupResult[]> {
+	const results: WorktreeSetupResult[] = [];
+	for (const wt of worktrees) {
+		if (!wt.autoActivate || wt.declaredDefault === null) continue;
+		try {
+			// That worktree's own manifest, read now: its branch may declare
+			// something other than this one's.
+			const manifest = await readManifest(wt.path);
+			const result = await applyProfileChoice(
+				{ kind: "activate", id: wt.declaredDefault },
+				manifest,
+				wt.path,
+				// Nothing to announce: `autoActivate` means nothing of the user's
+				// was there to move aside, and printing here would land inside
+				// whichever surface called this.
+				{ onDisplace: () => {} },
+			);
+			results.push({
+				path: wt.path,
+				name: wt.name,
+				ok: true,
+				profileId: result.profileId,
+			});
+		} catch (error) {
+			results.push({
+				path: wt.path,
+				name: wt.name,
+				ok: false,
+				reason: failureReason(error, wt.path),
+			});
+		}
+	}
+	return results;
+}

package/src/shared/plugin/hooks/bun-missing.sh

@@ -3,11 +3,13 @@
 # runs this only when Bun is not on the PATH Claude Code started with, which is
 # the one dependency the TypeScript check cannot report itself. $1 is the label.
 #
-# Writes the same ledger as deps-check.ts: seen/<label> = sh, then claims the
-# Bun requirement's dedupe key, so a session prints one Bun line however many
-# plugins carry this file. scripts/check-hook-copies.ts recomputes that key, the
-# install line and the PATH lines from lib/requires-probe.ts and fails when this
-# file disagrees. Exit 0 always.
+# Writes the same ledger as deps-check.ts, 0700: seen/<label> = sh, then claims
+# the Bun requirement's dedupe key, so a session prints one Bun line however
+# many plugins carry this file. A bun in a place an installer or Homebrew puts
+# one is reported as off the PATH, naming that place; only when there is none
+# is Bun called missing. scripts/check-hook-copies.ts recomputes the key, the
+# install line, the Bun prefix and the PATH line formats from
+# lib/requires-probe.ts and fails when this file disagrees. Exit 0 always.
 
 label=$1
 case $label in
@@ -17,6 +19,7 @@ key=bun-3182ab42b0f1
 
 sid=$(cat 2>/dev/null | tr -d '\n' | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([A-Za-z0-9_-]*\)".*/\1/p')
 if [ -n "$sid" ]; then
+	umask 077
 	base=${TMPDIR:-/tmp}
 	dir=$base/magus-deps-$sid
 	if mkdir -p "$dir/seen" "$dir/claimed" 2>/dev/null; then
@@ -26,13 +29,35 @@ if [ -n "$sid" ]; then
 	fi
 fi
 
-if [ -x "$HOME/.bun/bin/bun" ]; then
+# The first bun where an installer or Homebrew leaves one. A path that would
+# break the JSON line is skipped.
+found=
+for d in ${BUN_INSTALL:+"$BUN_INSTALL/bin"} "$HOME/.bun/bin" /opt/homebrew/bin /usr/local/bin /home/linuxbrew/.linuxbrew/bin; do
+	case $d in
+	*\"* | *\\* | *[[:cntrl:]]*) continue ;;
+	esac
+	if [ -f "$d/bun" ] && [ -x "$d/bun" ]; then
+		found=$d
+		break
+	fi
+done
+
+if [ -n "$found" ]; then
+	# Under $HOME: shown as ~/…, and $HOME in the PATH line.
+	rel=${found#"$HOME"/}
+	if [ -n "$HOME" ] && [ "$HOME" != / ] && [ "$rel" != "$found" ]; then
+		shown="~/$rel" pathdir="\$HOME/$rel"
+	else
+		shown=$found pathdir=$found
+	fi
 	case ${SHELL:-} in
-	*zsh) rc='~/.zshrc' line='export PATH=\"$HOME/.bun/bin:$PATH\"' ;;
-	*fish) rc='~/.config/fish/config.fish' line='fish_add_path $HOME/.bun/bin' ;;
-	*) rc='~/.bashrc' line='export PATH=\"$HOME/.bun/bin:$PATH\"' ;;
+	*zsh) rc='~/.zshrc' fmt='export PATH="%s:$PATH"' ;;
+	*fish) rc='~/.config/fish/config.fish' fmt='fish_add_path %s' ;;
+	*) rc='~/.bashrc' fmt='export PATH="%s:$PATH"' ;;
 	esac
-	printf '{"systemMessage":"magus-deps: Bun is installed at ~/.bun/bin but is not on the PATH Claude Code started with, so magus hooks and MCP servers cannot run (noticed by %s).\\n  Add %s to %s, then restart Claude Code from a new terminal."}\n' "$label" "$line" "$rc"
+	# shellcheck disable=SC2059 # fmt is one of the three fixed formats above
+	line=$(printf "$fmt" "$pathdir" | sed 's/["\\]/\\&/g')
+	printf '{"systemMessage":"magus-deps: Bun is installed at %s but is not on the PATH Claude Code started with, so magus hooks and MCP servers cannot run (noticed by %s).\\n  Add %s to %s, then restart Claude Code from a new terminal."}\n' "$shown" "$label" "$line" "$rc"
 else
 	printf '{"systemMessage":"magus-deps: Bun is missing — magus hooks and MCP servers need it (noticed by %s).\\n  Install: curl -fsSL https://bun.sh/install | bash, then restart Claude Code from a new terminal."}\n' "$label"
 fi

package/src/shared/plugin/hooks/deps-check.ts

@@ -17,7 +17,9 @@
  * atomic `mkdir claimed/<dedupeKey>`. A failed mkdir means another plugin's copy
  * reports that dep this session, so one dep is one banner line however many
  * plugins need it. An unreadable session id means no ledger and no claims:
- * more banners, never fewer. Ledgers older than a day are pruned on write.
+ * more banners, never fewer. The ledger is 0700. Ledgers older than a day are
+ * pruned on write, each on its own, so one this user cannot remove skips only
+ * itself.
  *
  * Exit 0 always. A watchdog keeps the hook inside its registration timeout.
  */
@@ -94,28 +96,42 @@ async function readHookInput(): Promise<HookInput> {
 	}
 }
 
+/**
+ * Remove ledgers older than a day. Each is tried on its own: a shared `/tmp`
+ * holds other users' ledgers, which this user cannot remove, and one of those
+ * must not stop this user's own from being pruned.
+ */
 function pruneOldLedgers(base: string): void {
+	let entries: string[];
 	try {
-		for (const entry of readdirSync(base)) {
-			if (!entry.startsWith("magus-deps-")) continue;
-			const dir = join(base, entry);
+		entries = readdirSync(base);
+	} catch {
+		return; // Pruning is housekeeping; a failure costs nothing now.
+	}
+	for (const entry of entries) {
+		if (!entry.startsWith("magus-deps-")) continue;
+		const dir = join(base, entry);
+		try {
 			if (Date.now() - statSync(dir).mtimeMs > LEDGER_MAX_AGE_MS) {
 				rmSync(dir, { recursive: true, force: true });
 			}
+		} catch {
+			// Another user's, or already gone: the next entry is still pruned.
 		}
-	} catch {
-		// Pruning is housekeeping; a failure costs nothing now.
 	}
 }
 
-/** The ledger directory, with `seen/<label>` written, or null without a session. */
+/**
+ * The ledger directory, with `seen/<label>` written, or null without a session.
+ * Created 0700: in a shared `/tmp`, no other user reads which plugins ran.
+ */
 function openLedger(hookSession: string | null, label: string): string | null {
 	if (!hookSession) return null;
 	const base = process.env.TMPDIR || tmpdir();
 	const dir = join(base, `magus-deps-${hookSession}`);
 	try {
-		mkdirSync(join(dir, "seen"), { recursive: true });
-		mkdirSync(join(dir, "claimed"), { recursive: true });
+		mkdirSync(join(dir, "seen"), { recursive: true, mode: 0o700 });
+		mkdirSync(join(dir, "claimed"), { recursive: true, mode: 0o700 });
 		writeFileSync(join(dir, "seen", label), "ts");
 	} catch {
 		return null;

package/src/shared/plugin/hooks/lib/requires-probe.ts

@@ -21,7 +21,7 @@
 
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { constants, accessSync, statSync } from "node:fs";
+import { constants, accessSync, readFileSync, statSync } from "node:fs";
 import { delimiter, join } from "node:path";
 
 /** The one `requires` shape this reader knows. Any change to it bumps this. */
@@ -51,6 +51,17 @@ export interface Bootstrap {
 	prefix: UserPrefix;
 	/** Tools the upstream installer script itself runs. */
 	needs: readonly string[];
+	/**
+	 * The environment the installer runs with: what keeps it out of the user's
+	 * rc files, so the PATH line magus prints is the only one.
+	 */
+	env?: Readonly<Record<string, string>>;
+	/**
+	 * The installer adds `prefix` to the user's rc file itself and has no
+	 * switch to stop it, so magus prints no PATH line ahead of it; once it has
+	 * run, the rc file is read to see whether it did.
+	 */
+	editsRc?: true;
 }
 
 /**
@@ -64,12 +75,14 @@ export const TOOLCHAIN_BOOTSTRAP = {
 		interpreter: "bash",
 		prefix: BUN_PREFIX,
 		needs: ["curl", "unzip"],
+		editsRc: true,
 	},
 	uv: {
 		url: "https://astral.sh/uv/install.sh",
 		interpreter: "sh",
 		prefix: LOCAL_PREFIX,
 		needs: ["curl"],
+		env: { UV_NO_MODIFY_PATH: "1" },
 	},
 } as const satisfies Record<string, Bootstrap>;
 
@@ -679,6 +692,79 @@ export function rcFile(shell: string): string {
 	return "~/.bashrc";
 }
 
+/** The files `shell` reads when a terminal starts it, `rcFile(shell)` first. */
+function startupFiles(shell: string): string[] {
+	if (shell.endsWith("zsh")) return ["~/.zshrc", "~/.zprofile", "~/.zshenv"];
+	if (shell.endsWith("fish")) return ["~/.config/fish/config.fish"];
+	return ["~/.bashrc", "~/.bash_profile"];
+}
+
+const SHELL_VAR_RE = /\$(?:\{([A-Za-z_]\w*)\}|([A-Za-z_]\w*))/g;
+const ASSIGN_RE = /^(?:export\s+)?([A-Za-z_]\w*)=(.*)$/;
+const FISH_SET_RE = /^set\s+(?:-\S+\s+)*([A-Za-z_]\w*)\s+(.*)$/;
+const PATH_EDIT_RE = /\bPATH\b|^fish_add_path\b|^path\+?=/;
+
+/**
+ * Does `text` (one rc file) put `abs` on PATH? A line that edits PATH counts
+ * when, with `~`, `$HOME` and the variables the file assigns earlier
+ * substituted, one of its words is `abs`. That reads the line magus prints,
+ * a hand-written one, and bun's installer's
+ * `export BUN_INSTALL="$HOME/.bun"` + `export PATH="$BUN_INSTALL/bin:$PATH"`.
+ */
+function textAddsToPath(text: string, abs: string, home: string): boolean {
+	const vars = new Map([["HOME", home]]);
+	const expand = (s: string): string =>
+		s
+			.replace(
+				SHELL_VAR_RE,
+				(whole: string, braced?: string, bare?: string) =>
+					vars.get(braced ?? bare ?? "") ?? whole,
+			)
+			.replace(
+				/(^|[\s:="'(])~(?=\/|$)/g,
+				(_whole: string, lead: string) => `${lead}${home}`,
+			);
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (line === "" || line.startsWith("#")) continue;
+		if (PATH_EDIT_RE.test(line)) {
+			const words = expand(line).split(/[\s:"'()=]+/);
+			if (words.some((w) => w === abs || w === `${abs}/`)) return true;
+		}
+		const assign = line.match(ASSIGN_RE) ?? line.match(FISH_SET_RE);
+		if (assign?.[1] && assign[2] !== undefined) {
+			const value = expand(assign[2]);
+			const quoted = /^(["']).*\1$/.test(value);
+			vars.set(assign[1], quoted ? value.slice(1, -1) : value);
+		}
+	}
+	return false;
+}
+
+/**
+ * The startup file of `shell` (as `~/…`) that already puts `dir` on PATH, or
+ * null. A PATH line is advice only while no such file exists: when one does,
+ * the prefix is off the PATH only because Claude Code started without reading
+ * it, and the fix is a restart, not a second line.
+ */
+export function rcFileAdding(
+	dir: string,
+	shell: string,
+	home: string,
+): string | null {
+	const abs = expandHome(dir, home).replace(/\/+$/, "");
+	for (const file of startupFiles(shell)) {
+		let text: string;
+		try {
+			text = readFileSync(expandHome(file, home), "utf8");
+		} catch {
+			continue;
+		}
+		if (textAddsToPath(text, abs, home)) return file;
+	}
+	return null;
+}
+
 // ─── presence ─────────────────────────────────────────────────────────────────
 
 export type Presence =
@@ -824,6 +910,8 @@ export type InstallStep =
 			url: string;
 			interpreter: "sh" | "bash";
 			prefix: UserPrefix;
+			/** The installer's environment, from {@link Bootstrap.env}. */
+			env?: Record<string, string>;
 	  }
 	| {
 			kind: "release";
@@ -980,13 +1068,14 @@ export function renderInstall(
 			};
 		}
 		case "bootstrap": {
-			const b = TOOLCHAIN_BOOTSTRAP[option.tool];
+			const b: Bootstrap = TOOLCHAIN_BOOTSTRAP[option.tool];
 			return {
 				kind: "bootstrap",
 				name,
 				url: b.url,
 				interpreter: b.interpreter,
 				prefix: b.prefix,
+				...(b.env ? { env: { ...b.env } } : {}),
 			};
 		}
 		case "uv-script":
@@ -1054,8 +1143,12 @@ export function describeStep(step: InstallStep, os: Os): string {
 			const sudo = step.escalation === "sudo" ? "sudo " : "";
 			return `${sync} && ${sudo}"$(${find})" ${run}`;
 		}
-		case "bootstrap":
-			return `curl -fsSL ${step.url} | ${step.interpreter}`;
+		case "bootstrap": {
+			const env = Object.entries(step.env ?? {}).map(([k, v]) => `${k}=${v}`);
+			const run =
+				env.length > 0 ? ["env", ...env, step.interpreter] : [step.interpreter];
+			return `curl -fsSL ${step.url} | ${shellLine(run)}`;
+		}
 		case "release": {
 			const asset = step.url.slice(step.url.lastIndexOf("/") + 1);
 			const verify = os === "darwin" ? "shasum -a 256 -c" : "sha256sum -c";
@@ -1174,8 +1267,11 @@ export function renderFix(
 	for (const p of offPath) {
 		const prefix = USER_PREFIXES.find((u) => u.dir === p.prefix);
 		const rc = prefix?.rcLine(shell) ?? "";
+		const adding = rcFileAdding(p.prefix, shell, env.home);
 		lines.push(
-			`  ${p.name} is in ${p.prefix}, which is not on the PATH Claude Code started with: add ${rc} to ${rcFile(shell)}`,
+			adding
+				? `  ${p.name} is in ${p.prefix}, which is not on the PATH Claude Code started with; ${adding} already puts it on PATH`
+				: `  ${p.name} is in ${p.prefix}, which is not on the PATH Claude Code started with: add ${rc} to ${rcFile(shell)}`,
 		);
 	}
 	lines.push("  Then restart Claude Code from a new terminal.");

package/src/ui/App.tsx

@@ -21,10 +21,15 @@ import {
 	checkForUpdates,
 	getCurrentVersion,
 } from "../services/version-check.js";
+import {
+	findUnsetWorktrees,
+	setUpWorktrees,
+} from "../services/worktree-profiles.js";
 import {
 	gitignoreStartupReport,
 	profileStartupReport,
 	staleRepairReport,
+	worktreeSetupReport,
 } from "./adapters/startupReports.js";
 import { ScreenErrorBoundary } from "./components/ScreenErrorBoundary.js";
 import { TABS } from "./components/TabBar.js";
@@ -296,8 +301,15 @@ function AppContent({ onExit }: AppContentProps) {
 		null,
 	);
 	const staleLoadModal = useStaleLoadModal();
+	// This project's own profile question is settled: it needed nothing, or it
+	// was answered. Only then are the other worktrees set up — before it, they
+	// would be set up from a project that is not set up itself.
+	const [profileSettled, setProfileSettled] = useState(false);
 	// Stable, so `profileModal.show` is not rebuilt for it on every render.
-	const profileAnswered = React.useCallback(() => setProfileNeed(null), []);
+	const profileAnswered = React.useCallback(() => {
+		setProfileNeed(null);
+		setProfileSettled(true);
+	}, []);
 	// Activating a profile changes which plugins are on, so the open screen must
 	// reload. The result modal that used to follow sent the user to the Profiles
 	// tab, which remounted it; without that modal the user stays where they are,
@@ -550,12 +562,31 @@ function AppContent({ onExit }: AppContentProps) {
 				);
 				queueReports(profileStartupReport(problems, activations ?? []));
 				if (!needsNothing(need)) setProfileNeed(need);
+				else setProfileSettled(true);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand
 			}
 		})();
 	}, [queueReports]);
 
+	// The other worktrees of this repository with no profile set up, once this
+	// project's own question is settled. Each one whose project already declares
+	// a profile, with nothing of the user's to replace, is set up without
+	// asking — the same rule this project's own profile follows above. Success
+	// shows nothing; failures go to the one failure popup. A worktree that needs
+	// a choice is left to `magus update` run in it. Its own effect, for the
+	// same reason as the profile check above.
+	const worktreesLooked = useRef(false);
+	useEffect(() => {
+		if (!profileSettled || worktreesLooked.current) return;
+		worktreesLooked.current = true;
+		findUnsetWorktrees(process.cwd())
+			.then((found) => setUpWorktrees(found.filter((w) => w.autoActivate)))
+			.then((results) => queueReports(worktreeSetupReport(results)))
+			// non-fatal: `magus update` reports the same worktrees
+			.catch(() => {});
+	}, [profileSettled, queueReports]);
+
 	// Auto-refresh marketplaces on startup
 	useEffect(() => {
 		const noRefresh = process.argv.includes("--no-refresh");

package/src/ui/adapters/startupReports.ts

@@ -1,8 +1,8 @@
 /**
  * The failure popup's words for everything outside the Plugins screen's apply
  * paths: the profile gate at startup, a profile activation, the startup
- * repairs (stale plugin loads, marketplace refreshes, gitignore fixes) and the
- * Git State screen. Each is a pure builder over what the service returned, on
+ * repairs (stale plugin loads, marketplace refreshes, gitignore fixes), the
+ * setup of other worktrees and the Git State screen. Each is a pure builder over what the service returned, on
  * top of {@link failureReport}, so they read like every other failure.
  *
  * Each returns null when nothing failed: success says nothing, because the
@@ -13,6 +13,7 @@ import type { StaleLoadRepairResult } from "../../services/claude-settings.js";
 import type { ActivationResult } from "../../services/profile-activate.js";
 import { SettingsParseError } from "../../services/settings-file.js";
 import { pluginName } from "../../services/update-engine.js";
+import type { WorktreeSetupResult } from "../../services/worktree-profiles.js";
 import { userFacingPath, withUserFacingPath } from "../../utils/user-path.js";
 import type { FailureReport, FailureRow } from "../state/types.js";
 import {
@@ -212,6 +213,25 @@ export function stepFailureReport(
 	};
 }
 
+/**
+ * Worktrees the startup setup could not put on their declared profile, each
+ * by folder name with its reason. Null when every one was set up.
+ */
+export function worktreeSetupReport(
+	results: readonly WorktreeSetupResult[],
+): FailureReport | null {
+	const failed = results.filter(
+		(r): r is Extract<WorktreeSetupResult, { ok: false }> => !r.ok,
+	);
+	return failureReport(
+		`${counted(failed.length, "worktree")} ${failed.length === 1 ? "was" : "were"} not set up`,
+		failed.map((r) => ({
+			subject: r.name,
+			reason: exceptionReason(r.reason).reason,
+		})),
+	);
+}
+
 /**
  * M9: generated files the startup gitignore fix could not untrack, each with
  * git's own reason.

package/src/utils/run.ts

@@ -41,6 +41,11 @@ export interface RunResult {
 	spawnError?: string;
 	/** Combined stdout + stderr, last {@link OUTPUT_TAIL_BYTES}, ANSI stripped. */
 	outputTail: string;
+	/**
+	 * stdout alone, last {@link OUTPUT_TAIL_BYTES}, ANSI stripped. Set only
+	 * when `captureStdout` asked for it.
+	 */
+	stdout?: string;
 	durationMs: number;
 }
 
@@ -53,6 +58,12 @@ export interface RunOptions {
 	killGraceMs?: number;
 	/** Each output chunk as it arrives, ANSI intact. Never called after return. */
 	onOutput?: (chunk: string) => void;
+	/**
+	 * Also keep stdout on its own in `RunResult.stdout`: for a query whose
+	 * answer is what it prints on stdout, so a warning on stderr is never read
+	 * as the answer.
+	 */
+	captureStdout?: boolean;
 }
 
 /** Keep the last {@link OUTPUT_TAIL_BYTES} of a growing buffer. */
@@ -67,10 +78,13 @@ export function runArgv(c: Command, opts: RunOptions): Promise<RunResult> {
 	const started = Date.now();
 	return new Promise((resolve) => {
 		let output = "";
+		let stdout = "";
 		let timedOut = false;
 		let settled = false;
 		let killTimer: ReturnType<typeof setTimeout> | undefined;
-		const finish = (result: Omit<RunResult, "outputTail" | "durationMs">) => {
+		const finish = (
+			result: Omit<RunResult, "outputTail" | "stdout" | "durationMs">,
+		) => {
 			if (settled) return;
 			settled = true;
 			clearTimeout(timer);
@@ -78,6 +92,7 @@ export function runArgv(c: Command, opts: RunOptions): Promise<RunResult> {
 			resolve({
 				...result,
 				outputTail: stripAnsi(tail(output)),
+				...(opts.captureStdout ? { stdout: stripAnsi(tail(stdout)) } : {}),
 				durationMs: Date.now() - started,
 			});
 		};
@@ -93,6 +108,11 @@ export function runArgv(c: Command, opts: RunOptions): Promise<RunResult> {
 		};
 		child.stdout?.on("data", onData);
 		child.stderr?.on("data", onData);
+		if (opts.captureStdout) {
+			child.stdout?.on("data", (data: Buffer) => {
+				stdout = tail(stdout + data.toString("utf8"));
+			});
+		}
 		const timer = setTimeout(() => {
 			timedOut = true;
 			child.kill("SIGTERM");