magus-cli 7.5.0 → 7.5.2

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

@@ -25,7 +25,7 @@ import type {
 	PluginUpdateItem,
 	UpdatePlan,
 } from "../services/update-plan.js";
-import type { ResolvedBin } from "../types/index.js";
+import type { InstalledPluginEntry, ResolvedBin } from "../types/index.js";
 import { noMoveReasons } from "../ui/adapters/pluginsAdapter.js";
 
 const PROJECT = "/tmp/project";
@@ -780,3 +780,344 @@ describe("applyPlugins — read-back against beforeVersions", () => {
 		expect(reasons.lines(["other@magus"])).toBe("other@magus");
 	});
 });
+
+// ── B4: installed must mean LOADED ──────────────────────────────────────────
+//
+// Claude Code's loader takes the FIRST registry row relevant to the repository,
+// and rows from this repository's other checkouts (deleted worktrees included)
+// often precede this project's own. `claude plugin update` writes only this
+// project's row, so an update could show "updated" and load the old version at
+// once. The same operation now runs the stale-load repair as its last step.
+
+describe("B4: an install or update ends with the loader on the new version", () => {
+	/** `loaded` is what the loader resolves until the repair has run. */
+	function loaderDeps(loaded: string | null, repairOk = true) {
+		const stub = stubDeps("2.0.0", (pluginId, target) =>
+			repairOk
+				? {
+						pluginId,
+						target,
+						rewritten: 3,
+						backup: "/tmp/installed_plugins.json.backup.1",
+						loaded: target,
+						ok: true,
+					}
+				: {
+						pluginId,
+						target,
+						rewritten: 0,
+						backup: null,
+						loaded,
+						ok: false,
+						error: `the loader still resolves v${loaded} here, not v${target}`,
+					},
+		);
+		stub.deps.loadedVersion = mock(async () => loaded);
+		return stub;
+	}
+
+	test("B4: an update the loader does not pick up moves the older records forward and says so", async () => {
+		const { deps, rowsRepaired } = loaderDeps("1.0.0");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([item({})], PROJECT, deps, reporter);
+
+		expect(rowsRepaired).toEqual([
+			{ id: "dev@magus", target: "2.0.0", projectPath: PROJECT },
+		]);
+		expect(result.ok).toBe(1);
+		expect(result.failed).toEqual([]);
+		expect(rows).toEqual([
+			{
+				ok: true,
+				name: "dev@magus",
+				detail:
+					"project → 2.0.0 · Claude Code now loads v2.0.0 here (3 older records moved forward)",
+			},
+		]);
+	});
+
+	test("B4: a loader already on the landed version runs no repair", async () => {
+		const { deps, rowsRepaired } = loaderDeps("2.0.0");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([item({})], PROJECT, deps, reporter);
+
+		expect(rowsRepaired).toEqual([]);
+		expect(result.ok).toBe(1);
+		expect(rows[0]?.detail).toBe("project → 2.0.0");
+	});
+
+	test("B4: a repair that cannot move the loader makes the update a failure, never 'updated'", async () => {
+		const { deps } = loaderDeps("1.0.0", false);
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([item({})], PROJECT, deps, reporter);
+
+		expect(result.ok).toBe(0);
+		expect(result.failed).toEqual(["dev@magus"]);
+		expect(rows).toEqual([
+			{
+				ok: false,
+				name: "dev@magus",
+				detail:
+					"installed v2.0.0, but Claude Code still loads v1.0.0 here — the loader still resolves v1.0.0 here, not v2.0.0",
+			},
+		]);
+	});
+
+	test("B4: an install whose version did not move still brings the loader forward, and is not 'no change'", async () => {
+		// The project row already held 2.0.0; the older row ahead of it is what
+		// loaded. Reporting "no change" would leave the plugin loading 1.0.0.
+		const { deps, rowsRepaired } = loaderDeps("1.0.0");
+
+		const result = await applyPlugins(
+			[item({ beforeVersions: { project: "2.0.0" } })],
+			PROJECT,
+			deps,
+		);
+
+		expect(rowsRepaired).toHaveLength(1);
+		expect(result.unchanged).toEqual([]);
+		expect(result.ok).toBe(1);
+	});
+
+	test("B4: the TUI's per-scope install and update helpers repair at project scope", async () => {
+		const a = loaderDeps("1.0.0");
+		expect(
+			await updatePluginInScope("dev@magus", "project", PROJECT, a.deps),
+		).toBe("2.0.0");
+		expect(a.rowsRepaired).toEqual([
+			{ id: "dev@magus", target: "2.0.0", projectPath: PROJECT },
+		]);
+
+		const b = loaderDeps("1.0.0");
+		await installPluginInScope("dev@magus", "project", PROJECT, b.deps);
+		expect(b.rowsRepaired).toHaveLength(1);
+	});
+
+	test("B4: a per-scope helper whose repair fails throws, so the TUI reports a failure", async () => {
+		const { deps } = loaderDeps("1.0.0", false);
+		await expect(
+			updatePluginInScope("dev@magus", "project", PROJECT, deps),
+		).rejects.toThrow(
+			"installed v2.0.0, but Claude Code still loads v1.0.0 here",
+		);
+	});
+
+	test("B4: the per-scope helpers bring the loader forward at user and local scope too", async () => {
+		for (const scope of ["user", "local"] as const) {
+			const up = loaderDeps("1.0.0");
+			await updatePluginInScope("dev@magus", scope, PROJECT, up.deps);
+			expect(up.rowsRepaired).toEqual([
+				{ id: "dev@magus", target: "2.0.0", projectPath: PROJECT },
+			]);
+			const fresh = loaderDeps("1.0.0");
+			await installPluginInScope("dev@magus", scope, PROJECT, fresh.deps);
+			expect(fresh.rowsRepaired).toHaveLength(1);
+		}
+	});
+
+	test("B4: a machine-wide winner the repair refuses fails the user-scope update, naming why", async () => {
+		const { deps } = loaderDeps("1.0.0", false);
+		await expect(
+			updatePluginInScope("dev@magus", "user", PROJECT, deps),
+		).rejects.toThrow("the loader still resolves v1.0.0 here, not v2.0.0");
+	});
+});
+
+// ── 7.5.2: Claude Code 2.1.281 updates ANOTHER project's row ─────────────────
+//
+// `claude plugin update P --scope project` under 2.1.281 moves the repository's
+// FIRST relevant registry row — the one its loader would pick — not this
+// project's. Measured 2026-09-24, same registry, cwd = the project:
+//   2.1.280  updated from 8.0.0 to 8.1.3 for scope project (<sandbox>/magus-src)
+//   2.1.281  updated from 8.0.0 to 8.1.3 for scope project (<sandbox>/magus-src/tools/claudeup)
+// This project's row stayed at 8.0.0, and `magus update` said "no change".
+
+describe("7.5.2: an update Claude Code applied to another project's row", () => {
+	const HERE = "/tmp/project";
+	const OTHER = "/tmp/project/tools/claudeup";
+	const UNRELATED = "/tmp/another-repository";
+
+	/**
+	 * A registry for dev@magus — another project's row of the same repository
+	 * first, this project's second — and a fake Claude CLI that updates either
+	 * the first relevant row (`"2.1.281"`) or this project's (`"2.1.280"`).
+	 */
+	function registry(
+		cli: "2.1.280" | "2.1.281" | "unrelated" | "other-version",
+		cached: string[] = ["8.1.3", "8.5.0"],
+	) {
+		const rows: InstalledPluginEntry[] = [
+			{
+				scope: "project",
+				projectPath: OTHER,
+				version: "8.0.0",
+			} as InstalledPluginEntry,
+			{
+				scope: "project",
+				projectPath: HERE,
+				version: "8.0.0",
+			} as InstalledPluginEntry,
+			{
+				scope: "project",
+				projectPath: UNRELATED,
+				version: "8.0.0",
+			} as InstalledPluginEntry,
+		];
+		const repaired: string[] = [];
+		const saved: string[] = [];
+		const row = (projectPath: string) =>
+			rows.find((r) => r.projectPath === projectPath) as InstalledPluginEntry;
+		const deps: PluginApplyDeps = {
+			install: async () => {},
+			update: async () => {
+				if (cli === "2.1.280") row(HERE).version = "8.1.3";
+				if (cli === "2.1.281") row(OTHER).version = "8.1.3";
+				// Another repository's row moving while the CLI runs.
+				if (cli === "unrelated") row(UNRELATED).version = "8.1.3";
+				// This repository's row, but not to the version this update targets.
+				if (cli === "other-version") row(OTHER).version = "8.5.0";
+			},
+			repair: async () => {},
+			readInstalled: async (_id, scope, projectPath) =>
+				scope === "project" ? (row(projectPath)?.version ?? null) : null,
+			saveInstalled: async (_id, version) => {
+				saved.push(version);
+			},
+			registryRows: async () => rows.map((r) => ({ ...r })),
+			// Same repository = this project's tree, as git would answer.
+			inThisRepository: (r, projectPath) =>
+				(r.projectPath ?? "").startsWith(projectPath),
+			// What repairStaleLoad does: refuse an uncached target, else move every
+			// row of this repository that is behind it.
+			repairStaleLoad: async (pluginId, target) => {
+				repaired.push(target);
+				if (!cached.includes(target)) {
+					return {
+						pluginId,
+						target,
+						rewritten: 0,
+						backup: null,
+						loaded: null,
+						ok: false,
+						error: `no cache directory for v${target}`,
+					};
+				}
+				let rewritten = 0;
+				for (const r of rows) {
+					if (r.projectPath?.startsWith(HERE) && r.version !== target) {
+						r.version = target;
+						rewritten++;
+					}
+				}
+				return {
+					pluginId,
+					target,
+					rewritten,
+					backup: null,
+					loaded: target,
+					ok: true,
+				};
+			},
+			// The loader: the first relevant row.
+			loadedVersion: async () => rows[0]?.version ?? null,
+		};
+		return { rows, deps, repaired, saved, row };
+	}
+
+	const update = () =>
+		item({
+			installed: "8.0.0",
+			available: "8.1.3",
+			target: "8.1.3",
+			beforeVersions: { project: "8.0.0" },
+		});
+
+	test("7.5.2: under 2.1.281 this project's row follows to the fetched version, reported as updated", async () => {
+		const { deps, row, repaired, saved } = registry("2.1.281");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.1.3");
+		expect(row(OTHER).version).toBe("8.1.3"); // the CLI's change stands
+		expect(repaired).toEqual(["8.1.3"]);
+		expect(saved).toEqual(["8.1.3"]);
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+		expect(rows).toEqual([
+			{
+				ok: true,
+				name: "dev@magus",
+				detail: `project → 8.1.3 · Claude Code updated ${OTHER} instead of this project — moved this project's record to v8.1.3 too`,
+			},
+		]);
+	});
+
+	test("7.5.2: under 2.1.280 the CLI updates this project's row and nothing extra happens", async () => {
+		const { deps, row, repaired } = registry("2.1.280");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.1.3");
+		expect(result.ok).toBe(1);
+		// Exactly 7.5.1's outcome: the older row ahead of this one is brought
+		// forward by the loader check (B4), and no misdirection is reported.
+		expect(repaired).toEqual(["8.1.3"]);
+		expect(rows[0]?.detail).toBe(
+			"project → 8.1.3 · Claude Code now loads v8.1.3 here (1 older record moved forward)",
+		);
+	});
+
+	test("7.5.2: a version the CLI did not cache is not followed — still an honest no change", async () => {
+		const { deps, row } = registry("2.1.281", []);
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.0.0");
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(rows[0]?.detail).toBe(
+			`no change — the installer exited 0 but dev@magus is still 8.0.0 (Claude Code updated ${OTHER} instead of this project, and this project's record could not follow: no cache directory for v8.1.3)`,
+		);
+	});
+
+	test("7.5.2 review: a row of ANOTHER repository moving to the target is not followed", async () => {
+		const { deps, row, repaired } = registry("unrelated");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.0.0");
+		expect(repaired).toEqual([]);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(rows[0]?.detail).toBe(
+			"no change — the installer exited 0 but dev@magus is still 8.0.0",
+		);
+	});
+
+	test("7.5.2 review: this repository's row moving to a version other than the target is not followed", async () => {
+		const { deps, row, repaired } = registry("other-version");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([update()], HERE, deps, reporter);
+
+		expect(row(HERE).version).toBe("8.0.0");
+		expect(repaired).toEqual([]);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(rows[0]?.detail).toBe(
+			`no change — the installer exited 0 but dev@magus is still 8.0.0 (Claude Code updated ${OTHER} instead of this project, and this project's record could not follow: it went to v8.5.0, not the v8.1.3 this update asked for)`,
+		);
+	});
+
+	test("7.5.2: the TUI's per-scope update key follows it too", async () => {
+		const { deps, row } = registry("2.1.281");
+		expect(await updatePluginInScope("dev@magus", "project", HERE, deps)).toBe(
+			"8.1.3",
+		);
+		expect(row(HERE).version).toBe("8.1.3");
+	});
+});

package/src/cli/bootstrap.ts

@@ -18,6 +18,7 @@ import {
 	type ActivationResult,
 	activateProfile,
 	activationNotes,
+	assertNoTrackedWriteTargets,
 	reportDisplaced,
 } from "../services/profile-activate.js";
 import {
@@ -83,6 +84,9 @@ async function writeAndActivate(
 	// their hand-written files went.
 	const rel = (p: string) => path.relative(projectPath, p);
 
+	// Before the manifest is written: adopting activates, and activating a
+	// project whose settings.json git tracks would take that file over.
+	await assertNoTrackedWriteTargets(projectPath);
 	await writeManifest(result.manifest, projectPath);
 	console.log(`✓ Wrote ${rel(getManifestPath(projectPath))}`);
 

package/src/cli/doctor.ts

@@ -46,16 +46,17 @@ import {
 	type RepoRootCache,
 	pickLoadedEntry,
 } from "../services/plugin-resolution.js";
-import {
-	trackedGeneratedFiles,
-	untrackCommand,
-} from "../services/profile-activate.js";
+import { trackedGeneratedFiles } from "../services/profile-activate.js";
 import {
 	LIVE_FILE_KEYS,
 	liveKind,
 	livePath,
 	readActiveMarker,
 } from "../services/profile-live.js";
+import {
+	describeDependencies,
+	renderProfile,
+} from "../services/profile-render.js";
 import { inspectManagedSkills } from "../services/profile-skills.js";
 import {
 	type ActiveProfileCheck,
@@ -66,6 +67,10 @@ import {
 	switchHint,
 } from "../services/profile-state.js";
 import { resolveAllProfiles } from "../services/resolver.js";
+import {
+	GitCheckError,
+	untrackCommand,
+} from "../services/tracked-live-files.js";
 import type {
 	ClaudeSettings,
 	InstalledPluginsRegistry,
@@ -529,13 +534,41 @@ export async function reportProfileState(
 		} else if (check.state === "active") {
 			console.log(`✓ Active profile "${check.profile}" is in place.`);
 		}
+		// Plugin dependencies: a dependency the profile turns off stops a plugin
+		// loading; a plugin.json that cannot be read leaves its dependencies
+		// unknown, and they were not enabled.
+		const manifest = await readManifest(projectPath);
+		const { dependencies } = manifest.profiles[check.profile]
+			? await renderProfile(manifest, check.profile, projectPath)
+			: { dependencies: undefined };
+		for (const line of describeDependencies(
+			dependencies && { ...dependencies, unreadable: [] },
+			check.profile,
+		)) {
+			console.log(`✗ ${line}`);
+			unfixable++;
+		}
+		for (const line of describeDependencies(
+			dependencies && { ...dependencies, blocked: [] },
+			check.profile,
+		)) {
+			console.log(`⚠ ${line}`);
+		}
 	}
 
 	// A .gitignore entry does not untrack a file committed before it. Report
 	// only: magus never runs git rm.
-	for (const tracked of await trackedGeneratedFiles(projectPath)) {
+	let tracked: string[] = [];
+	try {
+		tracked = await trackedGeneratedFiles(projectPath);
+	} catch (error) {
+		if (!(error instanceof GitCheckError)) throw error;
+		console.log(`✗ ${error.message}`);
+		unfixable++;
+	}
+	for (const rel of tracked) {
 		console.log(
-			`✗ ${tracked} is generated from profiles.json but tracked by git. Fix: \`${untrackCommand(tracked)}\`, then commit.`,
+			`✗ ${rel} is generated from profiles.json but tracked by git. Fix: \`${untrackCommand(rel)}\`, then commit.`,
 		);
 		unfixable++;
 	}

package/src/cli/install.ts

@@ -27,6 +27,10 @@ import {
 } from "../services/install-plan.js";
 import { readManifest, validateManifest } from "../services/manifest.js";
 import { registerClosureMarketplaces } from "../services/marketplace-sync.js";
+import {
+	clearMarketplaceCache,
+	readInstalledVersionForScope,
+} from "../services/plugin-manager.js";
 import { reportDisplaced } from "../services/profile-activate.js";
 import { activeProfile } from "../services/profile-live.js";
 import {
@@ -40,6 +44,7 @@ import {
 	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";
@@ -155,6 +160,41 @@ async function installPlugins(closure: ResolvedClosure): Promise<void> {
 	}
 }
 
+/**
+ * After the installs: every plugin must LOAD the version installed here, not
+ * an older one from a registry row this repository's other checkouts left
+ * first in line. Where it does not, the same stale-load repair `magus update`
+ * chains is run, and reported either way.
+ */
+async function bringLoadsForward(
+	pluginIds: readonly string[],
+	projectPath: string,
+): Promise<void> {
+	for (const pluginId of pluginIds) {
+		const here = await readInstalledVersionForScope(
+			pluginId,
+			"project",
+			projectPath,
+		);
+		if (!here) continue;
+		const forward = await bringLoadForward(pluginId, here, projectPath);
+		if (!forward) continue;
+		if (forward.ok) {
+			console.log(
+				`✓ ${pluginId}: Claude Code now loads v${here} here (${forward.rewritten} older record${
+					forward.rewritten === 1 ? "" : "s"
+				} 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"}`,
+			);
+		}
+	}
+}
+
 async function installBins(bins: ResolvedBin[]): Promise<void> {
 	for (const bin of bins) {
 		if (await resolveExecutable(bin.name)) {
@@ -261,10 +301,13 @@ export async function runInstallCommand(
 		return 1;
 	}
 
-	// Closure: a single profile, or the union of all.
-	const closure = flags.profile
-		? await resolveProfile(manifest, flags.profile)
-		: await resolveAllProfiles(manifest);
+	// Closure: a single profile, or the union of all — with every plugin the
+	// enabled ones depend on.
+	const resolveClosure = () =>
+		flags.profile
+			? resolveProfile(manifest, flags.profile)
+			: resolveAllProfiles(manifest);
+	let closure = await resolveClosure();
 
 	if (flags.check) {
 		return runCheck(closure, manifest.strictVersions === true);
@@ -295,6 +338,25 @@ export async function runInstallCommand(
 
 	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.
+	clearMarketplaceCache();
+	const before = new Set(Object.keys(closure.plugins));
+	closure = await resolveClosure();
+	const found = Object.keys(closure.plugins).filter((id) => !before.has(id));
+	if (found.length > 0) {
+		console.log(
+			`Also installing what those plugins depend on: ${found.join(", ")}`,
+		);
+	}
+	const unreadable = closure.dependencies?.unreadable ?? [];
+	if (unreadable.length > 0) {
+		console.warn(
+			`⚠ Could not read the plugin.json of ${unreadable.join(", ")} — whatever ${
+				unreadable.length === 1 ? "it depends" : "they depend"
+			} on is not installed by this run`,
+		);
+	}
 
 	const current = await activeProfile(projectPath);
 	const activeId =
@@ -326,8 +388,10 @@ export async function runInstallCommand(
 	// meantime is kept, only the install's own records are discarded, and a
 	// Ctrl-C leaves the flag for the next command to do the same.
 	await withCliBookkeeping(projectPath, () => installPlugins(closure), {
+		installable: Object.keys(closure.plugins),
 		report: (line) => console.log(noteLine(line)),
 	});
+	await bringLoadsForward(Object.keys(closure.plugins), projectPath);
 	await installBins(closure.bins);
 
 	if (activeId) {

package/src/cli/router.ts

@@ -8,6 +8,7 @@
 
 import type { ThemeMode } from "@opentui/core";
 import { SettingsParseError } from "../services/settings-file.js";
+import { LiveFileRefusal } from "../services/tracked-live-files.js";
 import { checkForUpdates } from "../services/version-check.js";
 import { type ThemeEnv, parseThemeWord } from "../ui/theme-resolve.js";
 import { profileGate, reportUnparseable } from "./bootstrap.js";
@@ -223,6 +224,12 @@ export async function route(
 			reportUnparseable(error);
 			return HANDLED(1);
 		}
+		// A live file git tracks (or git could not say): nothing was written,
+		// and the message says what to do. A refusal, not a crash.
+		if (error instanceof LiveFileRefusal) {
+			console.error(error.message);
+			return HANDLED(1);
+		}
 		throw error;
 	}
 }

package/src/cli/update.ts

@@ -607,6 +607,9 @@ export async function runUpdateCommand(
 		projectPath,
 		() => applyPlan(plan, projectPath, { report: skills.report }),
 		{
+			// Only the active profile's plugins are this run's to install, so
+			// only their records are the CLI's.
+			installable: Object.keys(closure.plugins),
 			beforeReconcile: () =>
 				recordRefetchedSkills(projectPath, skills.fetched()),
 			report: (line) => reconciledLines.push(line),

package/src/services/claude-cli.ts

@@ -10,6 +10,7 @@
  */
 
 import { execFile } from "node:child_process";
+import path from "node:path";
 import { promisify } from "node:util";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import { which } from "../utils/command-utils.js";
@@ -19,6 +20,7 @@ import {
 	removeLocalInstalledPluginVersion,
 } from "./claude-settings.js";
 import { removeInstalledPluginVersion } from "./plugin-manager.js";
+import { refuseTrackedLiveFiles } from "./tracked-live-files.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -138,6 +140,23 @@ async function execPluginCommand(
 	}
 }
 
+/**
+ * Every `claude plugin … --scope project` command writes the project's
+ * `.claude/settings.json` (its enabledPlugins entry). In a project with
+ * profiles that file is generated; where git tracks it, refuse — before the
+ * CLI runs — rather than let the CLI write it (see `tracked-live-files.ts`).
+ * The CLI works on the current directory.
+ */
+async function refuseProjectSettingsWrite(
+	scope: PluginScope,
+	projectPath: string = process.cwd(),
+): Promise<void> {
+	if (scope !== "project") return;
+	await refuseTrackedLiveFiles(projectPath, [
+		path.join(".claude", "settings.json"),
+	]);
+}
+
 /**
  * Install a plugin using claude CLI
  * Handles enabling + version tracking + cache copy in one shot.
@@ -154,6 +173,7 @@ export async function installPlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	// 60s, matching update and repair. Before the install/update split this path
 	// ran through `updatePlugin`'s 60s budget; leaving it on the 30s default
 	// would have quietly halved the time a fresh install — the SLOWEST of the
@@ -172,6 +192,7 @@ export async function uninstallPlugin(
 	scope: PluginScope = "user",
 	projectPath?: string,
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope, projectPath);
 	try {
 		await execClaude(["plugin", "uninstall", pluginId, "--scope", scope]);
 	} catch {
@@ -224,6 +245,7 @@ export async function enablePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	await execClaude(["plugin", "enable", pluginId, "--scope", scope]);
 }
 
@@ -234,6 +256,7 @@ export async function disablePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	await execClaude(["plugin", "disable", pluginId, "--scope", scope]);
 }
 
@@ -276,6 +299,7 @@ export async function updatePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	await execPluginCommand("update", pluginId, scope, 60000);
 }