magus-cli 7.8.0 → 7.9.1

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,
@@ -65,6 +66,7 @@ import {
 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 {
@@ -318,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
@@ -389,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 }) => {
@@ -403,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");
@@ -413,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(" · ");
@@ -455,9 +476,9 @@ export async function runUpdateCommand(
 	const plan: UpdatePlan = {
 		profileId: targetId,
 		plugins: planPluginUpdates(closure.plugins, catalog, requiredBy),
-		bins: planBinUpdates(closure.bins, toolFacts),
+		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);

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.

package/src/services/claude-settings.ts

@@ -1052,359 +1052,15 @@ export interface MarketplaceRecoveryResult {
 	reregistered: string[];
 }
 
-// =============================================================================
-// MARKETPLACE RENAME MIGRATION: mag-claude-plugins / MadAppGang-claude-code → magus
-// =============================================================================
-
-const OLD_MARKETPLACE_NAMES = ["mag-claude-plugins", "MadAppGang-claude-code"];
-const NEW_MARKETPLACE_NAME = "magus";
-const NEW_MARKETPLACE_REPO = "MadAppGang/magus";
-const OLD_MARKETPLACE_REPOS = ["MadAppGang/claude-code"];
-
-/**
- * Rename plugin keys in a Record from any old marketplace name to new.
- * e.g., "frontend@mag-claude-plugins" → "frontend@magus"
- *        "dev@MadAppGang-claude-code" → "dev@magus"
- * Returns [migratedRecord, count] — count=0 means no changes.
- */
-function migratePluginKeys<T>(
-	record: Record<string, T> | undefined,
-): [Record<string, T>, number] {
-	if (!record) return [{}, 0];
-	const migrated: Record<string, T> = {};
-	let count = 0;
-	for (const [key, value] of Object.entries(record)) {
-		const oldName = OLD_MARKETPLACE_NAMES.find((n) => key.endsWith(`@${n}`));
-		if (oldName) {
-			const pluginName = key.slice(0, key.lastIndexOf("@"));
-			const newKey = `${pluginName}@${NEW_MARKETPLACE_NAME}`;
-			// Don't overwrite if canonical key already exists
-			if (!record[newKey]) {
-				migrated[newKey] = value;
-			}
-			count++;
-		} else {
-			migrated[key] = value;
-		}
-	}
-	return [migrated, count];
-}
-
-/**
- * Migrate a single settings object in-place.
- * Returns number of keys renamed.
- */
-function migrateSettingsObject(settings: ClaudeSettings): number {
-	let total = 0;
-
-	const [ep, epCount] = migratePluginKeys(settings.enabledPlugins);
-	if (epCount > 0) {
-		settings.enabledPlugins = ep;
-		total += epCount;
-	}
-
-	const [iv, ivCount] = migratePluginKeys(settings.installedPluginVersions);
-	if (ivCount > 0) {
-		settings.installedPluginVersions = iv;
-		total += ivCount;
-	}
-
-	// Migrate extraKnownMarketplaces keys
-	for (const oldName of OLD_MARKETPLACE_NAMES) {
-		if (settings.extraKnownMarketplaces?.[oldName]) {
-			const entry = settings.extraKnownMarketplaces[oldName];
-			delete settings.extraKnownMarketplaces[oldName];
-			if (!settings.extraKnownMarketplaces[NEW_MARKETPLACE_NAME]) {
-				settings.extraKnownMarketplaces[NEW_MARKETPLACE_NAME] = {
-					...entry,
-					source: {
-						...entry.source,
-						repo: NEW_MARKETPLACE_REPO,
-					},
-				};
-			}
-			total++;
-		}
-	}
-
-	// Fix stale repo URL on existing magus entry (e.g. key is "magus" but repo is still "MadAppGang/claude-code")
-	const magusEntry = settings.extraKnownMarketplaces?.[NEW_MARKETPLACE_NAME];
-	if (
-		magusEntry?.source?.repo &&
-		OLD_MARKETPLACE_REPOS.includes(magusEntry.source.repo)
-	) {
-		magusEntry.source.repo = NEW_MARKETPLACE_REPO;
-		total++;
-	}
-
-	return total;
-}
-
-export interface MigrationResult {
-	projectMigrated: number;
-	globalMigrated: number;
-	localMigrated: number;
-	knownMarketplacesMigrated: boolean;
-	registryMigrated: number;
-}
-
-/**
- * Migrate all settings from mag-claude-plugins to magus.
- * Safe to call multiple times — no-ops if already migrated.
- * Runs across project settings, global settings, local settings,
- * known_marketplaces.json, and installed_plugins.json.
- */
-/**
- * Decode a ~/.claude/projects/ directory name back to a filesystem path.
- * Claude Code encodes paths by replacing "/" with "-", which is lossy when
- * directory names themselves contain dashes (e.g., "circl-infra" → "circl/infra").
- * Strategy: split on "-", then greedily recombine segments by checking which
- * combinations actually exist on disk.
- * Returns null if no valid path can be resolved.
- */
-async function decodeProjectDirName(encoded: string): Promise<string | null> {
-	// Split into segments: "-Users-jack-dev-circl-infra" → ["Users","jack","dev","circl","infra"]
-	const segments = encoded.replace(/^-/, "").split("-");
-	if (segments.length === 0) return null;
-
-	// Build path greedily: at each step, try joining the next segment with a dash first
-	// (preserving directory names like "circl-infra"), fall back to slash (new path segment)
-	let current = `/${segments[0]}`;
-	for (let i = 1; i < segments.length; i++) {
-		const withDash = `${current}-${segments[i]}`;
-		const withSlash = `${current}/${segments[i]}`;
-		// Prefer dash (keeps compound names intact) if that path prefix exists
-		if (await fs.pathExists(withDash)) {
-			current = withDash;
-		} else {
-			current = withSlash;
-		}
-	}
-
-	return (await fs.pathExists(current)) ? current : null;
-}
-
-export async function migrateMarketplaceRename(
-	projectPath?: string,
-): Promise<MigrationResult> {
-	const result: MigrationResult = {
-		projectMigrated: 0,
-		globalMigrated: 0,
-		localMigrated: 0,
-		knownMarketplacesMigrated: false,
-		registryMigrated: 0,
-	};
-
-	// 1. Project settings
-	try {
-		const settings = await readSettings(projectPath);
-		const count = migrateSettingsObject(settings);
-		if (count > 0) {
-			await writeSettings(settings, projectPath);
-			result.projectMigrated = count;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 2. Global settings
-	try {
-		const settings = await readGlobalSettings();
-		const count = migrateSettingsObject(settings);
-		if (count > 0) {
-			await writeGlobalSettings(settings);
-			result.globalMigrated = count;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 3. Local settings (settings.local.json)
-	try {
-		const local = await readLocalSettings(projectPath);
-		let localCount = 0;
-		const [ep, epCount] = migratePluginKeys(local.enabledPlugins);
-		if (epCount > 0) {
-			local.enabledPlugins = ep;
-			localCount += epCount;
-		}
-		const [iv, ivCount] = migratePluginKeys(local.installedPluginVersions);
-		if (ivCount > 0) {
-			local.installedPluginVersions = iv;
-			localCount += ivCount;
-		}
-		if (localCount > 0) {
-			await writeLocalSettings(local, projectPath);
-			result.localMigrated = localCount;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 4. known_marketplaces.json — rename old keys + physical directory cleanup
-	const marketplacesDir = path.join(
-		os.homedir(),
-		".claude",
-		"plugins",
-		"marketplaces",
-	);
-	const newDir = path.join(marketplacesDir, NEW_MARKETPLACE_NAME);
-
-	try {
-		const known = await readKnownMarketplaces();
-		let knownModified = false;
-
-		for (const oldName of OLD_MARKETPLACE_NAMES) {
-			if (known[oldName]) {
-				const oldEntry = known[oldName];
-				// If canonical entry doesn't exist yet, create it
-				if (!known[NEW_MARKETPLACE_NAME]) {
-					known[NEW_MARKETPLACE_NAME] = {
-						...oldEntry,
-						source: {
-							...oldEntry.source,
-							repo: "MadAppGang/magus",
-						},
-					};
-				}
-				delete known[oldName];
-				knownModified = true;
-			}
-
-			// Ensure installLocation doesn't reference old directory names
-			if (known[NEW_MARKETPLACE_NAME]?.installLocation?.includes(oldName)) {
-				known[NEW_MARKETPLACE_NAME].installLocation = known[
-					NEW_MARKETPLACE_NAME
-				].installLocation.replace(oldName, NEW_MARKETPLACE_NAME);
-				knownModified = true;
-			}
-		}
-
-		if (knownModified) {
-			await writeKnownMarketplaces(known);
-			result.knownMarketplacesMigrated = true;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 4b. Rename/remove old physical directories (runs even if keys were already migrated)
-	for (const oldName of OLD_MARKETPLACE_NAMES) {
-		const oldDir = path.join(marketplacesDir, oldName);
-		try {
-			if (await fs.pathExists(oldDir)) {
-				if (!(await fs.pathExists(newDir))) {
-					await fs.rename(oldDir, newDir);
-				} else {
-					// Both exist — remove the old one (magus dir is canonical)
-					await fs.remove(oldDir);
-				}
-			}
-		} catch {
-			/* non-fatal: directory cleanup is best-effort */
-		}
-	}
-
-	// 4c. Update git remote URL in the marketplace clone (old → new repo)
-	try {
-		if (await fs.pathExists(path.join(newDir, ".git"))) {
-			const { execSync } = await import("node:child_process");
-			const remote = execSync("git remote get-url origin", {
-				cwd: newDir,
-				encoding: "utf-8",
-				timeout: 5000,
-			}).trim();
-			if (remote.includes("claude-code") && remote.includes("MadAppGang")) {
-				const newRemote = remote.replace("claude-code", NEW_MARKETPLACE_NAME);
-				execSync(`git remote set-url origin "${newRemote}"`, {
-					cwd: newDir,
-					encoding: "utf-8",
-					timeout: 5000,
-				});
-			}
-		}
-	} catch {
-		/* non-fatal: git remote update is best-effort */
-	}
-
-	// 5. installed_plugins.json — rename plugin ID keys
-	try {
-		let regCount = 0;
-		await updateRegistryFile((registry) => {
-			const newPlugins: typeof registry.plugins = {};
-			for (const [pluginId, entries] of Object.entries(registry.plugins)) {
-				const oldName = OLD_MARKETPLACE_NAMES.find((n) =>
-					pluginId.endsWith(`@${n}`),
-				);
-				if (oldName) {
-					const pluginName = pluginId.slice(0, pluginId.lastIndexOf("@"));
-					const newKey = `${pluginName}@${NEW_MARKETPLACE_NAME}`;
-					if (!newPlugins[newKey]) {
-						newPlugins[newKey] = entries;
-					}
-					regCount++;
-				} else {
-					newPlugins[pluginId] = entries;
-				}
-			}
-			if (regCount === 0) return false;
-			registry.plugins = newPlugins;
-			return true;
-		});
-		// After the write, never inside the mutation: a refused write (a corrupt
-		// file, or one another session changed) must not report a migration that
-		// did not land.
-		result.registryMigrated = regCount;
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 6. Scan all known project settings (derived from ~/.claude/projects/ directory names)
-	try {
-		const projectsDir = path.join(os.homedir(), ".claude", "projects");
-		if (await fs.pathExists(projectsDir)) {
-			const entries = await fs.readdir(projectsDir);
-			const seenPaths = new Set<string>();
-			// Current project (from step 1) already handled — skip it
-			const currentProject = projectPath || process.cwd();
-			seenPaths.add(currentProject);
-
-			for (const entry of entries) {
-				const decoded = await decodeProjectDirName(entry);
-				if (!decoded || seenPaths.has(decoded)) continue;
-				seenPaths.add(decoded);
-
-				const settingsFile = path.join(decoded, ".claude", "settings.json");
-				try {
-					if (await fs.pathExists(settingsFile)) {
-						const raw = await fs.readJson(settingsFile);
-						const count = migrateSettingsObject(raw);
-						if (count > 0) {
-							await fs.writeJson(settingsFile, raw, { spaces: 2 });
-							result.projectMigrated += count;
-						}
-					}
-				} catch {
-					/* skip individual projects that fail */
-				}
-			}
-		}
-	} catch {
-		/* non-fatal: cross-project scan is best-effort */
-	}
-
-	return result;
-}
-
 /**
  * Recover/sync marketplace settings:
  * - Remove entries for marketplaces whose installLocation no longer exists
  * - Fix stale "directory" source for known Magus marketplaces that should be "github"
  *
- * It does NOT touch `autoUpdate`. It used to set it to `true` on every
- * MadAppGang entry whose flag was unset, on every TUI startup — writing a
- * Claude Code-owned field that Claude Code also syncs from settings. See
- * {@link getMarketplaceAutoUpdate}.
+ * A write to Claude Code's registry, so it runs only inside an install the user
+ * asked for, after Claude Code itself answered "not found in marketplace"
+ * (claude-cli's recovery). Opening magus never calls it. It does not touch
+ * `autoUpdate` — see {@link getMarketplaceAutoUpdate}.
  */
 export async function recoverMarketplaceSettings(): Promise<MarketplaceRecoveryResult> {
 	const known = await readKnownMarketplaces();

package/src/services/cli-tool-commands.ts

@@ -19,14 +19,115 @@
  * renderer.
  */
 
-import type { CliTool } from "../data/cli-tools.js";
+import {
+	type CatalogueEntry,
+	type CliTool,
+	type OwnedCatalogueEntry,
+	cliTools,
+	isOwnedEntry,
+} from "../data/cli-tools.js";
+import type { ResolvedBin, SelectedBin } from "../types/index.js";
 import type { Command } from "../utils/command-utils.js";
+import { ownedRequirement } from "./plugin-requires.js";
 import {
-	binInstallCommand,
 	binUninstallCommand,
 	binUpgradeCommand,
+	managedInstallCommand,
+	managedTool,
 } from "./toolchain.js";
 
+/**
+ * A catalogue row ready to probe. For a tool a plugin owns, `owned` is that
+ * plugin's requirement — what an install runs through the deps executor — and
+ * the tool's check and installer are read from it.
+ */
+export interface CatalogueTool {
+	tool: CliTool;
+	owned?: ResolvedBin;
+}
+
+/**
+ * A catalogue tool a plugin owns and installs with an option magus does not
+ * version — a release, a Homebrew cask, apt. Shown read-only, as managed by
+ * that plugin: its presence is the dependency probe's answer, and its
+ * install, update and removal are the plugin's declaration, run by
+ * `magus doctor --fix`.
+ */
+export interface PluginManagedTool {
+	entry: OwnedCatalogueEntry;
+	owned: ResolvedBin;
+}
+
+/** One catalogue row: a tool magus versions, or one its plugin manages. */
+export type CatalogueItem = CatalogueTool | PluginManagedTool;
+
+export const isPluginManagedItem = (
+	item: CatalogueItem,
+): item is PluginManagedTool => "entry" in item;
+
+/**
+ * An owned entry as a {@link CliTool}, from its plugin's requirement: null when
+ * that requirement is not installed by a version-managed kind, which the CLI
+ * Tools screen cannot track — such an entry is a {@link PluginManagedTool}.
+ */
+export function ownedCliTool(
+	entry: CatalogueEntry,
+	owned: SelectedBin,
+): CliTool | null {
+	const managed = managedTool(owned);
+	if (!managed) return null;
+	const { name, displayName, description, website, category } = entry;
+	return {
+		name,
+		displayName,
+		description,
+		website,
+		category,
+		checkCommand: owned.check.join(" "),
+		packageManager: managed.via,
+		packageName:
+			managed.package ?? managed.formula ?? managed.module ?? owned.name,
+	};
+}
+
+/** The catalogue entries that need no lookup: every one no plugin owns. */
+export function unownedCatalogue(): CatalogueTool[] {
+	return cliTools.flatMap((e) => (isOwnedEntry(e) ? [] : [{ tool: e }]));
+}
+
+/**
+ * The whole catalogue, in catalogue order, each owned entry resolved through
+ * its plugin's declaration (the copy Claude Code loads here, else the
+ * marketplace clone): a tracked tool when its chosen option is version-managed,
+ * else a {@link PluginManagedTool}. An owned entry whose declaration cannot be
+ * read here is left out: magus cannot say how to check or install it.
+ */
+export async function resolveCatalogue(
+	projectPath: string,
+	owned: (
+		pluginId: string,
+		name: string,
+		projectPath: string,
+	) => Promise<SelectedBin | null> = ownedRequirement,
+): Promise<CatalogueItem[]> {
+	const out: CatalogueItem[] = [];
+	for (const entry of cliTools) {
+		if (!isOwnedEntry(entry)) {
+			out.push({ tool: entry });
+			continue;
+		}
+		const requirement = await owned(entry.ownedBy, entry.name, projectPath);
+		if (!requirement) continue;
+		const resolved = {
+			...requirement,
+			sources: [`plugin:${entry.ownedBy}`],
+		};
+		const tool = ownedCliTool(entry, requirement);
+		out.push(tool ? { tool, owned: resolved } : { entry, owned: resolved });
+	}
+	return out;
+}
+
 /**
  * How a tool turned out to be installed, as detected from its path on disk.
  *
@@ -64,7 +165,7 @@ export type InstallMethod =
  * disagreement unrepresentable rather than merely fixed.
  */
 export function cliToolInstall(tool: CliTool): Command {
-	return binInstallCommand({
+	return managedInstallCommand({
 		name: tool.name,
 		via: tool.packageManager,
 		package: tool.packageName,