magus-cli 7.10.3 → 7.10.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.10.3",
+  "version": "7.10.5",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.10.3",
-    "magus-cli-darwin-x64": "7.10.3",
-    "magus-cli-linux-x64": "7.10.3"
+    "magus-cli-darwin-arm64": "7.10.5",
+    "magus-cli-darwin-x64": "7.10.5",
+    "magus-cli-linux-x64": "7.10.5"
   }
 }

package/src/__tests__/blackbox-convergence.test.ts

@@ -59,7 +59,6 @@ const SPECS: Record<string, ResolvedBin> = {
 	tmux: {
 		name: "tmux",
 		via: "brew",
-		check: "tmux -V",
 		sources: ["terminal@magus"],
 	},
 	gemini: {

package/src/__tests__/blackbox-parity.test.ts

@@ -670,8 +670,8 @@ describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
 		}
 
 		const crush = p.cliBins.get("crush");
-		expect(crush?.reason).toBe("not-managed");
-		expect(crush?.action).not.toBe("upgrade");
+		expect(crush?.action).toBe("external");
+		expect(crush?.reason).toBe("installed-elsewhere");
 		expect(p.cliBins.get("gemini")?.note).toBeTruthy();
 	});
 

package/src/__tests__/blackbox-tool-state.test.ts

@@ -250,7 +250,7 @@ describe("classifyTool — unpinned", () => {
 		expect(got.state).toBe("unknown");
 	});
 
-	test("behind, but the upgrade would not replace the file PATH runs: not upgrade / not-managed", () => {
+	test("behind, but the upgrade would not replace the file PATH runs: not upgrade / installed elsewhere", () => {
 		const got = classifyTool(
 			{ name: "crush", via: "npm" },
 			facts("crush", {
@@ -261,7 +261,8 @@ describe("classifyTool — unpinned", () => {
 			}),
 		);
 		expect(got.state).not.toBe("upgrade");
-		expect(got.reason).toBe("not-managed");
+		expect(got.state).toBe("external");
+		expect(got.reason).toBe("installed-elsewhere");
 	});
 
 	test("behind, but held back by the installer: not upgrade / held-back", () => {
@@ -457,25 +458,16 @@ describe("planBinUpdates and the one work predicate", () => {
 // ── the probe, through injected IO ─────────────────────────────────────────
 
 function brewIO(opts: { installed: string; outdatedJson: string }) {
+	const keg = `/opt/homebrew/Cellar/tmux/${opts.installed}/bin/tmux`;
 	return fakeIO({
 		paths: { tmux: "/opt/homebrew/bin/tmux", brew: "/opt/homebrew/bin/brew" },
-		realpaths: {
-			"/opt/homebrew/bin/tmux": `/opt/homebrew/Cellar/tmux/${opts.installed}/bin/tmux`,
-		},
-		env: {
-			HOMEBREW_PREFIX: "/opt/homebrew",
-			HOMEBREW_CELLAR: "/opt/homebrew/Cellar",
-		},
+		realpaths: { "/opt/homebrew/bin/tmux": keg },
 		exec: ([cmd, ...args]) => {
 			if (cmd === "brew") {
 				if (args.includes("outdated")) return OK(opts.outdatedJson);
-				if (args.includes("list")) return OK(`tmux ${opts.installed}\n`);
-				if (args.includes("--cellar")) return OK("/opt/homebrew/Cellar\n");
-				if (args.includes("--prefix"))
-					return OK(
-						args.length > 1 ? "/opt/homebrew/opt/tmux\n" : "/opt/homebrew\n",
-					);
-				if (args.includes("--repository")) return OK("/opt/homebrew\n");
+				if (args.includes("--versions")) return OK(`tmux ${opts.installed}\n`);
+				// brew's own file list for the formula names the keg file.
+				if (args.includes("list")) return OK(`${keg}\n`);
 			}
 			if (cmd === "tmux") return OK(`tmux ${opts.installed}\n`);
 			return undefined;
@@ -492,7 +484,6 @@ describe("probeTool through injected IO (no real brew/uv, no network)", () => {
 		const spec: BinRequirement = {
 			name: "tmux",
 			via: "brew",
-			check: "tmux -V",
 		};
 
 		const f = await probeTool(spec, io, { timeoutMs: 500, deadlineMs: 2000 });
@@ -521,7 +512,6 @@ describe("probeTool through injected IO (no real brew/uv, no network)", () => {
 		const spec: BinRequirement = {
 			name: "tmux",
 			via: "brew",
-			check: "tmux -V",
 		};
 
 		const f = await probeTool(spec, io, { timeoutMs: 500, deadlineMs: 2000 });

package/src/__tests__/blind/c14-cli-row-label.test.ts

@@ -113,7 +113,12 @@ const SPEC: BinRequirement = {
 
 type UnknownReason = Exclude<
 	ToolStatus["reason"],
-	"absent" | "up-to-date" | "behind" | "at-pin" | "behind-pin"
+	| "absent"
+	| "up-to-date"
+	| "behind"
+	| "at-pin"
+	| "behind-pin"
+	| "installed-elsewhere"
 >;
 
 /** Every reason that can put a row in `unknown`, with realistic versions. */
@@ -133,7 +138,7 @@ const UNKNOWN: Record<
 		target: null,
 		pin: "2.0.0",
 	},
-	"not-managed": { installed: "1.2.3", latest: "2.0.0", target: null },
+	"owner-unknown": { installed: "1.2.3", latest: "2.0.0", target: null },
 	"held-back": {
 		installed: "1.2.3",
 		latest: "2.0.0",
@@ -184,8 +189,8 @@ describe("C14 — cliToolStatusText on an unknown row", () => {
 				"ahead-of-pin",
 				"held-back",
 				"latest-unavailable",
-				"not-managed",
 				"not-probed",
+				"owner-unknown",
 				"pin-not-installable",
 				"unorderable",
 				"version-unreadable",

package/src/__tests__/blind/c15-probe-ownership.test.ts

@@ -277,11 +277,11 @@ describe("C15 (a) — npm package in a prefix other than `npm root -g`", () => {
 		expect(prefixOf(args)).toBe(NVM);
 	});
 
-	test("R9.7 classifyTool says upgrade, never the not-managed veto", async () => {
+	test("R9.7 classifyTool says upgrade, never the installed-elsewhere veto", async () => {
 		const { facts } = await probe(CRUSH, nvmCrush(OTHER_NPM_ROOT));
 		const status = classifyTool(CRUSH, facts);
 		expect(status.state).toBe("upgrade");
-		expect(status.reason).not.toBe("not-managed");
+		expect(status.reason).not.toBe("installed-elsewhere");
 	});
 
 	test("R9.7 control: at the registry's latest, classifyTool says current (still managed)", async () => {
@@ -324,7 +324,7 @@ describe("C15 (b) — npm package in the prefix `npm root -g` reports", () => {
 		});
 		const status = classifyTool(CRUSH, facts);
 		expect(status.state).toBe("upgrade");
-		expect(status.reason).not.toBe("not-managed");
+		expect(status.reason).not.toBe("installed-elsewhere");
 	});
 });
 
@@ -361,12 +361,12 @@ describe("C15 (c) — a crush binary that npm does not own", () => {
 		expect(facts.managed).not.toBe(true);
 	});
 
-	test("R9.7 classifyTool keeps the not-managed veto for it (external / not-managed)", async () => {
+	test("R9.7 classifyTool keeps the veto for it: installed elsewhere, never an upgrade", async () => {
 		const { facts } = await probe(CRUSH, elsewhere());
 		const status = classifyTool(CRUSH, facts);
 		expect({ state: status.state, reason: status.reason }).toEqual({
 			state: "external",
-			reason: "not-managed",
+			reason: "installed-elsewhere",
 		});
 	});
 
@@ -449,14 +449,14 @@ describe("C15 (d) — claude resolving into <home>/.local/share/claude/versions/
 		expect(facts.upgradeCommand).toEqual({ cmd: "claude", args: ["update"] });
 	});
 
-	test("R9.8 classifyTool says upgrade, never the not-managed veto", async () => {
+	test("R9.8 classifyTool says upgrade, never the installed-elsewhere veto", async () => {
 		const { facts } = await probe(CLAUDE, nativeClaude());
 		const status = classifyTool(CLAUDE, facts);
 		expect(status.state).toBe("upgrade");
-		expect(status.reason).not.toBe("not-managed");
+		expect(status.reason).not.toBe("installed-elsewhere");
 	});
 
-	test("R9.8 an npm copy of claude-code at `npm root -g` does not trigger the second-copy veto", async () => {
+	test("R9.8 an npm copy of claude-code at `npm root -g` does not trigger the installed-elsewhere veto", async () => {
 		const { facts } = await probe(CLAUDE, nativeClaude({ npmCopy: "2.0.1" }));
 		expect({
 			installed: facts.installed,
@@ -469,7 +469,7 @@ describe("C15 (d) — claude resolving into <home>/.local/share/claude/versions/
 		});
 		const status = classifyTool(CLAUDE, facts);
 		expect(status.state).toBe("upgrade");
-		expect(status.reason).not.toBe("not-managed");
+		expect(status.reason).not.toBe("installed-elsewhere");
 	});
 
 	test("R9.8 control: at the registry's latest, classifyTool says current", async () => {
@@ -521,13 +521,13 @@ describe("C15 (e) — a claude binary outside the native layout and outside node
 		expect(isClaudeUpdate).toBe(false);
 	});
 
-	test("R9.8 it is not managed, and classifyTool keeps the not-managed veto", async () => {
+	test("R9.8 it is not managed, and classifyTool keeps the veto: installed elsewhere", async () => {
 		const { facts } = await probe(CLAUDE, strayClaude());
 		expect(facts.managed).not.toBe(true);
 		const status = classifyTool(CLAUDE, facts);
 		expect({ state: status.state, reason: status.reason }).toEqual({
 			state: "external",
-			reason: "not-managed",
+			reason: "installed-elsewhere",
 		});
 	});
 });

package/src/__tests__/blind/c16-probe-adopts-node-global.test.ts

@@ -2,7 +2,7 @@
  * Blind tests, contract C16: a tool whose declared installer does not own the
  * file PATH runs is adopted by the node installer (bun or npm) when that file
  * lies in bun's global tree or an npm global prefix. Otherwise it stays
- * external / not-managed with a note that names no path.
+ * external / installed-elsewhere, with no note.
  *
  * Written from the spec only. Every fact reaches `probeTool` through a
  * scripted fake `ToolProbeIO`.
@@ -245,15 +245,17 @@ describe("C16 case 6: file in no node tree, brew spec", () => {
 			...CELLAR,
 		},
 	};
-	test("external / not-managed, note names who did not install it", async () => {
+	// Merged design (docs/plans/2026-10-08-magus-update-tool-rows.md): one
+	// state, `external` / `installed-elsewhere`, which carries no note — the
+	// row reads "installed elsewhere" and is counted, not explained.
+	test("external / installed-elsewhere, with no note and no path", async () => {
 		const f = await probeTool(spec, fakeIO(world));
 		const s = classifyTool(spec, f);
 		expect(s.state).toBe("external");
-		expect(s.reason).toBe("not-managed");
-		expect(s.note).toBe("installed by an installer magus does not update");
-		expect(s.note?.includes("/")).toBe(false);
+		expect(s.reason).toBe("installed-elsewhere");
+		expect(s.note).toBeUndefined();
 	});
-	test("an npm spec gets the same note: it names who installed it, never the spec installer", async () => {
+	test("an npm spec is installed elsewhere too", async () => {
 		const npmSpec: BinRequirement = { name: "uv", via: "npm", package: "uv" };
 		const f = await probeTool(
 			npmSpec,
@@ -264,17 +266,19 @@ describe("C16 case 6: file in no node tree, brew spec", () => {
 		);
 		const s = classifyTool(npmSpec, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("installed by an installer magus does not update");
+		expect(s.note).toBeUndefined();
 	});
-	test("a pinned spec in that situation stays unknown", async () => {
+	// Merged design: a pin changes nothing when no installer magus drives has
+	// the tool; it is still installed elsewhere (tool-probe.test.ts M3).
+	test("a pinned spec in that situation is installed elsewhere too", async () => {
 		const pinned: BinRequirement = { ...spec, version: "1.0.0" };
 		const f = await probeTool(pinned, fakeIO(world));
-		expect(classifyTool(pinned, f).state).toBe("unknown");
+		expect(classifyTool(pinned, f).state).toBe("external");
 	});
 });
 
 describe("C16 case 7: operating-system file", () => {
-	test("zsh in /bin is external with the operating-system note", async () => {
+	test("zsh in /bin is external, with no note", async () => {
 		const spec: BinRequirement = { name: "zsh", via: "brew", formula: "zsh" };
 		const f = await probeTool(
 			spec,
@@ -286,8 +290,8 @@ describe("C16 case 7: operating-system file", () => {
 		);
 		const s = classifyTool(spec, f);
 		expect(s.state).toBe("external");
-		expect(s.reason).toBe("not-managed");
-		expect(s.note).toBe("comes with the operating system");
+		expect(s.reason).toBe("installed-elsewhere");
+		expect(s.note).toBeUndefined();
 	});
 });
 

package/src/__tests__/blind/c17-enter-label.test.ts

@@ -22,6 +22,11 @@
  * downgrade, and latest moves further past the pin. Every other `unknown`
  * reason keeps "update anyway".
  *
+ * AMENDED 2026-10-08: a `held-back` row (a brew pin) has NO Enter action
+ * either. Nothing magus runs can move it, so "update anyway" is a no-op; the
+ * user's fix is `brew unpin <formula>`, which the CLI shows as the row's
+ * command (docs/plans/2026-10-08-magus-update-tool-rows.md, decision 4).
+ *
  * Pure: rows are built by hand to the CliToolRow contract. No IO. Modules are
  * loaded dynamically so a missing export fails each test, not the whole file.
  */
@@ -245,14 +250,13 @@ const CASES: Case[] = [
 		kind: "reinstall",
 		label: "reinstall",
 	},
-	// Every `unknown` reason except `ahead-of-pin`, which has no Enter action
-	// (R5.9 AMENDED) and is covered in its own block below.
+	// Every `unknown` reason except `ahead-of-pin` and `held-back`, which have
+	// no Enter action (R5.9 AMENDED) and are covered in their own blocks below.
 	...(
 		[
 			["version-unreadable", null, "2.0.0", undefined],
 			["unorderable", "nightly-2026-09-01", "2.0.0", undefined],
-			["not-managed", "1.2.3", "2.0.0", undefined],
-			["held-back", "1.2.3", "2.0.0", "1.2.3"],
+			["owner-unknown", "1.2.3", "2.0.0", undefined],
 			["pin-not-installable", "1.2.3", "2.0.0", "9.9.9"],
 			["latest-unavailable", "1.2.3", null, undefined],
 			["not-probed", null, null, undefined],
@@ -307,6 +311,23 @@ describe("C17 — cliToolEnterAction while the row is being checked", () => {
 	});
 });
 
+describe("C17 — cliToolEnterAction on a tool installed another way", () => {
+	// docs/plans/2026-10-08-magus-update-tool-rows.md, decision 6: an `external`
+	// row offers nothing. Without its guard it fell through to `reinstall`,
+	// which would install a second copy through an installer that does not own
+	// the file — an if-chain the compiler does not check.
+	test("external / installed-elsewhere → null (Enter does nothing)", async () => {
+		const st = status({
+			state: "external",
+			reason: "installed-elsewhere",
+			installed: "1.2.3",
+			latest: "2.0.0",
+			target: null,
+		});
+		expect(await enterAction(row(st))).toBeNull();
+	});
+});
+
 describe("C17 — cliToolEnterAction per state", () => {
 	for (const c of CASES) {
 		test(`R5.9 ${c.name}: kind "${c.kind}", footer label "${c.label}"`, async () => {
@@ -426,14 +447,28 @@ describe("C17 — cliToolEnterAction for ahead-of-pin rows (R5.9 AMENDED)", () =
 		expect(hints.filter((b) => b.id === ENTER_ID)).toEqual([]);
 	});
 
-	test("R5.9 control: the other unknown reasons still offer update anyway (ahead-of-pin is the only exception)", async () => {
+	test("R5.9 unknown / held-back (AMENDED 2026-10-08): no Enter action, whatever commands the row carries", async () => {
+		const held = row(
+			status({
+				state: "unknown",
+				reason: "held-back",
+				installed: "1.2.3",
+				latest: "2.0.0",
+				target: null,
+			}),
+			{ withUpdate: true },
+		);
+		const a = await enterAction(held);
+		expect(a === null ? null : { kind: a.kind, command: a.command }).toBeNull();
+	});
+
+	test("R5.9 control: the other unknown reasons still offer update anyway (ahead-of-pin and held-back are the exceptions)", async () => {
 		const others = CASES.filter((c) => c.fields.state === "unknown");
 		expect(others.map((c) => c.fields.reason).sort()).toEqual(
 			[
-				"held-back",
 				"latest-unavailable",
-				"not-managed",
 				"not-probed",
+				"owner-unknown",
 				"pin-not-installable",
 				"unorderable",
 				"version-unreadable",

package/src/__tests__/blind/c18-probe-adopts-homebrew-keg.test.ts

@@ -1,9 +1,15 @@
 /**
- * Blind tests, contract C18: Homebrew owns an installed tool whose file lies
- * in `<brew prefix>/Cellar/<short name>/<version>/...`, whatever installer the
- * spec declares. A pinned spec is not adopted (brew takes no version).
+ * Blind tests, contract C18: Homebrew owns an installed tool when Homebrew
+ * says it has it, whatever installer the spec declares. A pinned spec is not
+ * adopted (brew takes no version).
  *
  * 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):
+ * magus never reads ownership or a version off a Cellar path. It asks
+ * `brew list --versions <formula>` and reads the version PATH runs with its
+ * own version command, so the fake world answers those two questions instead
+ * of `brew --prefix`. Every expectation below is unchanged.
  */
 import { describe, expect, test } from "bun:test";
 import {
@@ -74,8 +80,12 @@ function fakeIO(setup: FakeSetup): ToolProbeIO & { calls: string[] } {
 
 const PREFIX = "/opt/homebrew";
 const CELLAR = { "/opt/homebrew/Cellar": "/opt/homebrew/Cellar" };
-const BREW_PREFIX_OK: Record<string, Partial<ExecResult>> = {
-	"brew --prefix": { stdout: `${PREFIX}\n` },
+
+/** What each tool's own version command prints (`data/tool-versions.ts`). */
+const VERSION_OUTPUT: Record<string, (v: string) => [string, string]> = {
+	claudish: (v) => ["claudish --version", `claudish version ${v}\n`],
+	mnemex: (v) => ["mnemex --version", `mnemex v${v}\n`],
+	tmux: (v) => ["tmux -V", `tmux ${v}\n`],
 };
 
 const OUTDATED_NONE = JSON.stringify({ formulae: [], casks: [] });
@@ -92,22 +102,34 @@ const outdatedBehind = (name: string, installed: string, current: string) =>
 		casks: [],
 	});
 
-/** A tool whose PATH entry resolves into a Homebrew keg. */
+/**
+ * A tool whose PATH entry resolves into a Homebrew keg. `list` is brew's
+ * answer to `brew list --versions <formula>`: the default lists the keg,
+ * `"missing"` means no brew is installed.
+ */
 function kegWorld(
 	bin: string,
 	short: string,
 	version: string,
 	outdatedKey: string,
 	outdatedStdout: string,
-	extraExec: Record<string, Partial<ExecResult>> = BREW_PREFIX_OK,
+	list: Partial<ExecResult> | "missing" = { stdout: `${short} ${version}\n` },
 ): FakeSetup {
 	const file = `${PREFIX}/Cellar/${short}/${version}/bin/${bin}`;
 	const onPath = `${PREFIX}/bin/${bin}`;
+	const versionCmd = VERSION_OUTPUT[bin]?.(version);
 	return {
 		onPath: { [bin]: onPath },
 		real: { [onPath]: file, [file]: file, ...CELLAR },
 		exec: {
-			...extraExec,
+			...(list === "missing"
+				? {}
+				: {
+						[`brew list --versions ${outdatedKey}`]: list,
+						// brew's own file list for the formula names the keg file.
+						[`brew list ${outdatedKey}`]: { stdout: `${file}\n` },
+					}),
+			...(versionCmd ? { [versionCmd[0]]: { stdout: versionCmd[1] } } : {}),
 			[`brew outdated --json=v2 ${outdatedKey}`]: { stdout: outdatedStdout },
 		},
 	};
@@ -248,7 +270,6 @@ describe("C18 case 6: a directory merely named Cellar is not Homebrew's", () =>
 			fakeIO({
 				onPath: { claudish: file },
 				real: { [file]: file, ...CELLAR },
-				exec: BREW_PREFIX_OK,
 			}),
 		);
 		expect(f.managed).not.toBe(true);
@@ -263,25 +284,22 @@ describe("C18 case 7: Homebrew unavailable", () => {
 		via: "bun",
 		package: "claudish",
 	};
-	const world = (exec: Record<string, Partial<ExecResult>>): FakeSetup =>
+	const world = (list: Partial<ExecResult> | "missing"): FakeSetup =>
 		kegWorld(
 			"claudish",
 			"claudish",
 			"10.5.0",
 			"claudish",
 			outdatedBehind("claudish", "10.5.0", "10.6.0"),
-			exec,
+			list,
 		);
-	test("brew --prefix missing: not adopted", async () => {
-		const f = await probeTool(spec, fakeIO(world({})));
+	test("brew missing: not adopted", async () => {
+		const f = await probeTool(spec, fakeIO(world("missing")));
 		expect(f.upgradeCommand?.cmd).not.toBe("brew");
 		expect(classifyTool(spec, f).state).not.toBe("upgrade");
 	});
-	test("brew --prefix exits non-zero: not adopted", async () => {
-		const f = await probeTool(
-			spec,
-			fakeIO(world({ "brew --prefix": { code: 1, stderr: "boom" } })),
-		);
+	test("brew list fails with an error: not adopted", async () => {
+		const f = await probeTool(spec, fakeIO(world({ code: 1, stderr: "boom" })));
 		expect(f.upgradeCommand?.cmd).not.toBe("brew");
 		expect(classifyTool(spec, f).state).not.toBe("upgrade");
 	});
@@ -329,7 +347,6 @@ describe("C18 case 9: bun ownership still wins over a brew spec", () => {
 						version: "0.36.2",
 					}),
 				},
-				exec: BREW_PREFIX_OK,
 				fetch: {
 					"https://registry.npmjs.org/-/package/mnemex/dist-tags": {
 						ok: true,