magus-cli 7.10.2 → 7.10.4

package/src/__tests__/blind/c19-probe-owner-version-shadow.test.ts

@@ -0,0 +1,392 @@
+/**
+ * Blind tests, contract C19: a KEPT row names who installed the file, shows its
+ * version whenever it can be read, drives a self-updating standalone installer
+ * (uv's receipt), and reports a newer copy hidden later on PATH.
+ *
+ * Written from the spec only, through a scripted fake `ToolProbeIO`.
+ *
+ * Merged with the tool-rows design (docs/plans/2026-10-08-magus-update-tool-rows.md,
+ * decision 7). Kept as written: the uv receipt cases (A1–A5) and the guards.
+ * Changed, because they contradict that design's rules:
+ *  - An `external` row carries no note, so the owner sentences (A6, B7–B10,
+ *    C11–C12) now expect none. They were read off Cellar, Caskroom and cargo
+ *    paths, which the design forbids. A pinned tool no installer has (B10) is
+ *    `external`, not `unknown`.
+ *  - zsh's version comes from magus's own version command (`zsh --version`,
+ *    bare name), not from running a file chosen by a path test, so C's fake
+ *    world answers that command.
+ *  - A copy later on PATH is counted (`otherCopies`), never described: its
+ *    owner and version were read off its path, and the warning named a PATH
+ *    folder with nothing for the user to run. So D expects a count, and an
+ *    older copy (D14) counts too — telling older from newer would need that
+ *    same guess.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	type ExecResult,
+	type FetchJsonResult,
+	type ToolProbeIO,
+	classifyTool,
+	probeTool,
+} from "../../services/tool-probe.js";
+import type { BinRequirement } from "../../types/index.js";
+
+interface FakeSetup {
+	exec?: Record<string, Partial<ExecResult>>;
+	fetch?: Record<string, FetchJsonResult>;
+	files?: Record<string, string>;
+	real?: Record<string, string>;
+	onPath?: Record<string, string>;
+	allOnPath?: Record<string, string[]>;
+	env?: Record<string, string>;
+	noAll?: boolean;
+}
+
+const HOME = "/home/u";
+
+function fakeIO(
+	setup: FakeSetup,
+): ToolProbeIO & { calls: string[]; reads: string[] } {
+	const calls: string[] = [];
+	const reads: string[] = [];
+	const io: ToolProbeIO & { calls: string[]; reads: string[] } = {
+		calls,
+		reads,
+		exec: async (command) => {
+			const key = [command.cmd, ...command.args].join(" ");
+			calls.push(key);
+			const h = setup.exec?.[key];
+			if (h === undefined) {
+				return {
+					code: null,
+					stdout: "",
+					stderr: "",
+					timedOut: false,
+					missing: true,
+				};
+			}
+			return {
+				code: 0,
+				stdout: "",
+				stderr: "",
+				timedOut: false,
+				missing: false,
+				...h,
+			};
+		},
+		fetchJson: async (url) =>
+			setup.fetch?.[url] ?? { ok: false, reason: "returned 404" },
+		readJson: async (file) => {
+			reads.push(file);
+			const t = setup.files?.[file];
+			if (t === undefined) return null;
+			try {
+				return JSON.parse(t);
+			} catch {
+				return null;
+			}
+		},
+		readText: async (file) => setup.files?.[file] ?? null,
+		readlink: async () => null,
+		realpath: async (file) => setup.real?.[file] ?? null,
+		resolveExecutable: async (name) => setup.onPath?.[name] ?? null,
+		env: setup.env ?? {},
+		homedir: HOME,
+	};
+	if (!setup.noAll) {
+		io.resolveAllExecutables = async (name: string) =>
+			setup.allOnPath?.[name] ??
+			(setup.onPath?.[name] !== undefined
+				? [setup.onPath[name] as string]
+				: []);
+	}
+	return io;
+}
+
+const PREFIX = "/opt/homebrew";
+const BREW_PREFIX_OK: Record<string, Partial<ExecResult>> = {
+	"brew --prefix": { stdout: `${PREFIX}\n` },
+};
+const CELLAR = { "/opt/homebrew/Cellar": "/opt/homebrew/Cellar" };
+
+const UV: BinRequirement = { name: "uv", via: "brew", formula: "uv" };
+const UV_FILE = "/home/u/.local/bin/uv";
+const UV_RECEIPT_PATH = "/home/u/.config/uv/uv-receipt.json";
+const uvReceipt = (prefix = "/home/u/.local/bin", version = "0.11.15") =>
+	JSON.stringify({
+		binaries: ["uv", "uvx"],
+		install_prefix: prefix,
+		source: { app_name: "uv", name: "uv", owner: "astral-sh" },
+		version,
+	});
+const pypi = (v: string): Record<string, FetchJsonResult> => ({
+	"https://pypi.org/pypi/uv/json": { ok: true, body: { info: { version: v } } },
+});
+
+function uvWorld(opts: {
+	latest?: string;
+	receiptPrefix?: string;
+	receiptAt?: string;
+	env?: Record<string, string>;
+	extra?: Partial<FakeSetup>;
+}): FakeSetup {
+	return {
+		onPath: { uv: UV_FILE },
+		real: { [UV_FILE]: UV_FILE },
+		files: {
+			[opts.receiptAt ?? UV_RECEIPT_PATH]: uvReceipt(opts.receiptPrefix),
+		},
+		fetch: pypi(opts.latest ?? "0.13.0"),
+		env: opts.env ?? {},
+		...opts.extra,
+	};
+}
+
+describe("C19 A: uv's own installer is a driven owner", () => {
+	test("1. receipt, PyPI newer: managed, upgrade, uv self update", async () => {
+		const f = await probeTool(UV, fakeIO(uvWorld({})));
+		expect(f.installed).toBe("0.11.15");
+		expect(f.managed).toBe(true);
+		expect(f.latest).toBe("0.13.0");
+		expect(f.upgradeCommand).toEqual({ cmd: "uv", args: ["self", "update"] });
+		const s = classifyTool(UV, f);
+		expect(s.state).toBe("upgrade");
+		expect(s.target).toBe("0.13.0");
+	});
+
+	test("2. PyPI equals installed: current", async () => {
+		const f = await probeTool(UV, fakeIO(uvWorld({ latest: "0.11.15" })));
+		expect(classifyTool(UV, f).state).toBe("current");
+	});
+
+	test("3. pinned spec: upgrade to the pin with a versioned command", async () => {
+		const spec: BinRequirement = { ...UV, version: "0.12.0" };
+		const f = await probeTool(spec, fakeIO(uvWorld({})));
+		expect(f.upgradeCommand).toEqual({
+			cmd: "uv",
+			args: ["self", "update", "0.12.0"],
+		});
+		const s = classifyTool(spec, f);
+		expect(s.state).toBe("upgrade");
+		expect(s.target).toBe("0.12.0");
+	});
+
+	test("4. receipt for a different install_prefix is ignored", async () => {
+		const f = await probeTool(
+			UV,
+			fakeIO(uvWorld({ receiptPrefix: "/somewhere/else" })),
+		);
+		expect(f.managed).not.toBe(true);
+		expect(f.upgradeCommand).toBeUndefined();
+		expect(classifyTool(UV, f).state).not.toBe("upgrade");
+	});
+
+	test("5. XDG_CONFIG_HOME relocates the receipt", async () => {
+		const io = fakeIO(
+			uvWorld({
+				env: { XDG_CONFIG_HOME: "/xdg" },
+				extra: {
+					// a decoy at the default place must not be the one used
+					files: {
+						"/xdg/uv/uv-receipt.json": uvReceipt(),
+						[UV_RECEIPT_PATH]: uvReceipt("/home/u/.local/bin", "9.9.9"),
+					},
+				},
+			}),
+		);
+		const f = await probeTool(UV, io);
+		expect(f.installed).toBe("0.11.15");
+		expect(f.managed).toBe(true);
+		expect(io.reads).toContain("/xdg/uv/uv-receipt.json");
+		expect(io.reads).not.toContain(UV_RECEIPT_PATH);
+	});
+
+	test("6. receipt of an installer magus cannot update: external, versioned, named", async () => {
+		const spec: BinRequirement = { name: "ruff", via: "brew", formula: "ruff" };
+		const file = "/home/u/.local/bin/ruff";
+		const f = await probeTool(
+			spec,
+			fakeIO({
+				onPath: { ruff: file },
+				real: { [file]: file },
+				files: {
+					"/home/u/.config/ruff/ruff-receipt.json": JSON.stringify({
+						binaries: ["ruff"],
+						install_prefix: "/home/u/.local/bin",
+						source: { app_name: "ruff", name: "ruff", owner: "astral-sh" },
+						version: "0.9.1",
+					}),
+				},
+				exec: BREW_PREFIX_OK,
+			}),
+		);
+		expect(f.installed).toBe("0.9.1");
+		expect(f.upgradeCommand).toBeUndefined();
+		const s = classifyTool(spec, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+});
+
+describe("C19 B: a file no driven installer has is installed elsewhere, with no note", () => {
+	const spec = (
+		name: string,
+		extra: Partial<BinRequirement> = {},
+	): BinRequirement => ({
+		name,
+		via: "brew",
+		formula: name,
+		...extra,
+	});
+	const world = (
+		name: string,
+		file: string,
+		env: Record<string, string> = {},
+	): FakeSetup => ({
+		onPath: { [name]: file },
+		real: { [file]: file, ...CELLAR },
+		exec: BREW_PREFIX_OK,
+		env,
+	});
+
+	test("7. Homebrew cask", async () => {
+		const sp = spec("madbench");
+		const file = "/opt/homebrew/Caskroom/madbench/0.43.2/madbench";
+		const f = await probeTool(sp, fakeIO(world("madbench", file)));
+		const s = classifyTool(sp, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+
+	test("8a. cargo bin under the home directory", async () => {
+		const sp = spec("rg");
+		const f = await probeTool(sp, fakeIO(world("rg", "/home/u/.cargo/bin/rg")));
+		const s = classifyTool(sp, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+
+	test("8b. cargo bin under CARGO_HOME", async () => {
+		const sp = spec("rg");
+		const f = await probeTool(
+			sp,
+			fakeIO(world("rg", "/opt/cargo/bin/rg", { CARGO_HOME: "/opt/cargo" })),
+		);
+		const s = classifyTool(sp, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+
+	test("9. unrecognised place, never says 'outside'", async () => {
+		const sp = spec("foo");
+		const f = await probeTool(
+			sp,
+			fakeIO(world("foo", "/home/u/tools/bin/foo")),
+		);
+		const s = classifyTool(sp, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+
+	test("10. pinned spec with a cargo file", async () => {
+		const sp = spec("rg", { version: "1.0.0" });
+		const f = await probeTool(sp, fakeIO(world("rg", "/home/u/.cargo/bin/rg")));
+		const s = classifyTool(sp, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+});
+
+describe("C19 C: operating-system programs show their version", () => {
+	const zsh: BinRequirement = { name: "zsh", via: "brew", formula: "zsh" };
+	const world = (zshExec?: Partial<ExecResult>): FakeSetup => ({
+		onPath: { zsh: "/bin/zsh" },
+		real: { "/bin/zsh": "/bin/zsh", ...CELLAR },
+		exec: {
+			...BREW_PREFIX_OK,
+			...(zshExec ? { "zsh --version": zshExec } : {}),
+		},
+	});
+
+	test("11. version read from --version", async () => {
+		const f = await probeTool(
+			zsh,
+			fakeIO(world({ stdout: "zsh 5.9 (arm64-apple-darwin25.0)\n" })),
+		);
+		expect(f.installed).toBe("5.9");
+		const s = classifyTool(zsh, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+
+	test("12a. --version exits non-zero: still external, installed null", async () => {
+		const f = await probeTool(
+			zsh,
+			fakeIO(world({ code: 1, stdout: "", stderr: "" })),
+		);
+		expect(f.installed).toBeNull();
+		const s = classifyTool(zsh, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+
+	test("12b. --version missing: still external, installed null", async () => {
+		const f = await probeTool(zsh, fakeIO(world()));
+		expect(f.installed).toBeNull();
+		const s = classifyTool(zsh, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
+	});
+});
+
+describe("C19 D: another copy later on PATH is counted", () => {
+	const BREW_BIN = "/opt/homebrew/bin/uv";
+	const cellarFile = (v: string) => `/opt/homebrew/Cellar/uv/${v}/bin/uv`;
+	const world = (second: string, secondReal: string): FakeSetup =>
+		uvWorld({
+			extra: {
+				allOnPath: { uv: [UV_FILE, second] },
+				real: { [UV_FILE]: UV_FILE, [second]: secondReal, ...CELLAR },
+				exec: BREW_PREFIX_OK,
+				env: { HOMEBREW_PREFIX: PREFIX },
+			},
+		});
+
+	test("13. a Homebrew copy later on PATH: counted, no path, no warning", async () => {
+		const f = await probeTool(
+			UV,
+			fakeIO(world(BREW_BIN, cellarFile("0.13.0"))),
+		);
+		expect(f.otherCopies).toBe(1);
+		expect(JSON.stringify(classifyTool(UV, f))).not.toContain("/");
+	});
+
+	test("14. an older later copy is counted the same: no version is guessed", async () => {
+		const f = await probeTool(
+			UV,
+			fakeIO(world(BREW_BIN, cellarFile("0.10.0"))),
+		);
+		expect(f.otherCopies).toBe(1);
+	});
+
+	test("15. a symlink to the running file is not another copy", async () => {
+		const f = await probeTool(UV, fakeIO(world("/usr/local/bin/uv", UV_FILE)));
+		expect(f.otherCopies).toBeUndefined();
+	});
+
+	test("16. IO without resolveAllExecutables: nothing reported, nothing throws", async () => {
+		const w = world(BREW_BIN, cellarFile("0.13.0"));
+		w.noAll = true;
+		const f = await probeTool(UV, fakeIO(w));
+		expect(f.otherCopies).toBeUndefined();
+	});
+
+	test("17. a current row is counted too", async () => {
+		const w = world(BREW_BIN, cellarFile("0.13.0"));
+		w.fetch = pypi("0.11.15");
+		const f = await probeTool(UV, fakeIO(w));
+		const s = classifyTool(UV, f);
+		expect(s.state).toBe("current");
+		expect(f.otherCopies).toBe(1);
+	});
+});

package/src/__tests__/cli-tool-commands.test.ts

@@ -93,11 +93,12 @@ describe("the catalogue is well-formed", () => {
 		const declared = declaredRequirements();
 		expect(declared.size).toBeGreaterThan(0);
 		for (const entry of catalogue) {
+			// No entry carries a version command: that is data/tool-versions.ts.
+			expect("checkCommand" in entry).toBe(false);
 			if (isOwnedEntry(entry)) {
 				const [plugin] = entry.ownedBy.split("@");
 				expect(declared.get(entry.name) ?? []).toContain(plugin);
 				expect("packageName" in entry).toBe(false);
-				expect("checkCommand" in entry).toBe(false);
 			} else {
 				expect(declared.has(entry.name)).toBe(false);
 			}
@@ -124,7 +125,6 @@ describe("the catalogue is well-formed", () => {
 		expect(
 			claudish && !isPluginManagedItem(claudish) && claudish.tool,
 		).toMatchObject({
-			checkCommand: "claudish --version",
 			packageManager: "bun",
 			packageName: "claudish",
 		});

package/src/__tests__/cli-tool-external-row.test.tsx

@@ -0,0 +1,112 @@
+/**
+ * A tool installed another way (`external`), and one held back, on the CLI
+ * Tools screen (docs/plans/2026-10-08-magus-update-tool-rows.md, decisions 5
+ * and 6).
+ *
+ * The screen is an inventory, so the row stays — but it is not a warning and
+ * not "Up to date": no `?`, a muted icon, "installed elsewhere", a detail
+ * status that says the same, and no Enter action. The list icon and the
+ * detail Status line are if-chains the compiler does not check, which is why
+ * each branch is pinned here. Rendered through OpenTUI's test renderer; no IO.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import { cliTools } from "../data/cli-tools.js";
+import type { CliTool } from "../data/cli-tools.js";
+import type { ToolStatus } from "../services/tool-probe.js";
+import type { CliToolRow } from "../ui/adapters/cliToolsAdapter.js";
+import {
+	renderCliToolDetail,
+	renderCliToolRow,
+} from "../ui/renderers/cliToolRenderers.js";
+
+const TOOL = cliTools.find((t) => t.name === "crush") as CliTool;
+
+function row(status: Pick<ToolStatus, "state" | "reason">): CliToolRow {
+	return {
+		tool: TOOL,
+		spec: { name: TOOL.name, via: "npm", package: TOOL.packageName },
+		checking: false,
+		status: {
+			name: TOOL.name,
+			installed: "0.55.0",
+			latest: null,
+			target: null,
+			...status,
+		},
+		updateCommand: { cmd: "npm", args: ["install", "-g", "x@latest"] },
+		installCommand: { cmd: "npm", args: ["install", "-g", "x"] },
+	};
+}
+
+const EXTERNAL = row({ state: "external", reason: "installed-elsewhere" });
+const CURRENT = row({ state: "current", reason: "up-to-date" });
+
+async function render(node: React.ReactNode, width = 80) {
+	const { captureCharFrame, captureSpans, renderOnce, renderer } =
+		await testRender(<box flexDirection="column">{node}</box>, {
+			width,
+			height: 24,
+		});
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const out = { chars: captureCharFrame(), lines: captureSpans().lines };
+	await act(async () => renderer.destroy());
+	return out;
+}
+
+/** The colour of the row's ● icon. */
+async function iconColour(r: CliToolRow): Promise<string> {
+	const { lines } = await render(renderCliToolRow(r, 0, false));
+	for (const line of lines) {
+		const span = line.spans.find((s) => s.text.includes("●"));
+		if (span) return JSON.stringify(span.fg);
+	}
+	throw new Error("no ● icon on the row");
+}
+
+describe("an external CLI tool row", () => {
+	test("the row says installed elsewhere, with no ?", async () => {
+		const { chars } = await render(renderCliToolRow(EXTERNAL, 0, false));
+		expect(chars).toContain("● Crush v0.55.0 installed elsewhere");
+		expect(chars).not.toContain("?");
+	});
+
+	test("its icon is muted, never the success colour of a current tool", async () => {
+		expect(await iconColour(EXTERNAL)).not.toBe(await iconColour(CURRENT));
+	});
+
+	test("the detail Status says Installed elsewhere, never Up to date, and offers no Enter", async () => {
+		const { chars } = await render(renderCliToolDetail(EXTERNAL, 70), 70);
+		expect(chars).toContain("Status   ● Installed elsewhere");
+		expect(chars).not.toContain("Up to date");
+		expect(chars).not.toContain("Enter");
+	});
+
+	test("control: a current tool's detail still says Up to date", async () => {
+		const { chars } = await render(renderCliToolDetail(CURRENT, 70), 70);
+		expect(chars).toContain("Up to date");
+	});
+});
+
+// A held-back tool was checked — brew says it is behind and pinned — so it is
+// "held back" here as in `magus update`: never `?`, never "not checked".
+const HELD = row({ state: "unknown", reason: "held-back" });
+
+describe("a held-back CLI tool row", () => {
+	test("the row says held back, with no ?", async () => {
+		const { chars } = await render(renderCliToolRow(HELD, 0, false));
+		expect(chars).toContain("‖ Crush v0.55.0 held back");
+		expect(chars).not.toContain("?");
+	});
+
+	test("the detail Status says Held back, never not checked", async () => {
+		const { chars } = await render(renderCliToolDetail(HELD, 70), 70);
+		expect(chars).toContain("Status   ‖ Held back");
+		expect(chars).not.toContain("not checked");
+	});
+});

package/src/__tests__/cli-tools-adapter.test.ts

@@ -19,6 +19,7 @@ import type { ResolvedBin } from "../types/index.js";
 import {
 	type PluginManagedRow,
 	buildToolRow,
+	cliToolEnterAction,
 	cliToolStatusText,
 	countToolRows,
 	isPluginManagedRow,
@@ -85,22 +86,21 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 		const spec = specForCatalogTool(codex, [declared], install);
 		expect(spec).toBe(declared);
 
-		// Through npm, the bun-installed file is not npm's: not-managed.
+		// Through npm, the bun-installed file is not npm's: installed elsewhere.
 		const f = facts("codex", {
 			managed: false,
 			resolvedPath:
 				"/Users/j/.bun/install/global/node_modules/@openai/codex/bin/codex.js",
-			owner: "npm (root /Users/j/.local/lib/node_modules)",
 		});
 		const row = buildToolRow(codex, spec, f, install);
 		const [cli] = planBinUpdates([declared], [f]);
 		expect(row.status).toMatchObject({
 			state: cli!.action,
 			reason: cli!.reason,
-			note: cli!.note,
 			target: cli!.target,
 		});
-		expect(row.status?.reason).toBe("not-managed");
+		expect(row.status?.note).toBe(cli!.note);
+		expect(row.status?.reason).toBe("installed-elsewhere");
 	});
 
 	test("pinned and behind: the row's key installs the PIN, exactly what the CLI runs", () => {
@@ -197,7 +197,7 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 		expect(row.installCommand).toEqual(cliToolInstall(codex));
 	});
 
-	test("detected pnpm → the catalogue's via, and a not-managed row in the user's terms", () => {
+	test("detected pnpm → the catalogue's via, and an installed-elsewhere row with no path", () => {
 		const opencode = catalogue("opencode");
 		const install = { primary: "pnpm" as const, all: ["pnpm" as const] };
 		const spec = specForCatalogTool(opencode, null, install);
@@ -207,15 +207,17 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 			managed: false,
 			resolvedPath:
 				"/Users/j/.local/share/pnpm/global/5/node_modules/opencode-ai/bin/opencode",
-			owner: "npm (root /Users/j/.local/lib/node_modules)",
 		});
 		const row = buildToolRow(opencode, spec, f, install);
-		expect(row.status?.state).toBe("external");
-		expect(row.status?.reason).toBe("not-managed");
-		// No path and no installer directory: the user acts on neither.
-		expect(row.status?.note).toBe("installed outside npm");
-		expect(row.status?.note).not.toContain("/");
-		// Enter still follows how it IS installed (pnpm).
+		expect(row.status).toMatchObject({
+			state: "external",
+			reason: "installed-elsewhere",
+		});
+		expect(row.status?.note).toBeUndefined();
+		// Enter offers nothing for a tool installed another way.
+		expect(cliToolEnterAction(row)).toBeNull();
+		// The row still builds its update command for how it IS installed
+		// (pnpm), even though Enter offers nothing for it.
 		expect(row.updateCommand?.cmd).toBe("pnpm");
 	});
 
@@ -252,26 +254,30 @@ describe("cliToolStatusText — the row's words", () => {
 			primary: "npm",
 			all: ["npm"],
 		});
-		const f = facts("crush", { managed: null });
+		const f = facts("crush", {
+			managed: null,
+			failure: "npm timed out after 8s",
+		});
 		const row = buildToolRow(tool, spec, f);
 		const text = cliToolStatusText(row);
 		expect(text.tone).toBe("warning");
-		expect(text.suffix).toBe(" ? owner not known");
+		expect(text.suffix).toBe(" ? owner unknown");
 		// The note is for the detail pane's "Why", not the row.
 		expect(row.status?.note).toBe(classifyTool(spec, f).note);
 		expect(text.suffix).not.toContain("/");
 	});
 
-	test("external renders muted, naming the installer it is outside of", () => {
+	test("external renders muted as `installed elsewhere`, with no ?", () => {
 		const tool = catalogue("crush");
 		const spec = specForCatalogTool(tool, null, {
 			primary: "npm",
 			all: ["npm"],
 		});
 		const row = buildToolRow(tool, spec, facts("crush", { managed: false }));
-		const text = cliToolStatusText(row);
-		expect(text.tone).toBe("muted");
-		expect(text.suffix).toBe(" · outside npm");
+		expect(cliToolStatusText(row)).toEqual({
+			suffix: " installed elsewhere",
+			tone: "muted",
+		});
 	});
 
 	test("upgrade names the target once, with one v", () => {
@@ -303,13 +309,19 @@ describe("countToolRows — header counts from states", () => {
 			buildToolRow(tool, spec, facts("mnemex", { behind: false })),
 			buildToolRow(tool, spec, facts("mnemex", { behind: true })),
 			buildToolRow(tool, spec, facts("mnemex", { managed: null })),
-			// Another installer's: installed, and not "unverified".
+			// Installed elsewhere: installed, but neither an update nor unverified.
 			buildToolRow(tool, spec, facts("mnemex", { managed: false })),
+			// Held back: checked (behind and pinned), so not unverified either.
+			buildToolRow(
+				tool,
+				spec,
+				facts("mnemex", { behind: true, heldBack: "held by brew pin" }),
+			),
 			buildToolRow(tool, spec, facts("mnemex", { present: false })),
 			buildToolRow(tool, spec, undefined),
 		];
 		expect(countToolRows(rows)).toEqual({
-			installed: 4,
+			installed: 5,
 			updates: 1,
 			unverified: 1,
 		});