magus-cli 7.8.0 → 7.9.0

package/src/cli/deps-view.ts

@@ -0,0 +1,213 @@
+/**
+ * The terminal rendering of plugin dependencies: doctor's report section, the
+ * consent list, live progress, and the result of an apply. `magus doctor` and
+ * `magus install` both render through here; `--json` and the TUI render the
+ * same `ApplyOutcome[]` their own way.
+ */
+
+import {
+	type ApplyEvent,
+	type ApplyOutcome,
+	DepsLockBusy,
+	type DepsPlan,
+	type PathAdvice,
+	type PlanEnv,
+	applyDepsPlan,
+	defaultLockPath,
+	planLines,
+	requiredByOf,
+} from "../services/deps-plan.js";
+import type { DepsState } from "../services/deps-report.js";
+import { installText } from "../services/doctor-bins.js";
+import {
+	type Os,
+	type Presence,
+	doctorFixCommand,
+} from "../shared/plugin/hooks/lib/requires-probe.js";
+import { askYesNo } from "./prompt.js";
+import { question } from "./update-view.js";
+
+function presenceLine(name: string, p: Presence, by: string): string | null {
+	switch (p.status) {
+		case "present":
+			return null;
+		case "missing":
+			return `  ✗ ${name} — missing${p.blockedBy ? ` (needs ${p.blockedBy} first)` : ""}  (${by})`;
+		case "off-path":
+			return `  ⚠ ${name} — installed in ${p.prefix}, which is not on the PATH Claude Code starts with  (${by})`;
+		case "unknown":
+			return `  ⚠ ${name} — could not tell: ${p.reason}  (${by})`;
+	}
+}
+
+/**
+ * doctor's "Plugin dependencies" section. Counts what `--fix` can and cannot
+ * act on. `projectDir` is `--project`'s directory, named in the fix line.
+ */
+export function depsSectionLines(
+	state: DepsState,
+	env: PlanEnv,
+	projectDir: string | null = null,
+): { lines: string[]; fixable: number; unfixable: number } {
+	const { collected, presences, plan } = state;
+	const lines: string[] = [];
+	let unfixable = 0;
+	collected.bins.forEach((bin, i) => {
+		const p = presences[i] as Presence;
+		const line = presenceLine(bin.name, p, requiredByOf(bin).join(", "));
+		if (!line) return;
+		lines.push(line);
+		if (p.status === "missing")
+			lines.push(`      fix: ${installText(bin, env)}`);
+		if (p.status === "off-path") unfixable++;
+	});
+	for (const problem of collected.problems) {
+		lines.push(
+			problem.kind === "invalid"
+				? `  ✗ ${problem.plugin} — its dependency declaration is invalid (${problem.errors.join("; ")}) — please report it to the plugin's author`
+				: `  ✗ ${problem.plugin} — ${problem.errors.join("; ")}`,
+		);
+		unfixable++;
+	}
+	for (const u of plan.unfixable) {
+		lines.push(`  ✗ ${u.name} — ${u.why}`);
+		unfixable++;
+	}
+	if (plan.steps.length > 0) {
+		lines.push(`    Fix: ${doctorFixCommand(projectDir)}`);
+	}
+	lines.push(...pathAdviceLines(plan.pathAdvice));
+	if (lines.length === 0 && collected.bins.length > 0) {
+		lines.push(`  ✓ All ${collected.bins.length} plugin dependencies present.`);
+	}
+	return {
+		lines: lines.length > 0 ? ["Plugin dependencies:", ...lines] : [],
+		fixable: plan.steps.length,
+		unfixable,
+	};
+}
+
+/** A box with a title, for the two blocks a person must act on. */
+function box(title: string, body: string[]): string[] {
+	return [`  ┌─ ${title}`, ...body.map((l) => `  │ ${l}`), "  └─"];
+}
+
+/** The PATH lines to add, ending with the restart. Empty when none. */
+export function pathAdviceLines(advice: readonly PathAdvice[]): string[] {
+	if (advice.length === 0) return [];
+	return box("DO THIS NEXT", [
+		...advice.map(
+			(a) =>
+				`${a.prefix} is not on your PATH: add  ${a.rcLine}  to ${a.rcFile}`,
+		),
+		"then restart Claude Code from a new terminal",
+	]);
+}
+
+const STATUS_TEXT: Record<ApplyOutcome["status"], string> = {
+	installed: "installed",
+	"off-path": "installed OFF the PATH Claude Code starts with",
+	failed: "failed",
+	"needs-password": "needs your sudo password",
+	"needs-root": "needs root",
+	blocked: "blocked",
+};
+
+/** The result of an apply: one row per step, then what needs the user. */
+export function renderApplyText(outcomes: readonly ApplyOutcome[]): string[] {
+	if (outcomes.length === 0) return [];
+	const width = Math.max(...outcomes.map((o) => o.name.length));
+	const mark = (o: ApplyOutcome) =>
+		o.status === "installed" ? "✓" : o.status === "off-path" ? "⚠" : "✗";
+	const lines = outcomes.map(
+		(o) =>
+			`  ${mark(o)} ${o.name.padEnd(width)}  ${STATUS_TEXT[o.status]}${o.dir ? ` (${o.dir})` : ""}${
+				o.durationMs > 0 ? `  ${(o.durationMs / 1000).toFixed(1)}s` : ""
+			}`,
+	);
+	const needs = outcomes.filter((o) => o.status !== "installed");
+	if (needs.length === 0) return lines;
+	const body: string[] = [];
+	for (const o of needs) {
+		body.push(
+			`${o.name}: ${STATUS_TEXT[o.status]}${o.dir ? ` — it is in ${o.dir}` : ""}`,
+		);
+		const last = o.outputTail.trim().split("\n").pop();
+		if (o.status === "failed" && last) body.push(`  ${last}`);
+		if (o.remedy) body.push(`  ${o.remedy}`);
+	}
+	return [...lines, ...box("NEEDS YOU", body)];
+}
+
+/** Live progress for a text apply, to stderr so stdout stays the report. */
+export function stderrProgress(e: ApplyEvent): void {
+	if (e.type === "step-start") {
+		process.stderr.write(`→ ${e.name}: ${e.describe}\n`);
+	} else if (e.type === "output") {
+		for (const line of e.chunk.split("\n")) {
+			if (line.trim()) process.stderr.write(`    ${line}\n`);
+		}
+	}
+}
+
+export interface FixDepsOptions {
+	yes: boolean;
+	/** Write progress and ask questions (text mode); false for `--json`. */
+	interactive: boolean;
+	/** For `--json` and tests: the lock path; defaults to the cache dir. */
+	lockPath?: string;
+	/** `--project`'s directory, named in a remedy's fix line. */
+	projectDir?: string | null;
+}
+
+export type FixDepsResult =
+	| { kind: "applied"; outcomes: ApplyOutcome[]; after: DepsState }
+	| { kind: "declined" }
+	| { kind: "busy"; message: string };
+
+/** The consent question's body: every step, once. */
+export function consentLines(plan: DepsPlan, os: Os): string[] {
+	return [
+		`Install ${plan.steps.length} plugin dependenc${plan.steps.length === 1 ? "y" : "ies"}:`,
+		...planLines(plan, os).map((l) => `  ${l}`),
+	];
+}
+
+/**
+ * The `--fix` flow, shared by doctor and install: list every step once, ask
+ * once (unless `yes`), apply, then re-assess from a fresh probe.
+ */
+export async function fixDeps(
+	state: DepsState,
+	env: PlanEnv,
+	opts: FixDepsOptions,
+	reassess: () => Promise<DepsState>,
+): Promise<FixDepsResult> {
+	try {
+		const outcomes = await applyDepsPlan(state.plan, {
+			yes: opts.yes,
+			env,
+			projectDir: opts.projectDir ?? null,
+			lockPath:
+				opts.lockPath ?? defaultLockPath(env.home, process.env.XDG_CACHE_HOME),
+			confirm: async (plan) => {
+				for (const line of consentLines(plan, env.os)) console.log(line);
+				return askYesNo(question("Install them now?"));
+			},
+			...(opts.interactive ? { onEvent: stderrProgress } : {}),
+		});
+		if (outcomes.length === 0 && state.plan.steps.length > 0) {
+			return { kind: "declined" };
+		}
+		return {
+			kind: "applied",
+			outcomes,
+			after: await reassess(),
+		};
+	} catch (error) {
+		if (error instanceof DepsLockBusy) {
+			return { kind: "busy", message: error.message };
+		}
+		throw error;
+	}
+}

package/src/cli/doctor.ts

@@ -1,10 +1,15 @@
 /**
- * `magus doctor [--fix]`
+ * `magus doctor [--json] [--fix] [--yes] [--project <dir>]`
  *
- * Diagnoses (and with --fix, repairs) project health:
+ * Diagnoses (and with --fix, repairs) the health of the project in the current
+ * directory, or in `--project`'s:
  *   0. Global settings — `~/.claude/settings.json` parses.
- *   1. Binary dependencies — every requires.bin / cliTools binary on PATH.
- *      This is the check that would have caught a dead `tmux-mcp`.
+ *   1. Plugin dependencies — what every plugin Claude Code loads here declares
+ *      in `requires` (plus the profiles' cliTools), probed with each
+ *      declaration's own check. `--fix` lists every install once, asks once
+ *      (`--yes` skips the question) and installs through the deps executor.
+ *      `--json` prints only this section, as one document on stdout, and
+ *      `--fix --json` repairs only this section: dependencies, nothing else.
  *   2. Profile state — which profile is active (strictly), what the next magus
  *      command would record or regenerate (with `--fix`, it does it now and
  *      says what it did), generated files git still tracks, and
@@ -21,6 +26,7 @@
  * them, because magus never rewrites a file it cannot parse.
  */
 
+import os from "node:os";
 import path from "node:path";
 import fs from "fs-extra";
 import {
@@ -31,7 +37,13 @@ import {
 	readLocalSettings,
 	readSettings,
 } from "../services/claude-settings.js";
-import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
+import type { PlanEnv } from "../services/deps-plan.js";
+import {
+	type DepsState,
+	assessDeps,
+	depsReportJson,
+} from "../services/deps-report.js";
+import { machineEnv } from "../services/doctor-bins.js";
 import { checkProject, fixDoctorIssues } from "../services/doctor.js";
 import {
 	isAgentModelHookRegistered,
@@ -77,10 +89,54 @@ import type {
 	ProfileManifest,
 } from "../types/index.js";
 import { resolveExecutable } from "../utils/command-utils.js";
+import { depsSectionLines, fixDeps, renderApplyText } from "./deps-view.js";
+
+/**
+ * `--project <dir>`: the directory to check, or null for the current one. A
+ * string `error` is a usage error to print.
+ */
+function projectOption(
+	args: string[],
+): { dir: string | null } | { error: string } {
+	const at = args.indexOf("--project");
+	if (at === -1) return { dir: null };
+	const value = args[at + 1];
+	if (value === undefined || value.startsWith("-")) {
+		return { error: "magus doctor --project needs a directory" };
+	}
+	const dir = path.resolve(value);
+	let isDir = false;
+	try {
+		isDir = fs.statSync(dir).isDirectory();
+	} catch {
+		// Absent: reported below like any other non-directory.
+	}
+	return isDir
+		? { dir }
+		: { error: `magus doctor --project: ${value} is not a directory` };
+}
 
 export async function runDoctorCommand(args: string[]): Promise<number> {
 	const fix = args.includes("--fix");
+	const yes = args.includes("--yes") || args.includes("-y");
+	const project = projectOption(args);
+	if ("error" in project) {
+		console.error(project.error);
+		return 2;
+	}
+	// Doctor checks the directory it runs in: the plugins enabled there, its
+	// profiles, and each check runs there as Claude Code runs a plugin's servers.
+	// `--project` moves it there, so every one of those reads the same directory.
+	if (project.dir !== null) process.chdir(project.dir);
 	const projectPath = process.cwd();
+	const env = machineEnv(
+		process.env.HOME || os.homedir(),
+		process.env.PATH ?? "",
+		process.env.SHELL ?? "",
+	);
+	if (args.includes("--json")) {
+		return runDepsJson(projectPath, env, { fix, yes, projectDir: project.dir });
+	}
 	let problems = 0;
 	// Findings `--fix` does not repair, counted apart so it cannot silence
 	// them — see doctorExitCode.
@@ -93,7 +149,17 @@ export async function runDoctorCommand(args: string[]): Promise<number> {
 	const globalSettingsError = await checkGlobalSettings();
 	if (globalSettingsError) unfixable++;
 
-	// 1. Binary dependencies, which needs the manifest to know what to check.
+	// 1. Plugin dependencies.
+	if (env) {
+		const deps = await reportDeps(projectPath, env, {
+			fix,
+			yes,
+			projectDir: project.dir,
+		});
+		problems += deps.fixable;
+		unfixable += deps.unfixable;
+	}
+
 	let manifest: ProfileManifest | null = null;
 	try {
 		manifest = await readManifest(projectPath);
@@ -104,25 +170,11 @@ export async function runDoctorCommand(args: string[]): Promise<number> {
 	}
 	let pluginIds: string[] = [];
 	if (manifest && Object.keys(manifest.profiles).length > 0) {
-		const closure = await resolveAllProfiles(manifest);
+		// Plugin ids only: the dependency section above read every requirement.
+		const closure = await resolveAllProfiles(manifest, {
+			binResolver: async () => [],
+		});
 		pluginIds = Object.keys(closure.plugins);
-		if (closure.bins.length > 0) {
-			const results = await checkBinaries(closure.bins);
-			const missing = missingBinaries(results);
-			if (missing.length > 0) {
-				console.log("Binary dependencies:");
-				for (const m of missing) {
-					console.log(
-						`  ✗ ${m.name} — run: ${m.installCommand}  (needed by ${m.sources.join(", ")})`,
-					);
-					problems++;
-				}
-			} else {
-				console.log(
-					`✓ All ${closure.bins.length} binary dependencies present.`,
-				);
-			}
-		}
 	}
 
 	// 2. Profile state.
@@ -183,6 +235,99 @@ export async function runDoctorCommand(args: string[]): Promise<number> {
 	return doctorExitCode({ fixable: problems, unfixable, fix });
 }
 
+interface DoctorDepsFlags {
+	fix: boolean;
+	yes: boolean;
+	/** `--project`'s directory, named in every fix line doctor prints; else null. */
+	projectDir: string | null;
+}
+
+/**
+ * Section 1 in text: the report, and with `--fix` the install. After an
+ * install the report is printed again from a fresh probe, and whatever is
+ * still missing counts as a problem `--fix` could not solve.
+ */
+async function reportDeps(
+	projectPath: string,
+	env: PlanEnv,
+	flags: DoctorDepsFlags,
+): Promise<{ fixable: number; unfixable: number }> {
+	const state = await assessDeps(projectPath, env);
+	const before = depsSectionLines(state, env, flags.projectDir);
+	for (const line of before.lines) console.log(line);
+	if (!flags.fix || before.fixable === 0) return before;
+
+	console.log("");
+	const result = await fixDeps(
+		state,
+		env,
+		{ yes: flags.yes, interactive: true, projectDir: flags.projectDir },
+		() => assessDeps(projectPath, env),
+	);
+	if (result.kind === "busy") {
+		console.log(`  ✗ ${result.message}`);
+		return { fixable: 0, unfixable: before.fixable + before.unfixable };
+	}
+	if (result.kind === "declined") {
+		console.log("  Nothing installed.");
+		return { fixable: 0, unfixable: before.fixable + before.unfixable };
+	}
+	for (const line of renderApplyText(result.outcomes)) console.log(line);
+	const after = depsSectionLines(result.after, env, flags.projectDir);
+	console.log("");
+	for (const line of after.lines) console.log(line);
+	// Still missing after an install is not something a re-run of --fix fixes
+	// silently: it is a problem, counted so the exit code says so.
+	return { fixable: 0, unfixable: after.fixable + after.unfixable };
+}
+
+/**
+ * `--json`: only the dependency section, as one document on stdout and
+ * nothing else there. `--fix --json` needs `--yes`: with stdout carrying the
+ * document, there is nowhere to ask.
+ */
+async function runDepsJson(
+	projectPath: string,
+	env: PlanEnv | null,
+	flags: DoctorDepsFlags,
+): Promise<number> {
+	if (!env) {
+		console.error("magus doctor --json: this platform is not supported");
+		return 1;
+	}
+	if (flags.fix && !flags.yes) {
+		console.error(
+			"magus doctor --fix --json needs --yes: nothing can be asked while stdout carries the report",
+		);
+		return 2;
+	}
+	let state: DepsState = await assessDeps(projectPath, env);
+	let applied: ReturnType<typeof depsReportJson>["applied"];
+	if (flags.fix && state.plan.steps.length > 0) {
+		const result = await fixDeps(
+			state,
+			env,
+			{ yes: true, interactive: false, projectDir: flags.projectDir },
+			() => assessDeps(projectPath, env),
+		);
+		if (result.kind === "busy") {
+			console.error(result.message);
+			return 1;
+		}
+		if (result.kind === "applied") {
+			applied = result.outcomes;
+			state = result.after;
+		}
+	}
+	const report = depsReportJson(state, env, applied);
+	process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+	const healthy =
+		report.deps.every((d) => d.status === "present") &&
+		report.invalid.length === 0 &&
+		report.plugins_needing_update.length === 0;
+	return healthy ? 0 : 1;
+}
+
 /**
  * A file that exists and does not parse, as a finding under `heading`.
  *

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,
@@ -39,20 +44,14 @@ import {
 } from "../services/profile-state.js";
 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,
 	describeLoadNotForward,
 } 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";
+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 {
@@ -108,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.
  *
@@ -218,19 +175,42 @@ async function bringLoadsForward(
 	}
 }
 
-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(
@@ -373,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.
@@ -438,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