magus-cli 7.9.1 → 7.10.1

package/src/cli/update-view.ts

@@ -34,6 +34,10 @@ import {
 	type UpdatePlan,
 	isKeptDeprecated,
 } from "../services/update-plan.js";
+import type {
+	UnsetWorktree,
+	WorktreeSetupResult,
+} from "../services/worktree-profiles.js";
 import { type ReportBadgeKind, reportBadge } from "../ui/theme-mode.js";
 import { brand } from "../ui/theme.js";
 import { formatCommand } from "../utils/command-utils.js";
@@ -86,6 +90,7 @@ type ActionKey =
 	| "refresh"
 	| "stale-load"
 	| "remove"
+	| "external"
 	| "unknown";
 
 const ACTIONS: Record<ActionKey, ActionStyle> = {
@@ -107,6 +112,9 @@ const ACTIONS: Record<ActionKey, ActionStyle> = {
 	// dead weight Claude Code refuses to load, and the row is work, not a shrug.
 	// The plugin table shows the group's DEPRECATED chip, not this label.
 	remove: { glyph: "✗", label: "REMOVE", color: brand.danger },
+	// A tool another installer put on PATH. Settled, so chrome like CURRENT,
+	// and the same word the summary already prints for settled rows.
+	external: { glyph: "=", label: "KEPT", color: brand.muted, chrome: true },
 	// Warning, not danger: "cannot tell" is not a failure, and red UNKNOWN read
 	// as "broken". The summary line and the TUI already use warning for it.
 	unknown: { glyph: "?", label: "UNKNOWN", color: brand.warning },
@@ -449,6 +457,7 @@ function binDetail(item: BinUpdateItem, plan: UpdatePlan): string {
 				// plain one reads identically to before.
 				item.adopted ? `  ${dim(`(${item.adopted})`)}` : ""
 			}`;
+		case "external":
 		case "unknown":
 			return `${item.installed ?? "—"}${
 				item.note ? `  ${dim(`(${item.note})`)}` : ""
@@ -903,3 +912,66 @@ export function pendingHeadline(plan: UpdatePlan): string {
 		!plan.skills.some((s) => s.action === "install");
 	return onlyRemovals ? "Changes pending" : "Updates available";
 }
+
+// -- other worktrees -----------------------------------------------------------
+//
+// The other working trees of this repository that have no profile set up
+// (`findUnsetWorktrees`). `magus update` sets up the ones the project already
+// answered for, exactly as it does its own folder, and says so in one line.
+// No section and no question: there is nothing to decide. Read-only runs
+// (`magus doctor`, `--check`, `--dry-run`) get the same one line as a warning.
+
+/** `Worktree a` or `Worktrees a, b, c + 2 more`, so the row stays one line. */
+function worktreeLabel(names: readonly string[]): string {
+	const shown = names.slice(0, 3).join(", ");
+	const list = names.length > 3 ? `${shown} + ${names.length - 3} more` : shown;
+	return `${names.length === 1 ? "Worktree" : "Worktrees"} ${bold(list)}`;
+}
+
+/**
+ * The worktree rows: after a setup (`results`), one `✓` line for every
+ * worktree set up and a `✗` line for each failure; on a read-only run
+ * (`results` null), one `⚠` line for the ones `magus update` would set up.
+ *
+ * A worktree that needs a choice gets no line. magus cannot set it up from
+ * here, and a line per worktree on every run is noise about folders the user
+ * may never open: old branches, agent and bench worktrees. The `setup`
+ * plugin says so when Claude Code starts in one, and magus run there asks.
+ * Empty when there is nothing to say, blank line included.
+ */
+export function worktreeLines(
+	worktrees: readonly UnsetWorktree[],
+	results: readonly WorktreeSetupResult[] | null,
+): string[] {
+	const lines: string[] = [];
+	if (results === null) {
+		const auto = worktrees.filter((w) => w.autoActivate).map((w) => w.name);
+		if (auto.length > 0) {
+			const one = auto.length === 1;
+			lines.push(
+				warn(
+					`${worktreeLabel(auto)} ${one ? "is" : "are"} missing this project's plugins. magus update sets ${one ? "it" : "them"} up.`,
+				),
+			);
+		}
+	} else {
+		const done = results.filter((r) => r.ok).map((r) => r.name);
+		if (done.length > 0) {
+			lines.push(
+				ok(
+					`${worktreeLabel(done)} now ${done.length === 1 ? "has" : "have"} this project's plugins.`,
+				),
+			);
+		}
+		for (const r of results) {
+			if (!r.ok) {
+				lines.push(
+					fail(
+						`Worktree ${bold(r.name)} was not set up: ${r.reason.replace(/\.+$/, "")}.`,
+					),
+				);
+			}
+		}
+	}
+	return lines.length > 0 ? ["", ...lines] : [];
+}

package/src/cli/update.ts

@@ -84,6 +84,7 @@ import {
 	planSkillUpdates,
 	summarizePlan,
 } from "../services/update-plan.js";
+import type { ProfileManifest } from "../types/index.js";
 import { brand } from "../ui/theme.js";
 import { bold, dim, fg, width } from "./ansi.js";
 import { ensureManifest, requireActiveProfile } from "./bootstrap.js";
@@ -108,6 +109,7 @@ import {
 	unknownToolsNotice,
 	warn as warnLine,
 } from "./update-view.js";
+import { setUpOtherWorktrees } from "./worktrees.js";
 
 interface UpdateFlags {
 	/** Report drift and exit 1 if anything is behind. The CI gate. */
@@ -250,6 +252,25 @@ export async function runUpdateCommand(
 	// what it promised. A refused `--check` exits 1, because that is a gate.
 	if (!current) return flags.dryRun ? 0 : 1;
 
+	const code = await updateProfile(flags, projectPath, current, startedAt);
+
+	// This project is on a profile; now the other worktrees of the repository,
+	// set up the same way without asking. After the update, so their line is
+	// not lost above the plan. Read-only under `--check` and `--dry-run`, and
+	// never a change to the exit code: those are other projects.
+	await setUpOtherWorktrees(projectPath, {
+		mayWrite: !flags.check && !flags.dryRun,
+	});
+	return code;
+}
+
+/** The update itself, once the project's own profile gate has passed. */
+async function updateProfile(
+	flags: UpdateFlags,
+	projectPath: string,
+	current: ProfileManifest,
+	startedAt: number,
+): Promise<number> {
 	const profileIds = Object.keys(current.profiles);
 	if (flags.profile && !current.profiles[flags.profile]) {
 		console.error(

package/src/cli/worktrees.ts

@@ -0,0 +1,32 @@
+/**
+ * The other worktrees of this repository at the end of `magus update`: the ones
+ * with no profile set up. Each one whose project already declares a profile,
+ * with nothing of the user's to replace, is set up without asking, exactly as
+ * `magus update` sets up its own folder. Then one line says so.
+ *
+ * Detection and apply are `services/worktree-profiles.ts`, shared with
+ * `magus doctor` and the TUI; the words are `update-view.ts`.
+ */
+
+import {
+	findUnsetWorktrees,
+	setUpWorktrees,
+} from "../services/worktree-profiles.js";
+import { worktreeLines } from "./update-view.js";
+
+/**
+ * Set up what can be set up when `mayWrite`, and print the rows. Under
+ * `--check` and `--dry-run` it only reports. Never changes the command's exit
+ * code: these are other projects, and a failure in one is reported on its row.
+ */
+export async function setUpOtherWorktrees(
+	projectPath: string,
+	opts: { mayWrite: boolean },
+): Promise<void> {
+	const worktrees = await findUnsetWorktrees(projectPath);
+	if (worktrees.length === 0) return;
+	const results = opts.mayWrite
+		? await setUpWorktrees(worktrees.filter((w) => w.autoActivate))
+		: null;
+	for (const line of worktreeLines(worktrees, results)) console.log(line);
+}

package/src/services/git-worktree.ts

@@ -190,6 +190,47 @@ export async function inheritablePaths(projectPath: string): Promise<string[]> {
 	return paths;
 }
 
+/** One working tree of a repository, as `git worktree list` reports it. */
+export interface WorkingTree {
+	/** Absolute path, as git recorded it. */
+	path: string;
+	/** git says its folder is gone (`prunable`); the record outlives it. */
+	prunable: boolean;
+}
+
+/**
+ * Every working tree of `projectPath`'s repository — the main one first, then
+ * each linked worktree — and the one `projectPath` itself sits in.
+ *
+ * Null when git cannot say: not a repository, git missing or not answering.
+ * A bare repository's own record has no working tree and is left out. Reads
+ * only; never caches, because a worktree added while magus runs is exactly
+ * what a caller of this wants to see.
+ */
+export async function listWorkingTrees(
+	projectPath: string,
+): Promise<{ self: string; trees: WorkingTree[] } | null> {
+	const dir = path.resolve(projectPath);
+	const [top, list] = await Promise.all([
+		git(dir, ["rev-parse", "--show-toplevel"]),
+		git(dir, ["worktree", "list", "--porcelain"]),
+	]);
+	if (top.code !== 0 || !top.out || list.code !== 0) return null;
+	const trees: WorkingTree[] = [];
+	for (const record of list.out.split(/\n\s*\n/)) {
+		const lines = record.split("\n").map((l) => l.trim());
+		const line = lines.find((l) => l.startsWith("worktree "));
+		if (!line || lines.includes("bare")) continue;
+		trees.push({
+			path: path.resolve(line.slice("worktree ".length)),
+			prunable: lines.some(
+				(l) => l === "prunable" || l.startsWith("prunable "),
+			),
+		});
+	}
+	return { self: path.resolve(top.out), trees };
+}
+
 async function resolveInheritable(
 	dir: string,
 ): Promise<{ paths: string[]; answered: boolean }> {

package/src/services/plugin-mcp-config.ts

@@ -217,7 +217,9 @@ export async function getPluginSourcePath(
 				const plugin = manifest.plugins.find(
 					(p: { name: string }) => p.name === pluginName,
 				);
-				return plugin?.source;
+				// An object source (git-subdir, github, url) is fetched from its own
+				// repo, not read from the marketplace clone, so there is no local path.
+				return typeof plugin?.source === "string" ? plugin.source : undefined;
 			}
 		}
 	} catch {

package/src/services/tool-probe.ts

@@ -58,7 +58,18 @@ import {
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
-export type ToolState = "install" | "current" | "upgrade" | "unknown";
+/**
+ * `external` is a determined fact, not a failure to check: the tool is on
+ * PATH, and something other than the installer magus would use put it there
+ * (bun, an official installer, the OS). magus leaves it as is, so it is
+ * neither work nor "could not be checked".
+ */
+export type ToolState =
+	| "install"
+	| "current"
+	| "upgrade"
+	| "external"
+	| "unknown";
 
 export type ToolReason =
 	| "absent"
@@ -215,16 +226,38 @@ function withFailure(text: string, failure: string | undefined): string {
 	return failure ? `${text} (${failure})` : text;
 }
 
-/** The `not-managed` sentence. Names the file and its owner, never the version. */
+/** The installer as the user knows it. */
+export function installerWord(via: ManagedTool["via"]): string {
+	return via === "brew" ? "Homebrew" : via;
+}
+
+/**
+ * The `not-managed` sentence, in the user's terms: who did not install it,
+ * and what magus does about it. Never the path or the installer's directory:
+ * the user acts on neither.
+ */
 function notManagedNote(spec: ManagedTool, facts: ToolFacts): string {
+	const pin = pinOf(spec);
+	if (facts.managed === false && pin) {
+		return `installed outside ${installerWord(spec.via)}, so magus cannot move it to the pin ${pin}`;
+	}
 	return facts.managed === false
-		? `on PATH at ${facts.resolvedPath ?? "?"}, which ${facts.owner ?? spec.via} does not own — upgrading through ${spec.via} would install a second copy`
+		? `installed outside ${installerWord(spec.via)}, so magus leaves it as is`
 		: withFailure(
-				`could not tell whether ${spec.via} owns ${facts.resolvedPath ?? spec.name}`,
+				`could not tell whether ${installerWord(spec.via)} installed it`,
 				facts.failure,
 			);
 }
 
+/**
+ * Another installer's file is `external`, settled, only while nothing is
+ * asked of it. With a pin the profile declares a version magus cannot deliver
+ * without a second copy, so that is still a warning: `unknown`.
+ */
+function externalOr(pin: string | undefined): ToolState {
+	return pin ? "unknown" : "external";
+}
+
 /**
  * THE tool classifier. Pure. The first matching rule wins, and each branch
  * returns, so reading top to bottom is reading the precedence.
@@ -271,7 +304,7 @@ export function classifyTool(spec: ManagedTool, facts: ToolFacts): ToolStatus {
 	if (installed === null && facts.managed === false) {
 		return {
 			...base,
-			state: "unknown",
+			state: externalOr(pin),
 			reason: "not-managed",
 			target: null,
 			note: notManagedNote(spec, facts),
@@ -317,11 +350,12 @@ export function classifyTool(spec: ManagedTool, facts: ToolFacts): ToolStatus {
 		};
 	}
 
-	// 7. The veto: the upgrade would not replace the file PATH runs.
+	// 7. The veto: the upgrade would not replace the file PATH runs. Known to be
+	// another installer's file: `external`. Not known either way: `unknown`.
 	if (facts.managed !== true) {
 		return {
 			...base,
-			state: "unknown",
+			state: facts.managed === false ? externalOr(pin) : "unknown",
 			reason: "not-managed",
 			target: null,
 			note: notManagedNote(spec, facts),

package/src/services/update-plan.ts

@@ -1235,8 +1235,10 @@ export function summarizePlan(plan: UpdatePlan): {
 	unknownPlugins: number;
 	unknownTools: number;
 	/**
-	 * No longer published by their marketplace, and kept on purpose: moved, or
-	 * still required. A determined fact, so not part of `unknown`.
+	 * Left as they are, on purpose. Plugins no longer published by their
+	 * marketplace and kept (moved, or still required), and tools another
+	 * installer put on PATH (`external`). Determined facts, so not part of
+	 * `unknown`.
 	 */
 	kept: number;
 } {
@@ -1244,8 +1246,11 @@ export function summarizePlan(plan: UpdatePlan): {
 		plan.plugins.filter((p) => p.action === a).length;
 	const bins = (a: BinUpdateAction) =>
 		plan.bins.filter((b) => b.action === a).length;
-	const kept = plan.plugins.filter(isKeptDeprecated).length;
-	const unknownPlugins = count("unknown") - kept;
+	const keptPlugins = plan.plugins.filter(isKeptDeprecated).length;
+	const unknownPlugins = count("unknown") - keptPlugins;
+	// A tool another installer put on PATH is left as it is: settled, like a
+	// kept plugin, and never "could not be checked".
+	const kept = keptPlugins + bins("external");
 	const unknownTools = bins("unknown");
 	return {
 		installed: count("install") + bins("install"),

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/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/cliToolsAdapter.ts

@@ -29,6 +29,7 @@ import {
 	type ToolReason,
 	type ToolStatus,
 	classifyTool,
+	installerWord,
 } from "../../services/tool-probe.js";
 import { binCommandForState } from "../../services/toolchain.js";
 import type { Presence } from "../../shared/plugin/hooks/lib/requires-probe.js";
@@ -246,7 +247,9 @@ export function cliToolEnterAction(row: CliToolRow): CliToolEnterAction | null {
 			command,
 		};
 	}
-	if (status.state === "unknown") {
+	// Another installer's file, or one magus could not place: still offered,
+	// as an explicit choice, with the note beside it (see the renderer).
+	if (status.state === "unknown" || status.state === "external") {
 		return {
 			kind: "update-anyway",
 			label: "update anyway",
@@ -280,13 +283,14 @@ export interface CliToolStatusText {
  * line, the same string `magus update` prints.
  *
  * Every label is at most 19 cells, so the row suffix (" ? " + label) stays
- * within 24. Keyed by reason alone — plus the spec's installer, which is a
- * word, never a path.
+ * within 24. Keyed by reason alone.
  */
-function unknownLabel(reason: ToolReason, via: ManagedTool["via"]): string {
+function unknownLabel(reason: ToolReason): string {
 	switch (reason) {
+		// Only the undetermined case: a file known to be another installer's
+		// is `external`, not `unknown`.
 		case "not-managed":
-			return `not managed by ${via}`;
+			return "owner not known";
 		case "version-unreadable":
 			return "version unreadable";
 		case "latest-unavailable":
@@ -321,9 +325,14 @@ export function cliToolStatusText(row: CliToolRow): CliToolStatusText {
 	switch (status.state) {
 		case "unknown":
 			return {
-				suffix: ` ? ${unknownLabel(status.reason, row.spec.via)}`,
+				suffix: ` ? ${unknownLabel(status.reason)}`,
 				tone: "warning",
 			};
+		case "external":
+			return {
+				suffix: ` · outside ${installerWord(row.spec.via)}`,
+				tone: "muted",
+			};
 		case "upgrade":
 			return {
 				suffix: status.target