magus-cli 7.10.0 → 7.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.10.0",
+  "version": "7.10.1",
   "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.0",
-    "magus-cli-darwin-x64": "7.10.0",
-    "magus-cli-linux-x64": "7.10.0"
+    "magus-cli-darwin-arm64": "7.10.1",
+    "magus-cli-darwin-x64": "7.10.1",
+    "magus-cli-linux-x64": "7.10.1"
   }
 }

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

@@ -361,11 +361,11 @@ 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 (unknown / not-managed)", async () => {
+	test("R9.7 classifyTool keeps the not-managed veto for it (external / not-managed)", async () => {
 		const { facts } = await probe(CRUSH, elsewhere());
 		const status = classifyTool(CRUSH, facts);
 		expect({ state: status.state, reason: status.reason }).toEqual({
-			state: "unknown",
+			state: "external",
 			reason: "not-managed",
 		});
 	});
@@ -526,7 +526,7 @@ describe("C15 (e) — a claude binary outside the native layout and outside node
 		expect(facts.managed).not.toBe(true);
 		const status = classifyTool(CLAUDE, facts);
 		expect({ state: status.state, reason: status.reason }).toEqual({
-			state: "unknown",
+			state: "external",
 			reason: "not-managed",
 		});
 	});

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

@@ -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 naming the real path", () => {
+	test("detected pnpm → the catalogue's via, and a not-managed row in the user's terms", () => {
 		const opencode = catalogue("opencode");
 		const install = { primary: "pnpm" as const, all: ["pnpm" as const] };
 		const spec = specForCatalogTool(opencode, null, install);
@@ -210,8 +210,13 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 			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");
-		expect(row.status?.note).toContain("/Users/j/.local/share/pnpm/");
+		// No path and no installer directory: the user acts on neither.
+		expect(row.status?.note).toBe(
+			"installed outside npm, so magus leaves it as is",
+		);
+		expect(row.status?.note).not.toContain("/");
 		// Enter still follows how it IS installed (pnpm).
 		expect(row.updateCommand?.cmd).toBe("pnpm");
 	});
@@ -249,16 +254,28 @@ describe("cliToolStatusText — the row's words", () => {
 			primary: "npm",
 			all: ["npm"],
 		});
-		const f = facts("crush", { managed: false, owner: "npm (root /l)" });
+		const f = facts("crush", { managed: null });
 		const row = buildToolRow(tool, spec, f);
 		const text = cliToolStatusText(row);
 		expect(text.tone).toBe("warning");
-		expect(text.suffix).toBe(" ? not managed by npm");
-		// The note (with its path) is for the detail pane's "Why", not the row.
+		expect(text.suffix).toBe(" ? owner not known");
+		// 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", () => {
+		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");
+	});
+
 	test("upgrade names the target once, with one v", () => {
 		const tool = catalogue("mnemex");
 		const spec = specForCatalogTool(tool, null, {
@@ -287,12 +304,14 @@ describe("countToolRows — header counts from states", () => {
 		const rows = [
 			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".
 			buildToolRow(tool, spec, facts("mnemex", { managed: false })),
 			buildToolRow(tool, spec, facts("mnemex", { present: false })),
 			buildToolRow(tool, spec, undefined),
 		];
 		expect(countToolRows(rows)).toEqual({
-			installed: 3,
+			installed: 4,
 			updates: 1,
 			unverified: 1,
 		});

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

@@ -226,7 +226,7 @@ describe("classifyTool — every rule of §4.3, in order", () => {
 		);
 	});
 
-	test("6. not managed → unknown, naming both paths", () => {
+	test("6. not managed → external, in the user's terms", () => {
 		const s = classifyTool(
 			spec({ name: "crush" }),
 			facts({
@@ -237,16 +237,24 @@ describe("classifyTool — every rule of §4.3, in order", () => {
 				owner: "npm (root /Users/j/.local/lib/node_modules)",
 			}),
 		);
-		expect(s).toMatchObject({ state: "unknown", reason: "not-managed" });
-		expect(s.note).toContain("/Users/j/.nvm/versions/node/v24.14.0");
-		expect(s.note).toContain("npm (root /Users/j/.local/lib/node_modules)");
-		expect(s.note).toContain("second copy");
+		expect(s).toMatchObject({ state: "external", reason: "not-managed" });
+		expect(s.note).toBe("installed outside npm, so magus leaves it as is");
+		expect(s.note).not.toContain("/");
 	});
 
-	test("6. managed === null (owner undeterminable) is also a veto", () => {
+	test("6. managed === null (owner undeterminable) is also a veto, as unknown", () => {
 		expect(
-			classifyTool(spec(), facts({ managed: null, behind: true })).reason,
-		).toBe("not-managed");
+			classifyTool(spec(), facts({ managed: null, behind: true })),
+		).toMatchObject({ state: "unknown", reason: "not-managed" });
+	});
+
+	test("6. brew is named as the user knows it", () => {
+		expect(
+			classifyTool(
+				spec({ via: "brew" }),
+				facts({ managed: false, behind: true }),
+			).note,
+		).toBe("installed outside Homebrew, so magus leaves it as is");
 	});
 
 	test("7. held back → unknown, with the hold as the note", () => {
@@ -364,7 +372,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"]).toContain(status.state);
+			expect(["unknown", "upgrade", "external"]).toContain(status.state);
 			expect(status.note?.length ?? 0).toBeGreaterThan(0);
 		}
 	});
@@ -866,11 +874,11 @@ describe("probeTool — ownership decides managed", () => {
 		const [f] = await probeTools([hostile], io);
 		expect(io.calls).toEqual(["npm root -g"]);
 		expect(f?.installed).toBeNull();
-		// Cannot tell ⇒ unknown, so it is reported and never applied. The file
-		// is outside npm's tree, so the reason is ownership (R9.9), not the
-		// unread version that follows from it.
+		// 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.
 		expect(classifyTool(hostile, f!)).toMatchObject({
-			state: "unknown",
+			state: "external",
 			reason: "not-managed",
 		});
 

package/src/__tests__/update-plan.test.ts

@@ -502,7 +502,7 @@ describe("planIsBehind — the --check gate", () => {
 		const p = plan({
 			bins: planBinUpdates(
 				[{ name: "crush", via: "npm", sources: [] }],
-				[toolFacts("crush", { managed: false })],
+				[toolFacts("crush", { managed: null })],
 			),
 		});
 		expect(p.bins[0]!.action).toBe("unknown");
@@ -510,6 +510,19 @@ describe("planIsBehind — the --check gate", () => {
 		expect(planIsBehind(p)).toBe(false);
 	});
 
+	test("an EXTERNAL tool (another installer's) is no work, and not unknown", () => {
+		const p = plan({
+			bins: planBinUpdates(
+				[{ name: "crush", via: "npm", sources: [] }],
+				[toolFacts("crush", { managed: false, behind: true })],
+			),
+		});
+		expect(p.bins[0]!.action).toBe("external");
+		expect(planHasWork(p)).toBe(false);
+		expect(planIsBehind(p)).toBe(false);
+		expect(summarizePlan(p)).toMatchObject({ unknownTools: 0, kept: 1 });
+	});
+
 	test("a MISSING binary does fail the gate", () => {
 		const p = plan({
 			bins: planBinUpdates(
@@ -946,11 +959,13 @@ describe("planHasWork / summarizePlan", () => {
 					{ name: "crush", via: "npm", sources: [] },
 					{ name: "claude", via: "npm", sources: [] },
 					{ name: "tmux", via: "brew", sources: [] },
+					{ name: "zsh", via: "brew", sources: [] },
 				],
 				[
-					toolFacts("crush", { managed: false }),
-					toolFacts("claude", { managed: false }),
+					toolFacts("crush", { managed: null }),
+					toolFacts("claude", { managed: null }),
 					toolFacts("tmux", { behind: false }),
+					toolFacts("zsh", { managed: false }),
 				],
 			),
 		});
@@ -959,6 +974,7 @@ describe("planHasWork / summarizePlan", () => {
 			unknownTools: 2,
 			unknown: 3,
 			current: 1,
+			kept: 1,
 		});
 	});
 });

package/src/cli/update-view.ts

@@ -90,6 +90,7 @@ type ActionKey =
 	| "refresh"
 	| "stale-load"
 	| "remove"
+	| "external"
 	| "unknown";
 
 const ACTIONS: Record<ActionKey, ActionStyle> = {
@@ -111,6 +112,9 @@ const ACTIONS: Record<ActionKey, ActionStyle> = {
 	// dead weight Claude Code refuses to load, and the row is work, not a shrug.
 	// The plugin table shows the group's DEPRECATED chip, not this label.
 	remove: { glyph: "✗", label: "REMOVE", color: brand.danger },
+	// A tool another installer put on PATH. Settled, so chrome like CURRENT,
+	// and the same word the summary already prints for settled rows.
+	external: { glyph: "=", label: "KEPT", color: brand.muted, chrome: true },
 	// Warning, not danger: "cannot tell" is not a failure, and red UNKNOWN read
 	// as "broken". The summary line and the TUI already use warning for it.
 	unknown: { glyph: "?", label: "UNKNOWN", color: brand.warning },
@@ -453,6 +457,7 @@ function binDetail(item: BinUpdateItem, plan: UpdatePlan): string {
 				// plain one reads identically to before.
 				item.adopted ? `  ${dim(`(${item.adopted})`)}` : ""
 			}`;
+		case "external":
 		case "unknown":
 			return `${item.installed ?? "—"}${
 				item.note ? `  ${dim(`(${item.note})`)}` : ""
@@ -927,15 +932,18 @@ function worktreeLabel(names: readonly string[]): string {
  * The worktree rows: after a setup (`results`), one `✓` line for every
  * worktree set up and a `✗` line for each failure; on a read-only run
  * (`results` null), one `⚠` line for the ones `magus update` would set up.
- * A worktree that needs a choice gets its own `⚠` line either way. Empty for
- * an empty list: a repository with nothing to say prints nothing.
+ *
+ * A worktree that needs a choice gets no line. magus cannot set it up from
+ * here, and a line per worktree on every run is noise about folders the user
+ * may never open: old branches, agent and bench worktrees. The `setup`
+ * plugin says so when Claude Code starts in one, and magus run there asks.
+ * Empty when there is nothing to say, blank line included.
  */
 export function worktreeLines(
 	worktrees: readonly UnsetWorktree[],
 	results: readonly WorktreeSetupResult[] | null,
 ): string[] {
-	if (worktrees.length === 0) return [];
-	const lines = [""];
+	const lines: string[] = [];
 	if (results === null) {
 		const auto = worktrees.filter((w) => w.autoActivate).map((w) => w.name);
 		if (auto.length > 0) {
@@ -965,14 +973,5 @@ export function worktreeLines(
 			}
 		}
 	}
-	for (const w of worktrees) {
-		if (!w.autoActivate) {
-			lines.push(
-				warn(
-					`Worktree ${bold(w.name)} is missing this project's plugins. Run magus update there to choose a profile.`,
-				),
-			);
-		}
-	}
-	return lines;
+	return lines.length > 0 ? ["", ...lines] : [];
 }

package/src/services/tool-probe.ts

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

package/src/services/update-plan.ts

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

package/src/ui/adapters/cliToolsAdapter.ts

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

package/src/ui/renderers/cliToolRenderers.tsx

@@ -250,6 +250,10 @@ export function renderCliToolRow(
 	} else if (status?.state === "unknown") {
 		icon = "?";
 		iconColor = theme.colors.warning;
+	} else if (status?.state === "external") {
+		// Installed, and left alone on purpose: present, not a finding.
+		icon = "●";
+		iconColor = theme.colors.muted;
 	} else {
 		icon = "●";
 		iconColor = theme.colors.success;
@@ -353,6 +357,8 @@ export function renderCliToolDetail(
 						</text>
 					) : state === "upgrade" ? (
 						<text fg={theme.colors.warning}>{"● Update available"}</text>
+					) : state === "external" ? (
+						<text fg={theme.colors.muted}>{"● Installed, kept as is"}</text>
 					) : state === "unknown" ? (
 						// A version that was read but cannot be checked for updates is
 						// still a version: say "installed", and let Why say the rest.
@@ -365,12 +371,17 @@ export function renderCliToolDetail(
 						<text fg={theme.colors.success}>{"● Up to date"}</text>
 					)}
 				</box>
-				{state === "unknown" && status?.note ? (
+				{(state === "unknown" || state === "external") && status?.note ? (
 					<box flexDirection="row">
 						<text fg={theme.colors.muted} flexShrink={0}>
 							{"Why      "}
 						</text>
-						<text fg={theme.colors.warning} minWidth={0}>
+						<text
+							fg={
+								state === "external" ? theme.colors.muted : theme.colors.warning
+							}
+							minWidth={0}
+						>
 							{wrapValue(status.note, width)}
 						</text>
 					</box>