magus-cli 7.7.0 → 7.9.0

package/src/cli/install.ts

@@ -4,8 +4,9 @@
  * Put a committed team profile from .claude/profiles.json onto this machine:
  * register marketplaces, activate the profile (render its settings.json,
  * .mcp.json and models.json, install its skills), install its pinned plugins
- * and the binaries plugins declare (requires.bin) plus the profile's cliTools,
- * then collect required env.
+ * and what those plugins declare in `requires` plus the profile's cliTools
+ * (through the deps executor that `magus doctor --fix` uses), then collect
+ * required env.
  *
  * With no argument it installs the union of every profile's deps (so `profile
  * switch` needs no reinstall) and keeps the active profile active, asking only
@@ -13,6 +14,7 @@
  * the confirmation prompt.
  */
 
+import { homedir } from "node:os";
 import { installPlugin, isClaudeAvailable } from "../services/claude-cli.js";
 import {
 	getLocalSettingsPath,
@@ -20,6 +22,9 @@ import {
 	readLocalSettings,
 	writeLocalSettings,
 } from "../services/claude-settings.js";
+import type { PlanEnv } from "../services/deps-plan.js";
+import { assessBins } from "../services/deps-report.js";
+import { machineEnv } from "../services/doctor-bins.js";
 import {
 	computeEnvStatus,
 	computeVersionDrift,
@@ -40,16 +45,13 @@ import {
 import { resolveAllProfiles, resolveProfile } from "../services/resolver.js";
 import { SettingsParseError, writableMap } from "../services/settings-file.js";
 import {
-	TOOLCHAIN_BOOTSTRAP,
-	binInstallCommand,
-	detectToolchains,
-} from "../services/toolchain.js";
-import { bringLoadForward } from "../services/update-engine.js";
-import type { ResolvedBin, ResolvedClosure } from "../types/index.js";
-import { formatCommand, resolveExecutable } from "../utils/command-utils.js";
-import { runCommand, runShellScript } from "../utils/run.js";
+	bringLoadForward,
+	describeLoadNotForward,
+} from "../services/update-engine.js";
+import type { ResolvedClosure } from "../types/index.js";
 import { bold } from "./ansi.js";
 import { ensureManifest, printActivationNotes } from "./bootstrap.js";
+import { depsSectionLines, fixDeps, renderApplyText } from "./deps-view.js";
 import { askYesNo, promptValue } from "./prompt.js";
 import { selectOption } from "./select.js";
 import {
@@ -105,48 +107,6 @@ async function runCheck(
 
 // ── install steps ───────────────────────────────────────────────────────────
 
-async function ensureToolchains(
-	closure: ResolvedClosure,
-	yes: boolean,
-): Promise<void> {
-	// Only the binaries actually missing can need a toolchain. Checking all of
-	// them warns "pip isn't installed" on a machine whose pip-provided binaries
-	// are already on PATH — an alarming message about work that will not happen.
-	const missing: ResolvedBin[] = [];
-	for (const bin of closure.bins) {
-		if (!(await resolveExecutable(bin.name))) missing.push(bin);
-	}
-	if (missing.length === 0) return;
-
-	const toolchains = await detectToolchains(missing);
-	for (const tc of toolchains) {
-		if (tc.present) continue;
-		const bootstrap = TOOLCHAIN_BOOTSTRAP[tc.name];
-		if (!bootstrap) {
-			console.warn(
-				`⚠ ${tc.name} is required by ${tc.requiredBy.join(", ")} but isn't installed and can't be auto-installed. Install it and re-run.`,
-			);
-			continue;
-		}
-		const ok =
-			yes ||
-			(await askYesNo(
-				question(
-					`${tc.name} is missing — ${tc.requiredBy.join(", ")} need${tc.requiredBy.length === 1 ? "s" : ""} it. Install it?`,
-				),
-			));
-		if (ok) {
-			console.log(`Installing ${tc.name}…`);
-			// A bootstrap line IS shell text — bun's contains a pipe, Homebrew's a
-			// command substitution — and it is a constant in this repo, not
-			// profile data. This is the only legitimate caller.
-			if (!(await runShellScript(bootstrap))) {
-				console.warn(`⚠ Failed to install ${tc.name}. Continuing.`);
-			}
-		}
-	}
-}
-
 /**
  * Install the closure's plugins at PROJECT scope.
  *
@@ -210,28 +170,47 @@ async function bringLoadsForward(
 				} moved forward)`,
 			);
 		} else {
-			console.warn(
-				`⚠ ${pluginId}: installed v${here}, but Claude Code still loads v${
-					forward.loaded ?? "an older version"
-				} here — ${forward.error ?? "the older records could not be moved forward"}`,
-			);
+			console.warn(`⚠ ${pluginId}: ${describeLoadNotForward(forward)}`);
 		}
 	}
 }
 
-async function installBins(bins: ResolvedBin[]): Promise<void> {
-	for (const bin of bins) {
-		if (await resolveExecutable(bin.name)) {
-			continue; // already installed and runnable (not a dangling link)
-		}
-		const cmd = binInstallCommand(bin);
-		// Printed rendered, executed as argv. The package name in `cmd.args` came
-		// from a profile or a plugin manifest, so it must never reach a shell.
-		console.log(`+ ${bin.name}  (${formatCommand(cmd)})`);
-		if (!(await runCommand(cmd))) {
-			console.warn(`⚠ failed to install ${bin.name} via ${bin.via}`);
-		}
+/**
+ * Install what the closure's requirements say is missing here: probe, plan,
+ * list every step and ask once (unless `--yes`), apply, then report from a
+ * fresh probe — the same flow and rendering as `magus doctor --fix`.
+ */
+async function installDeps(
+	closure: ResolvedClosure,
+	env: PlanEnv,
+	yes: boolean,
+): Promise<void> {
+	const collected = {
+		plugins: Object.keys(closure.plugins),
+		bins: closure.bins,
+		problems: [],
+	};
+	const state = await assessBins(collected, env);
+	if (state.plan.steps.length === 0) {
+		for (const line of depsSectionLines(state, env).lines) console.log(line);
+		return;
+	}
+	const result = await fixDeps(state, env, { yes, interactive: true }, () =>
+		assessBins(collected, env),
+	);
+	if (result.kind === "busy") {
+		console.warn(`⚠ ${result.message}`);
+		return;
+	}
+	if (result.kind === "declined") {
+		console.log(
+			"Plugin dependencies not installed — `magus doctor --fix` installs them later.",
+		);
+		return;
 	}
+	for (const line of renderApplyText(result.outcomes)) console.log(line);
+	for (const line of depsSectionLines(result.after, env).lines)
+		console.log(line);
 }
 
 async function collectEnv(
@@ -374,7 +353,6 @@ export async function runInstallCommand(
 		return 1;
 	}
 
-	await ensureToolchains(closure, flags.yes);
 	await registerClosureMarketplaces(closure.marketplaces);
 	// A marketplace added just now carries the plugin.json files that name
 	// each plugin's dependencies; resolve again so those are installed too.
@@ -439,7 +417,13 @@ export async function runInstallCommand(
 	);
 	// Only what installed: a failed install already printed its own warning.
 	await bringLoadsForward(installed, projectPath);
-	await installBins(closure.bins);
+	// Resolved again: the requirements are read from the copies just installed.
+	const env = machineEnv(
+		process.env.HOME || homedir(),
+		process.env.PATH ?? "",
+		process.env.SHELL ?? "",
+	);
+	if (env) await installDeps(await resolveClosure(), env, flags.yes);
 
 	if (activeId) {
 		await collectEnv(

package/src/cli/profile.ts

@@ -7,7 +7,12 @@
  * live config first goes into the profile being left.
  */
 
-import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
+import { homedir } from "node:os";
+import {
+	checkBinaries,
+	machineEnv,
+	missingBinaries,
+} from "../services/doctor-bins.js";
 import { summarizeClosure } from "../services/install-plan.js";
 import { getManifestPath, readManifest } from "../services/manifest.js";
 import { reportDisplaced } from "../services/profile-activate.js";
@@ -173,7 +178,20 @@ export async function switchProfile(
 	// succeeds (the config is in place), but warn so "switched" is not misleading.
 	try {
 		const closure = await resolveProfile(manifest, name);
-		const missing = missingBinaries(await checkBinaries(closure.bins));
+		const env = machineEnv(
+			process.env.HOME || homedir(),
+			process.env.PATH ?? "",
+			process.env.SHELL ?? "",
+		);
+		const missing = env
+			? missingBinaries(
+					await checkBinaries(closure.bins, {
+						env,
+						depth: "presence",
+						capMs: 3_000,
+					}),
+				)
+			: [];
 		if (missing.length > 0) {
 			console.log(
 				`\n⚠ ${missing.length} binary dependenc${missing.length === 1 ? "y is" : "ies are"} missing:`,

package/src/cli/router.ts

@@ -282,8 +282,12 @@ without one is offered adoption on first run. See docs/team-configuration.md.
 Changes Claude Code makes to .claude/settings.json or .mcp.json (a plugin
 installed, a setting changed) are changes to the active profile: every command
 above records them in .claude/profiles.json before it acts.
-  doctor             Check binary deps, the active profile, and conventions
-    --fix            Apply the repairs it can make itself
+  doctor             Check plugin dependencies, the active profile, and conventions
+    --fix            Apply the repairs it can make itself, including installing
+                     missing plugin dependencies (asks once, listing each)
+    --yes            Install without asking
+    --json           Plugin dependencies only, as one JSON document
+    --project <dir>  Check the project in <dir> instead of this directory
 
 Per-subagent model routing — give each subagent its own model and effort. The
 routing lives on the active profile (committed in .claude/profiles.json) and is

package/src/cli/update-view.ts

@@ -27,11 +27,12 @@
  */
 
 import { binCommandFor } from "../services/update-engine.js";
-import type {
-	BinUpdateItem,
-	PluginUpdateItem,
-	SkillUpdateItem,
-	UpdatePlan,
+import {
+	type BinUpdateItem,
+	type PluginUpdateItem,
+	type SkillUpdateItem,
+	type UpdatePlan,
+	isKeptDeprecated,
 } from "../services/update-plan.js";
 import { type ReportBadgeKind, reportBadge } from "../ui/theme-mode.js";
 import { brand } from "../ui/theme.js";
@@ -84,6 +85,7 @@ type ActionKey =
 	| "repair"
 	| "refresh"
 	| "stale-load"
+	| "remove"
 	| "unknown";
 
 const ACTIONS: Record<ActionKey, ActionStyle> = {
@@ -101,6 +103,10 @@ const ACTIONS: Record<ActionKey, ActionStyle> = {
 	// a mild version of `repair`, and this is not that. Six characters, one under
 	// UNKNOWN, so CHIP_WIDTH is unchanged and no other section pays for it.
 	"stale-load": { glyph: "✗", label: "BROKEN", color: brand.danger },
+	// No longer published, and removed by the apply. ✗ in danger: the plugin is
+	// 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 },
 	// 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 },
@@ -373,10 +379,15 @@ function pluginDetail(item: PluginUpdateItem): string {
 	// "loads v0.3.0, installed v0.5.0" and the two columns beside it already do.
 	const note =
 		item.note &&
-		item.reason !== "not-offered" &&
+		item.reason !== "deprecated" &&
 		item.reason !== "older-version-loads"
 			? `  ${dim(`(${item.note})`)}`
 			: "";
+	// Kept on purpose — moved, or still required. Under Deprecated, and the
+	// word says nothing will happen to it; the note says why.
+	if (isKeptDeprecated(item)) {
+		return `${item.installed ?? "—"}  ${dim(`kept — ${item.note ?? "no longer published"}`)}`;
+	}
 	switch (item.action) {
 		case "install":
 			return `${item.target ?? "latest"}${note}`;
@@ -391,6 +402,7 @@ function pluginDetail(item: PluginUpdateItem): string {
 			)} ${fg(groupStyle("Update").text, item.target ?? "?")}${note}`;
 		case "repair":
 		case "unknown":
+		case "remove":
 			return `${item.installed ?? "—"}${note}`;
 		case "stale-load":
 			// Both versions, in the order the reader needs them: what runs, then
@@ -459,7 +471,7 @@ function binDetail(item: BinUpdateItem, plan: UpdatePlan): string {
  * note. Five headings, and no more:
  *
  *   Update        something an apply would move forward
- *   Deprecated    no configured marketplace offers it
+ *   Deprecated    no longer published — an apply removes it
  *   Fix required  declared or installed, with its files missing
  *   Unverified    the check itself did not complete
  *   Current       settled — the version was compared, or there was none to compare
@@ -485,9 +497,11 @@ function pluginGroup(item: PluginUpdateItem): string {
 	// state deceptive, and a row that reads as up to date under a CURRENT
 	// heading is the defect this state was added to end.
 	if (item.action === "stale-load") return "Broken";
-	if (item.action === "unknown") {
-		return item.reason === "not-offered" ? "Deprecated" : "Unverified";
-	}
+	if (item.action === "remove") return "Deprecated";
+	// Moved or still required: no longer published here, and KEPT. That is a
+	// determined fact, not a check that failed, so never "Unverified".
+	if (isKeptDeprecated(item)) return "Deprecated";
+	if (item.action === "unknown") return "Unverified";
 	return "Current";
 }
 
@@ -590,9 +604,12 @@ function pluginRow(
 			: badge(groupBadge(group), style.fill ?? brand.muted, style.ink),
 		chipWidth,
 	);
-	return `${PAD}${fg(style.text, ACTIONS[item.action].glyph)}  ${
-		style.chrome ? dim(name) : name
-	}  ${chip}${pluginDetail(item)}`;
+	// A kept row is not work: the ✗ of a removal would say it is, and the "?"
+	// of an unknown that nobody knows. It gets the settled row's muted glyph.
+	const mark = isKeptDeprecated(item)
+		? fg(brand.muted, ACTIONS.current.glyph)
+		: fg(style.text, ACTIONS[item.action].glyph);
+	return `${PAD}${mark}  ${style.chrome ? dim(name) : name}  ${chip}${pluginDetail(item)}`;
 }
 
 /** The Plugins section: grouped by state, `Current` last. */
@@ -681,7 +698,7 @@ export function planReport(plan: UpdatePlan): string[] {
 	// EVERY planned plugin gets a row. There is no filter here and there must
 	// not be one.
 	//
-	// A previous revision dropped `unknown` + `not-offered` + not-installed rows
+	// A previous revision dropped unlisted, not-installed rows
 	// — a pin naming a plugin no marketplace offers — on the grounds that a
 	// notice named them instead. That notice did not exist: the function the
 	// comment cited was never written. The row appeared in no table and no
@@ -778,10 +795,11 @@ export function summaryLine(
 	failed: number,
 	ms: number,
 	unchanged = 0,
+	kept = 0,
 ): string[] {
 	const bar = stackedBar(BAR * 2, [
 		{ value: changed, color: brand.success },
-		{ value: current, color: brand.muted },
+		{ value: current + kept, color: brand.muted },
 		{ value: unchanged + unknown, color: brand.warning },
 		{ value: failed, color: brand.danger },
 	]);
@@ -789,6 +807,9 @@ export function summaryLine(
 		changed > 0 ? fg(brand.success, `${changed} changed`) : "",
 		unchanged > 0 ? fg(brand.warning, `${unchanged} unchanged`) : "",
 		current > 0 ? dim(`${current} current`) : "",
+		// Deprecated but kept on purpose (moved, still required): settled, so
+		// grey beside `current`, and never folded into "unverified".
+		kept > 0 ? dim(`${kept} kept`) : "",
 		unknown > 0 ? fg(brand.warning, `${unknown} unverified`) : "",
 		failed > 0 ? fg(brand.danger, `${failed} failed`) : "",
 	].filter(Boolean);
@@ -860,3 +881,25 @@ export function nothingToApplyNotice(unknownPlugins: number): string {
 		`Nothing to apply. ${unknownPlugins} plugin(s) could not be checked. They are NOT reported as up to date. Reasons are shown above.`,
 	);
 }
+
+/**
+ * The words `--check` fails with, chosen by what is pending. "Updates
+ * available" over a plan whose only work is removing plugins that are no
+ * longer published claims an update nobody can find in the table above.
+ */
+export function pendingHeadline(plan: UpdatePlan): string {
+	const pendingPlugins = plan.plugins.filter(
+		(p) =>
+			p.action === "install" ||
+			p.action === "update" ||
+			p.action === "repair" ||
+			p.action === "stale-load" ||
+			p.action === "remove",
+	);
+	const onlyRemovals =
+		pendingPlugins.length > 0 &&
+		pendingPlugins.every((p) => p.action === "remove") &&
+		!plan.bins.some((b) => b.action === "install" || b.action === "upgrade") &&
+		!plan.skills.some((s) => s.action === "install");
+	return onlyRemovals ? "Changes pending" : "Updates available";
+}

package/src/cli/update.ts

@@ -37,6 +37,7 @@
 import { selectProfileId } from "../services/active-closure.js";
 import { isClaudeAvailable } from "../services/claude-cli.js";
 import { clearContentDriftCache } from "../services/content-drift.js";
+import { refusedPinWhy } from "../services/deps-plan.js";
 import { validateManifest } from "../services/manifest.js";
 import {
 	refreshRegisteredMarketplaces,
@@ -47,6 +48,7 @@ import {
 	type PluginInfo,
 	clearMarketplaceCache,
 	getAvailablePlugins,
+	isInstalledAnywhere,
 } from "../services/plugin-manager.js";
 import {
 	recordRefetchedSkills,
@@ -61,14 +63,16 @@ import {
 	switchHint,
 	withCliBookkeeping,
 } from "../services/profile-state.js";
-import { resolveProfile } from "../services/resolver.js";
+import { requirersHere, resolveProfile } from "../services/resolver.js";
 import { getInstalledSkillNames } from "../services/skills-manager.js";
 import { REAL_TOOL_PROBE_IO, probeTools } from "../services/tool-probe.js";
+import { managedBins } from "../services/toolchain.js";
 // The apply half lives in services/ so the TUI runs the SAME code — see the
 // header of update-engine.ts for what drifted while it did not.
 import {
 	type ApplyReporter,
 	applyPlan,
+	describeRemoved,
 	planWorkItems,
 } from "../services/update-engine.js";
 import {
@@ -95,6 +99,7 @@ import {
 	note as noteLine,
 	nothingToApplyNotice,
 	ok as okLine,
+	pendingHeadline,
 	planReport,
 	stepFrame,
 	stepRecord,
@@ -315,6 +320,14 @@ export async function runUpdateCommand(
 		return resolved;
 	});
 
+	// A pin the owning plugin's option cannot carry: whatever installs or
+	// upgrades the tool ignores it, so say so rather than let it read as kept.
+	for (const bin of closure.bins) {
+		for (const pin of bin.refusedPins ?? []) {
+			notices.push(warnLine(`${bold(bin.name)}: ${refusedPinWhy(bin, pin)}`));
+		}
+	}
+
 	// "latest" is only as fresh as the catalog. Fast-forward the marketplace
 	// clones first, then drop every cached answer derived from the old HEAD —
 	// skipping this is how a clone sits days behind while every plugin reads as
@@ -386,13 +399,23 @@ export async function runUpdateCommand(
 	// "behind?" answer — the same probe the TUI's CLI Tools screen uses. It used
 	// to be a presence check, which is why every present unpinned tool planned
 	// as an upgrade on every run.
+	//
+	// Only the requirements installed by a versioned package manager have a
+	// version to move. The rest (apt, a pinned release, a toolchain bootstrap,
+	// a plugin's uv env) are as current as their declaration, and
+	// `magus doctor --fix` installs them.
+	const tools = managedBins(closure.bins);
+	const declaredOnly = closure.bins.length - tools.length;
 	const toolFacts = await runStep(steps.binaries, async (say) => {
-		if (closure.bins.length === 0) {
-			steps.binaries.detail = "none declared";
+		if (tools.length === 0) {
+			steps.binaries.detail =
+				declaredOnly > 0
+					? `${declaredOnly} managed by their declaration`
+					: "none declared";
 			return [];
 		}
-		steps.binaries.progress = { done: 0, total: closure.bins.length };
-		const facts = await probeTools(closure.bins, REAL_TOOL_PROBE_IO, {
+		steps.binaries.progress = { done: 0, total: tools.length };
+		const facts = await probeTools(tools, REAL_TOOL_PROBE_IO, {
 			// `settled`, not `index`: results arrive in completion order, and a
 			// meter driven by index would jump backwards.
 			onResult: (f, { settled, total }) => {
@@ -400,7 +423,7 @@ export async function runUpdateCommand(
 				say(f.name);
 			},
 		});
-		const items = planBinUpdates(closure.bins, facts);
+		const items = planBinUpdates(tools, facts);
 		const n = (a: string) => items.filter((i) => i.action === a).length;
 		const behind = n("upgrade");
 		const unknown = n("unknown");
@@ -410,6 +433,7 @@ export async function runUpdateCommand(
 			behind > 0 ? `${behind} behind` : "",
 			unknown > 0 ? `${unknown} unknown` : "",
 			missing > 0 ? `${missing} missing` : "",
+			declaredOnly > 0 ? `${declaredOnly} managed by their declaration` : "",
 		]
 			.filter(Boolean)
 			.join(" · ");
@@ -441,12 +465,20 @@ export async function runUpdateCommand(
 		targetId,
 		closure.skills,
 	);
+	// Every installed plugin's dependencies count, not only the profile's: a
+	// plugin still required by one that stays is never planned for removal, and
+	// retired plugins that only require each other are removed together.
+	const requiredBy = await requirersHere(
+		closure.dependencies?.requiredBy,
+		[...catalog.values()].filter(isInstalledAnywhere).map((p) => p.id),
+		projectPath,
+	);
 	const plan: UpdatePlan = {
 		profileId: targetId,
-		plugins: planPluginUpdates(closure.plugins, catalog),
-		bins: planBinUpdates(closure.bins, toolFacts),
+		plugins: planPluginUpdates(closure.plugins, catalog, requiredBy),
+		bins: planBinUpdates(tools, toolFacts),
 		skills: planSkillUpdates(skillRefs, installedSkills),
-		binSpecs: new Map(closure.bins.map((b) => [b.name, b])),
+		binSpecs: new Map(tools.map((b) => [b.name, b])),
 	};
 
 	for (const line of planReport(plan)) console.log(line);
@@ -489,7 +521,9 @@ export async function runUpdateCommand(
 			return 0;
 		}
 		console.error(
-			failLine(`Updates available. Run ${bold("magus update")} to apply.`),
+			failLine(
+				`${pendingHeadline(plan)}. Run ${bold("magus update")} to apply.`,
+			),
 		);
 		return 1;
 	}
@@ -506,6 +540,8 @@ export async function runUpdateCommand(
 			counts.unknown,
 			0,
 			Date.now() - startedAt,
+			0,
+			counts.kept,
 		))
 			console.log(line);
 		// `planHasWork` counts an `unknown` plugin as work, because from the
@@ -539,8 +575,10 @@ export async function runUpdateCommand(
 
 	// No confirmation. `update` moves the machine toward what the profile
 	// declares and can only go FORWARD: `claude plugin install` takes no version
-	// and installs the newest published one, so there is no downgrade and no
-	// delete for a prompt to protect against. The plan is printed above, so the
+	// and installs the newest published one, so there is no downgrade for a
+	// prompt to protect against. The one delete it makes is a DEPRECATED plugin:
+	// its marketplace no longer publishes it and Claude Code refuses to load it
+	// (measured, 2.1.284), so removing it loses nothing. The plan is printed above, so the
 	// run is still legible after the fact — and `--dry-run` shows it beforehand.
 	//
 	// Note this also runs a profile's CLI-tool installers unattended (`brew
@@ -637,9 +675,14 @@ export async function runUpdateCommand(
 		failed.length,
 		Date.now() - startedAt,
 		outcome.unchanged.length,
+		counts.kept,
 	))
 		console.log(line);
 
+	// Only the CLI says it: on the Plugins screen the removed rows are simply gone.
+	const removed = describeRemoved(outcome.plugins.removed);
+	if (removed) console.log(okLine(removed));
+
 	// Exited 0, read back unmoved. Reported, never fatal — the same precedent
 	// as the pin mismatches below: this is a standing property of the machine
 	// (a stale tap, a shadowing PATH entry), not something this run did wrong,

package/src/data/cli-tools.ts

@@ -13,13 +13,16 @@ import { MAGUS_NPM_PACKAGE } from "./npm-package.js";
  * catalogue entry can no longer smuggle shell syntax (that same entry's command
  * was a `&&` chain) into something that gets executed.
  */
-export interface CliTool {
+interface CatalogueDisplay {
 	name: string;
 	displayName: string;
 	description: string;
-	checkCommand: string;
 	website: string;
 	category: "ai-coding" | "utility";
+}
+
+export interface CliTool extends CatalogueDisplay {
+	checkCommand: string;
 	/**
 	 * Reuses `BinInstaller` rather than restating its members, so the
 	 * correspondence with the resolver in `services/toolchain.ts` — which is
@@ -29,6 +32,22 @@ export interface CliTool {
 	packageName: string;
 }
 
+/**
+ * A catalogue tool a plugin declares in its `requires`. The entry carries
+ * display fields only: how the tool is checked and installed is that plugin's
+ * declaration, read through requires-probe (`resolveCatalogue`), so the two
+ * can never disagree.
+ */
+export interface OwnedCatalogueEntry extends CatalogueDisplay {
+	/** `<plugin>@<marketplace>` whose `requires` declares this tool. */
+	ownedBy: string;
+}
+
+export type CatalogueEntry = CliTool | OwnedCatalogueEntry;
+
+export const isOwnedEntry = (e: CatalogueEntry): e is OwnedCatalogueEntry =>
+	"ownedBy" in e;
+
 /**
  * Claude Code's npm package. Named once because two readers need it: the
  * catalogue entry below, and the probe, which asks this package's `latest`
@@ -37,7 +56,7 @@ export interface CliTool {
  */
 export const CLAUDE_CODE_NPM_PACKAGE = "@anthropic-ai/claude-code";
 
-export const cliTools: CliTool[] = [
+export const cliTools: CatalogueEntry[] = [
 	{
 		name: "magus",
 		displayName: "magus",
@@ -56,21 +75,17 @@ export const cliTools: CliTool[] = [
 		displayName: "Mnemex",
 		description:
 			"AST-aware code search with PageRank, callers/callees, and semantic embeddings",
-		checkCommand: "mnemex --version",
 		website: "https://github.com/MadAppGang/mnemex",
 		category: "ai-coding",
-		packageManager: "bun",
-		packageName: "mnemex",
+		ownedBy: "mnemex@magus",
 	},
 	{
 		name: "claudish",
 		displayName: "Claudish",
 		description: "Run Claude Code with OpenRouter models (Grok, GPT-5, Gemini)",
-		checkCommand: "claudish --version",
 		website: "https://github.com/MadAppGang/claudish",
 		category: "ai-coding",
-		packageManager: "bun",
-		packageName: "claudish",
+		ownedBy: "claudish@magus",
 	},
 	{
 		name: "claude",

package/src/services/active-closure.ts

@@ -15,9 +15,9 @@
  */
 
 import type {
-	BinRequirement,
 	ProfileManifest,
 	ResolvedClosure,
+	SelectedBin,
 } from "../types/index.js";
 import { readManifest, validateManifest } from "./manifest.js";
 import { activeProfile } from "./profile-live.js";
@@ -54,7 +54,7 @@ export interface ActiveClosureDeps {
 		manifest: ProfileManifest,
 		id: string,
 		opts?: {
-			binResolver?: (pluginId: string) => Promise<BinRequirement[]>;
+			binResolver?: (pluginId: string) => Promise<SelectedBin[]>;
 		},
 	): Promise<ResolvedClosure>;
 }
@@ -79,7 +79,7 @@ export interface LoadActiveClosureOptions {
 	deps?: Partial<ActiveClosureDeps>;
 }
 
-const NO_BINS = async (): Promise<BinRequirement[]> => [];
+const NO_BINS = async (): Promise<SelectedBin[]> => [];
 
 /**
  * The active profile's closure for a project.