magus-cli 7.10.1 → 7.10.3

package/src/services/tool-probe.ts

@@ -52,6 +52,8 @@ import {
 	versionFromVersionedPath,
 } from "./cli-tool-version.js";
 import {
+	binPinCommand,
+	binUpgradeCommand,
 	claudeNativeUpgradeCommand,
 	npmPrefixInstallCommand,
 } from "./toolchain.js";
@@ -104,7 +106,20 @@ export type ToolFactSource =
 	| "package-json"
 	/** the file name of a versioned install (`…/versions/2.1.276`). */
 	| "version-dir"
-	| "check-command";
+	| "check-command"
+	/** an installer's own receipt (`~/.config/uv/uv-receipt.json`). */
+	| "installer-receipt"
+	/** `--version` of a program the operating system ships. */
+	| "os-version";
+
+/** Another copy of the tool on PATH, behind the one that runs. */
+export interface OtherCopy {
+	/** The installer as the user knows it: "Homebrew", "uv's own installer". */
+	owner: string;
+	version: string | null;
+	/** The PATH directory it was found in, with the home folder as `~`. */
+	dir: string;
+}
 
 export interface ToolFacts {
 	name: string;
@@ -133,6 +148,16 @@ export interface ToolFacts {
 	 * "npm (root /Users/x/.local/lib/node_modules)". Diagnostic only.
 	 */
 	owner?: string;
+	/**
+	 * Who installed the file PATH runs, as the user knows it ("uv's own
+	 * installer", "a Homebrew cask"), when that is not the spec's installer and
+	 * magus could name it. Read by the not-managed note.
+	 */
+	ownerName?: string;
+	/** The PATH directory the running copy was found in, home as `~`. */
+	pathDir?: string;
+	/** Other copies of the tool later on PATH, which nothing runs. */
+	otherCopies?: OtherCopy[];
 	/** e.g. "held by brew pin". */
 	heldBack?: string;
 	/**
@@ -176,6 +201,12 @@ export interface ToolStatus {
 	note?: string;
 	/** {@link ToolFacts.adopted}, carried when this state plans work. */
 	adopted?: string;
+	/**
+	 * Set in every state when a NEWER copy sits later on PATH, unused: e.g.
+	 * "Homebrew also has 0.13.0, unused: ~/.local/bin comes first on PATH".
+	 * A warning, because only the user can decide which copy to keep.
+	 */
+	shadowed?: string;
 	installed: string | null;
 	latest: string | null;
 	target: string | null;
@@ -231,22 +262,55 @@ export function installerWord(via: ManagedTool["via"]): string {
 	return via === "brew" ? "Homebrew" : via;
 }
 
+/** The directories the operating system itself installs programs into. */
+const SYSTEM_DIRS = ["/bin", "/sbin", "/usr/bin", "/usr/sbin", "/System"];
+
+function isSystemPath(resolved: string | null): boolean {
+	return (
+		resolved !== null && SYSTEM_DIRS.some((dir) => isInside(resolved, dir))
+	);
+}
+
 /**
  * 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}`;
+	if (facts.managed !== false) {
+		return withFailure(
+			`could not tell whether ${installerWord(spec.via)} installed it`,
+			facts.failure,
+		);
 	}
-	return facts.managed === false
-		? `installed outside ${installerWord(spec.via)}, so magus leaves it as is`
-		: withFailure(
-				`could not tell whether ${installerWord(spec.via)} installed it`,
-				facts.failure,
-			);
+	// Who DID install it. "Outside Homebrew" named the installer magus would
+	// have used, which says nothing about the copy the user has.
+	const who = isSystemPath(facts.resolvedPath)
+		? "comes with the operating system"
+		: facts.ownerName
+			? `installed by ${facts.ownerName}`
+			: "installed by an installer magus does not update";
+	const pin = pinOf(spec);
+	// The KEPT chip already says magus leaves it as is; the note says only who
+	// installed it, and what that means for a pin.
+	return pin ? `${who}, so magus cannot move it to the pin ${pin}` : who;
+}
+
+/**
+ * The warning for a newer copy later on PATH, or undefined. Only a NEWER one
+ * (or any, when the running version is unknown) is worth a line: an older
+ * copy changes nothing the user runs.
+ */
+function shadowNote(facts: ToolFacts): string | undefined {
+	const running = facts.installed;
+	const newer = (facts.otherCopies ?? []).find(
+		(copy) =>
+			copy.version !== null &&
+			(running === null || compareToolVersions(copy.version, running) === 1),
+	);
+	if (!newer?.version) return undefined;
+	const first = facts.pathDir ? `${facts.pathDir} comes first on PATH` : "";
+	return `${newer.owner} also has ${newer.version}, unused${first ? `: ${first}` : ""}`;
 }
 
 /**
@@ -277,6 +341,12 @@ function externalOr(pin: string | undefined): ToolState {
  * none.
  */
 export function classifyTool(spec: ManagedTool, facts: ToolFacts): ToolStatus {
+	const status = classifyState(spec, facts);
+	const shadowed = facts.present ? shadowNote(facts) : undefined;
+	return shadowed ? { ...status, shadowed } : status;
+}
+
+function classifyState(spec: ManagedTool, facts: ToolFacts): ToolStatus {
 	const pin = pinOf(spec);
 	const base = {
 		name: spec.name,
@@ -377,7 +447,10 @@ export function classifyTool(spec: ManagedTool, facts: ToolFacts): ToolStatus {
 	// From here on a row can plan work, so an adoption must travel with it.
 	const adopted = facts.adopted ? { adopted: facts.adopted } : {};
 	if (pin) {
-		if (spec.via === "brew") {
+		// Homebrew cannot install a chosen version, but the spec's installer is
+		// not always the owner: an owner's own command (`uv self update <pin>`)
+		// is already aimed at the pin.
+		if (spec.via === "brew" && !facts.upgradeCommand) {
 			return {
 				...base,
 				state: "unknown",
@@ -743,6 +816,11 @@ export interface ToolProbeIO {
 	 * null. A dangling symlink is not executable and does not count.
 	 */
 	resolveExecutable(name: string): Promise<string | null>;
+	/**
+	 * Every executable `name` on PATH, in PATH order, as found. Optional: an IO
+	 * without it reports no other copies.
+	 */
+	resolveAllExecutables?(name: string): Promise<string[]>;
 	env: Readonly<Record<string, string | undefined>>;
 	homedir: string;
 }
@@ -861,6 +939,16 @@ export const REAL_TOOL_PROBE_IO: ToolProbeIO = {
 		}
 		return null;
 	},
+	resolveAllExecutables: async (name) => {
+		const found: string[] = [];
+		for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+			if (!dir) continue;
+			const candidate = path.join(dir, name);
+			if (!found.includes(candidate) && (await isExecutable(candidate)))
+				found.push(candidate);
+		}
+		return found;
+	},
 	env: process.env,
 	homedir: os.homedir(),
 };
@@ -1223,6 +1311,9 @@ async function probeBrew(
 	resolvedPath: string,
 ): Promise<void> {
 	const formula = spec.formula ?? spec.name;
+	// A tap formula ("user/tap/f") keeps its keg under the short name, so the
+	// full name never matched and a Homebrew mnemex read as installed outside it.
+	const keg = formula.slice(formula.lastIndexOf("/") + 1);
 	const prefix = await s.brewPrefix();
 	if ("failure" in prefix) {
 		f.managed = null;
@@ -1232,11 +1323,11 @@ async function probeBrew(
 	const cellar =
 		(await s.io.realpath(path.join(prefix.dir, "Cellar"))) ??
 		path.join(prefix.dir, "Cellar");
-	const ownerDir = path.join(cellar, formula);
+	const ownerDir = path.join(cellar, keg);
 	f.owner = `brew (Cellar ${ownerDir})`;
 	f.managed = isInside(resolvedPath, ownerDir);
 	if (!f.managed) return;
-	f.installed = brewKegVersion(resolvedPath, cellar, formula);
+	f.installed = brewKegVersion(resolvedPath, cellar, keg);
 	if (f.installed) addSource(f, "brew");
 
 	const r = await s.run("brew", ["outdated", "--json=v2", formula], BREW_ENV);
@@ -1386,6 +1477,330 @@ async function readNodePackage(
 	if (!pinned) await npmLatest(s, pkg, f);
 }
 
+/** Where `bun add -g` puts packages: `$BUN_INSTALL/install/global/node_modules`. */
+function bunGlobalRoot(io: ToolProbeIO): string {
+	return path.join(
+		io.env.BUN_INSTALL ?? path.join(io.homedir, ".bun"),
+		"install",
+		"global",
+		"node_modules",
+	);
+}
+
+/** The package a path names, from its segments under `node_modules`. */
+function packageFromSegments(rel: string): string | null {
+	const [first, second] = rel.split(path.sep);
+	if (!first || first.startsWith(".")) return null;
+	if (!first.startsWith("@")) return first;
+	return second ? `${first}/${second}` : null;
+}
+
+/**
+ * The bun or npm global package that holds `resolvedPath`, read from the path
+ * alone. Null when the file lies in neither tree (a Homebrew keg included:
+ * `npmGlobalPrefixOf` refuses one).
+ */
+async function nodeGlobalOwner(
+	s: ProbeSession,
+	resolvedPath: string,
+): Promise<{ via: "bun" | "npm"; pkg: string } | null> {
+	const bunRoot = await s.io.realpath(bunGlobalRoot(s.io));
+	if (bunRoot && isInside(resolvedPath, bunRoot)) {
+		const pkg = packageFromSegments(path.relative(bunRoot, resolvedPath));
+		return pkg ? { via: "bun", pkg } : null;
+	}
+	const marker = `${path.sep}${path.join("lib", "node_modules")}${path.sep}`;
+	const at = resolvedPath.lastIndexOf(marker);
+	if (at < 0) return null;
+	const pkg = packageFromSegments(resolvedPath.slice(at + marker.length));
+	return pkg && npmGlobalPrefixOf(resolvedPath, pkg) !== null
+		? { via: "npm", pkg }
+		: null;
+}
+
+/**
+ * The formula whose keg holds `resolvedPath` (`…/Cellar/<formula>/<version>/…`),
+ * read from the path alone. `probeBrew` then checks that this Cellar is brew's.
+ */
+function kegFormulaOf(resolvedPath: string): string | null {
+	const parts = resolvedPath.split(path.sep);
+	const at = parts.lastIndexOf("Cellar");
+	return at >= 0 && parts.length > at + 2 ? (parts[at + 1] ?? null) : null;
+}
+
+/**
+ * The spec as the installer that actually holds `resolvedPath` would state it,
+ * or null when that is the spec's own installer or none magus drives.
+ */
+async function actualOwnerSpec(
+	s: ProbeSession,
+	spec: ManagedTool,
+	resolvedPath: string,
+): Promise<ManagedTool | null> {
+	const base = {
+		name: spec.name,
+		...(spec.check ? { check: spec.check } : {}),
+		...(spec.version ? { version: spec.version } : {}),
+	};
+	const node = await nodeGlobalOwner(s, resolvedPath);
+	if (node) {
+		return node.via === spec.via
+			? null
+			: { ...base, via: node.via, package: node.pkg };
+	}
+	const formula = kegFormulaOf(resolvedPath);
+	// Homebrew takes no version, so it cannot honour a pin: such a tool stays
+	// "installed outside", which the classifier reports as unknown.
+	if (!formula || spec.via === "brew" || spec.version) return null;
+	return { ...base, via: "brew", formula };
+}
+
+/**
+ * The spec's installer does not own the file PATH runs, but bun's or npm's
+ * global tree or a Homebrew keg does: re-read the tool through THAT installer.
+ *
+ * A plugin's `requires` lists its install options in preference order for a
+ * FRESH install, and magus plans through the first. That order says how to
+ * install a missing tool, not which owner an installed one must have. A
+ * mnemex from `bun add -g` or from Homebrew has a version, a registry and an
+ * upgrade command like any other. Reading it as "installed outside" the
+ * first option's installer showed a settled, upgradeable tool as one magus
+ * could not touch.
+ *
+ * The catalogue's tools already follow how a tool IS installed
+ * (`specForCatalogTool`); this gives a plugin's requirements the same rule.
+ * The upgrade command is carried on the facts, so `magus update` and the TUI
+ * run the owner's command rather than the spec's.
+ */
+async function adoptActualOwner(
+	s: ProbeSession,
+	spec: ManagedTool,
+	f: ToolFacts,
+	resolvedPath: string,
+): Promise<void> {
+	const actual = await actualOwnerSpec(s, spec, resolvedPath);
+	if (!actual) return;
+	const read = blankFacts(spec.name);
+	if (actual.via === "brew") await probeBrew(s, actual, read, resolvedPath);
+	else await probeNodeGlobal(s, actual, read, resolvedPath);
+	if (read.managed !== true) return;
+	f.managed = true;
+	f.owner = read.owner;
+	f.installed = read.installed;
+	f.latest = read.latest;
+	f.behind = read.behind;
+	// What the spec's installer could not answer is moot once the owner is
+	// known: only the owner's own failure describes this tool.
+	f.failure = read.failure;
+	for (const source of read.sources) addSource(f, source);
+	f.upgradeCommand =
+		read.upgradeCommand ??
+		(spec.version
+			? (binPinCommand(actual) ?? undefined)
+			: binUpgradeCommand(actual));
+}
+
+/**
+ * Standalone installers that update their own copy in place, keyed by the
+ * app their receipt names: the arguments after the program, and the PyPI
+ * project that publishes it. uv's own installer writes a receipt and ships
+ * `uv self update`, so a uv from it is as upgradeable as one from Homebrew.
+ */
+const SELF_UPDATERS: Readonly<
+	Record<string, { args: readonly string[]; pypi: string }>
+> = {
+	uv: { args: ["self", "update"], pypi: "uv" },
+};
+
+interface InstallerReceipt {
+	app: string;
+	version: string;
+	file: string;
+}
+
+/**
+ * The receipt a standalone installer (cargo-dist's format, which uv's uses)
+ * left for `name`, when it covers `resolvedPath`:
+ * `$XDG_CONFIG_HOME/<name>/<name>-receipt.json`, whose `install_prefix` holds
+ * the file and whose `binaries` list it. A receipt for another folder is a
+ * different copy and says nothing about this one.
+ */
+async function installerReceipt(
+	s: ProbeSession,
+	name: string,
+	resolvedPath: string,
+): Promise<InstallerReceipt | null> {
+	const config = s.io.env.XDG_CONFIG_HOME || path.join(s.io.homedir, ".config");
+	const file = path.join(config, name, `${name}-receipt.json`);
+	const body = await s.io.readJson(file);
+	if (!body || typeof body !== "object") return null;
+	const r = body as {
+		version?: unknown;
+		install_prefix?: unknown;
+		binaries?: unknown;
+		source?: { app_name?: unknown } | null;
+	};
+	if (typeof r.version !== "string" || typeof r.install_prefix !== "string")
+		return null;
+	if (
+		!Array.isArray(r.binaries) ||
+		!r.binaries.includes(path.basename(resolvedPath))
+	)
+		return null;
+	const prefix = (await s.io.realpath(r.install_prefix)) ?? r.install_prefix;
+	if (!isInside(resolvedPath, prefix)) return null;
+	const app = typeof r.source?.app_name === "string" ? r.source.app_name : name;
+	return { app, version: r.version, file };
+}
+
+/**
+ * The file is a standalone installer's: its receipt gives the version, and
+ * when that installer updates itself ({@link SELF_UPDATERS}) it is the owner
+ * `magus update` drives. Otherwise the tool stays KEPT, but its row can say
+ * who installed it and which version runs.
+ */
+async function adoptOwnInstaller(
+	s: ProbeSession,
+	spec: ManagedTool,
+	f: ToolFacts,
+	resolvedPath: string,
+): Promise<void> {
+	const receipt = await installerReceipt(s, spec.name, resolvedPath);
+	if (!receipt) return;
+	const ownerName = `${receipt.app}'s own installer`;
+	f.installed = receipt.version;
+	addSource(f, "installer-receipt");
+	const updater = SELF_UPDATERS[receipt.app];
+	if (!updater) {
+		f.managed = false;
+		f.ownerName = ownerName;
+		return;
+	}
+	f.managed = true;
+	f.owner = `${ownerName} (receipt ${receipt.file})`;
+	f.latest = null;
+	f.behind = null;
+	// What the spec's installer could not answer is moot: the owner is known.
+	f.failure = undefined;
+	const pin = pinOf(spec);
+	f.upgradeCommand = {
+		cmd: spec.name,
+		args: [...updater.args, ...(pin ? [pin] : [])],
+	};
+	if (!pin) await pypiLatest(s, updater.pypi, f);
+}
+
+/**
+ * Who installed a file no installer magus drives owns, as the user knows it,
+ * or undefined when the path does not say.
+ */
+async function nameOwner(
+	s: ProbeSession,
+	resolvedPath: string,
+): Promise<string | undefined> {
+	if (resolvedPath.split(path.sep).includes("Caskroom"))
+		return "a Homebrew cask";
+	if (kegFormulaOf(resolvedPath)) return "Homebrew";
+	const node = await nodeGlobalOwner(s, resolvedPath);
+	if (node) return node.via;
+	const cargoHome = s.io.env.CARGO_HOME || path.join(s.io.homedir, ".cargo");
+	if (isInside(resolvedPath, path.join(cargoHome, "bin"))) return "cargo";
+	return undefined;
+}
+
+/**
+ * Where an operating-system program is safe to run for `--version`. Not
+ * macOS's /usr/bin: several programs there are Xcode stubs that open an
+ * install dialog when run on a machine without the developer tools.
+ */
+function osVersionDirs(): string[] {
+	return process.platform === "darwin" ? ["/bin", "/sbin"] : SYSTEM_DIRS;
+}
+
+/**
+ * The version of a program the operating system ships, from its own
+ * `--version`. No installer keeps a record of these, and the file is the OS
+ * vendor's, not a string a catalogue wrote, so running it is safe.
+ */
+async function versionFromOs(
+	s: ProbeSession,
+	f: ToolFacts,
+	resolvedPath: string,
+): Promise<void> {
+	if (!osVersionDirs().some((dir) => isInside(resolvedPath, dir))) return;
+	const r = await s.run(resolvedPath, ["--version"], PLAIN_ENV);
+	if (r.missing || r.timedOut) return;
+	const v = parseVersionToken(`${r.stdout}\n${r.stderr}`);
+	if (v) {
+		f.installed = v;
+		addSource(f, "os-version");
+	}
+}
+
+/** `dir` with the home folder written as `~`, for a line the user reads. */
+function homeShort(io: ToolProbeIO, dir: string): string {
+	return isInside(dir, io.homedir)
+		? path.join("~", path.relative(io.homedir, dir))
+		: dir;
+}
+
+/** Owner and version of a copy PATH does not run, read from its path. */
+async function describeCopy(
+	s: ProbeSession,
+	name: string,
+	real: string,
+): Promise<{ owner: string; version: string | null }> {
+	const parts = real.split(path.sep);
+	for (const [marker, owner] of [
+		["Cellar", "Homebrew"],
+		["Caskroom", "a Homebrew cask"],
+	] as const) {
+		const at = parts.lastIndexOf(marker);
+		if (at >= 0 && parts.length > at + 2)
+			return { owner, version: parts[at + 2] ?? null };
+	}
+	const receipt = await installerReceipt(s, name, real);
+	if (receipt)
+		return {
+			owner: `${receipt.app}'s own installer`,
+			version: receipt.version,
+		};
+	const node = await nodeGlobalOwner(s, real);
+	if (node) return { owner: node.via, version: readPackageVersionForBin(real) };
+	if (isSystemPath(real))
+		return { owner: "the operating system", version: null };
+	return { owner: "another installer", version: null };
+}
+
+/**
+ * The other copies of the tool on PATH. The first one wins, and whatever
+ * comes later is never run: a newer copy there is a surprise only the user
+ * can settle, by removing one or reordering PATH.
+ */
+async function findOtherCopies(
+	s: ProbeSession,
+	name: string,
+	f: ToolFacts,
+	onPath: string,
+	resolvedPath: string,
+): Promise<void> {
+	f.pathDir = homeShort(s.io, path.dirname(onPath));
+	if (!s.io.resolveAllExecutables) return;
+	const seen = new Set([resolvedPath]);
+	const copies: OtherCopy[] = [];
+	for (const candidate of await s.io.resolveAllExecutables(name)) {
+		if (candidate === onPath) continue;
+		const real = await s.io.realpath(candidate);
+		if (!real || seen.has(real)) continue;
+		seen.add(real);
+		copies.push({
+			...(await describeCopy(s, name, real)),
+			dir: homeShort(s.io, path.dirname(candidate)),
+		});
+	}
+	if (copies.length > 0) f.otherCopies = copies;
+}
+
 async function probeNodeGlobal(
 	s: ProbeSession,
 	spec: ManagedTool,
@@ -1396,12 +1811,7 @@ async function probeNodeGlobal(
 	const pin = pinOf(spec);
 	const pinned = pin !== undefined;
 	if (spec.via === "bun") {
-		const root = path.join(
-			s.io.env.BUN_INSTALL ?? path.join(s.io.homedir, ".bun"),
-			"install",
-			"global",
-			"node_modules",
-		);
+		const root = bunGlobalRoot(s.io);
 		f.owner = `bun (global ${root})`;
 		const { inside, real } = await containedIn(
 			s,
@@ -1654,13 +2064,31 @@ async function probeInto(
 			break;
 	}
 
+	// Not the spec's installer's file, or it could not tell (npm with no `npm`
+	// to ask), but the path names bun's, npm's or Homebrew's tree: then that is
+	// the owner, and it can upgrade the file PATH runs.
+	if (f.managed !== true) await adoptActualOwner(s, spec, f, resolvedPath);
+	// Or a standalone installer's, which may update itself (`uv self update`).
+	if (f.managed !== true) await adoptOwnInstaller(s, spec, f, resolvedPath);
+
 	// The method's own record was silent. Before anything runs, read what the
 	// installed files already say about themselves.
 	if (f.installed === null) versionFromFiles(f, resolvedPath);
 
+	// A program the operating system ships keeps no record anywhere: ask it.
+	if (f.installed === null) await versionFromOs(s, f, resolvedPath);
+
 	// Still nothing: read the running file itself — but only where the caller
 	// opted into running a check command (see there).
 	if (f.installed === null) await versionFromCheck(s, spec, f, onPath);
+
+	// A KEPT row names who installed it, not the installer magus would use.
+	if (f.managed === false && !f.ownerName) {
+		const who = await nameOwner(s, resolvedPath);
+		if (who) f.ownerName = who;
+	}
+
+	await findOtherCopies(s, spec.name, f, onPath, resolvedPath);
 }
 
 /**

package/src/services/update-engine.ts

@@ -397,7 +397,7 @@ async function readRows(
  * The row Claude Code moved is left as it is: it belongs to this repository,
  * and bringing this repository's rows forward is what the repair does anyway.
  * Null when there was nothing to follow — this project's row moved (2.1.280),
- * or no row of this repository moved at all.
+ * or no row of this repository moved at all and none already holds `target`.
  */
 async function followMisdirectedUpdate(
 	deps: PluginApplyDeps,
@@ -422,14 +422,32 @@ async function followMisdirectedUpdate(
 		scope,
 		projectPath: scope === "user" ? undefined : projectPath,
 	});
-	if (moved.length === 0 || moved.some((row) => rowKey(row) === mine)) {
-		return null;
-	}
-	const version = moved
+	if (moved.some((row) => rowKey(row) === mine)) return null;
+	// The row Claude Code picked may ALREADY hold the target — an earlier run
+	// from another checkout put it there. Then the update writes nothing, so
+	// nothing moves, and this project's row stays behind on every run (seen on
+	// 2.1.296: "the installer exited 0 but mnemex@magus is still 1.1.0" while
+	// tools/claudeup held 1.1.1). A row of this repository at exactly the
+	// target is the same misdirection, already landed.
+	const landed =
+		moved.length > 0 || !target
+			? moved
+			: after.filter(
+					(row) =>
+						row.version === target &&
+						rowKey(row) !== mine &&
+						inThisRepository(row, projectPath),
+				);
+	if (landed.length === 0) return null;
+	const version = landed
 		.map((row) => row.version)
 		.reduce((a, b) => ((compareVersions(b, a) ?? 0) > 0 ? b : a));
 	if (!isRepairablyBehind(version, now)) return null;
-	const elsewhere = moved.map((row) => row.projectPath ?? `${row.scope} scope`);
+	// Already landed, every checkout at the target matches, but Claude Code
+	// wrote to one of them: report one folder, not all of them.
+	const elsewhere = (moved.length > 0 ? landed : landed.slice(0, 1)).map(
+		(row) => row.projectPath ?? `${row.scope} scope`,
+	);
 	if (target && version !== target) {
 		return {
 			elsewhere,

package/src/services/update-plan.ts

@@ -1034,6 +1034,8 @@ export interface BinUpdateItem {
 	 * the same value the TUI's row runs on Enter.
 	 */
 	upgradeCommand?: Command;
+	/** {@link ToolStatus.shadowed}: a newer copy later on PATH, unused. */
+	shadowed?: string;
 	/** The exact pin, when the profile declares one. */
 	version?: string;
 	/** The version PATH runs, or null when absent / unreadable. */
@@ -1089,6 +1091,7 @@ export function planBinUpdates(
 		};
 		if (status.note) item.note = status.note;
 		if (status.adopted) item.adopted = status.adopted;
+		if (status.shadowed) item.shadowed = status.shadowed;
 		if (f?.upgradeCommand) item.upgradeCommand = f.upgradeCommand;
 		if (bin.version) item.version = bin.version;
 		return item;

package/src/ui/renderers/cliToolRenderers.tsx

@@ -397,6 +397,17 @@ export function renderCliToolDetail(
 						</text>
 					</box>
 				) : null}
+				{/* A newer copy later on PATH, which nothing runs. */}
+				{status?.shadowed ? (
+					<box flexDirection="row">
+						<text fg={theme.colors.muted} flexShrink={0}>
+							{"Warning  "}
+						</text>
+						<text fg={theme.colors.warning} minWidth={0}>
+							{wrapValue(`⚠ ${status.shadowed}`, width)}
+						</text>
+					</box>
+				) : null}
 				{status?.installed ? (
 					<box flexDirection="row">
 						<text fg={theme.colors.muted} flexShrink={0}>