magus-cli 7.5.2 → 7.5.4

package/src/__tests__/profile-state.test.ts

@@ -13,7 +13,7 @@ import { ensureManifest, profileGate } from "../cli/bootstrap.js";
 import { reportProfileState, runDoctorCommand } from "../cli/doctor.js";
 import { runModelsCommand } from "../cli/models.js";
 import { route } from "../cli/router.js";
-import { installPlugin, uninstallPlugin } from "../services/claude-cli.js";
+import { runUpdateCommand } from "../cli/update.js";
 import {
 	readSettings,
 	writeMcpConfig,
@@ -25,6 +25,7 @@ import type { ModelsConfig } from "../services/models-core.js";
 import { reconcileActiveProfile } from "../services/profile-absorb.js";
 import {
 	activateProfile,
+	activationNotes,
 	regenerateLiveFiles,
 	trackedGeneratedFiles,
 } from "../services/profile-activate.js";
@@ -44,10 +45,6 @@ import {
 	switchToProfile,
 } from "../services/profile-state.js";
 import { applyUserProfile } from "../services/profiles.js";
-import {
-	GitCheckError,
-	TrackedLiveFileError,
-} from "../services/tracked-live-files.js";
 import type { ProfileManifest } from "../types/index.js";
 
 const MANIFEST: ProfileManifest = {
@@ -148,7 +145,7 @@ describe("strict active-profile check", () => {
 			profile: "other",
 			restored: false,
 		});
-		expect(prep.lines[0]).toContain('matches profile "other" exactly');
+		expect(prep.lines[0]).toContain('Using profile "other"');
 		expect((await readActiveMarker(project))?.profile).toBe("other");
 		expect(await activeProfile(project)).toBe("other");
 	});
@@ -227,11 +224,11 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 
 		expect(prep.problems).toEqual([]);
 		expect(prep.lines).toContain(
-			'Changes Claude Code made under the older layout were added to profile "team"',
+			'Changes Claude Code made were added to profile "team"',
 		);
 		expect(prep.lines).toContain('Added code-search@magus to profile "team"');
 		expect(prep.lines).toContain(
-			'Converted profile "team" from the older layout to real files',
+			'Updated profile "team" to the current profile format',
 		);
 		// In profiles.json...
 		const team = (await readManifest(project)).profiles.team;
@@ -268,9 +265,8 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 			enabledPlugins: { "dev@magus": true, "code-search@magus": true },
 			permissions: { allow: ["Bash(bun test:*)"] },
 		});
-		expect(prep.lines.join("\n")).toContain(
-			`was kept at .claude/.magus-backups/${kept[0]}/`,
-		);
+		// Said in the user's terms; where the backup went is checked on disk above.
+		expect(prep.lines).toContain("A backup of the old profile format was kept");
 		expect(await readdir(join(project, ".claude", "profiles"))).toEqual([
 			"active.json",
 		]);
@@ -319,7 +315,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		// stands, the key is named, and the older copy is in the backup.
 		expect(team?.models?.agents).toEqual({ "dev:architect": "smart" });
 		expect(prep.lines).toContain(
-			'Profile "team": models differs between the older layout and profiles.json — kept profiles.json\'s value; the older copy is in the -layout backup under .claude/.magus-backups/',
+			'Profile "team": models differs between the old profile format and profiles.json — kept profiles.json\'s value (the old one is backed up)',
 		);
 		const live = await fs.readJson(settingsPath());
 		expect(live.enabledPlugins["code-search@magus"]).toBe(true);
@@ -429,7 +425,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		// Removals are not applied, and the run says so, once.
 		expect(
 			prep.lines.filter((l) =>
-				l.includes("a removal made under the older layout is not applied"),
+				l.includes("a removal made in the old format is not applied"),
 			),
 		).toHaveLength(1);
 		const live = await fs.readJson(settingsPath());
@@ -481,7 +477,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 			"mcpServers.db",
 		]) {
 			expect(prep.lines).toContain(
-				`Profile "team": ${at} differs between the older layout and profiles.json — kept profiles.json's value; the older copy is in the -layout backup under .claude/.magus-backups/`,
+				`Profile "team": ${at} differs between the old profile format and profiles.json — kept profiles.json's value (the old one is backed up)`,
 			);
 		}
 		// The older copy really is in the backup.
@@ -580,7 +576,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		const prep = await prepareProfileState(project);
 
 		expect(prep.problems).toHaveLength(1);
-		expect(prep.problems[0]).toContain("did not convert it");
+		expect(prep.problems[0]).toContain("did not update the old profile format");
 		expect(
 			(await lstat(join(project, ".claude", "settings.json"))).isSymbolicLink(),
 		).toBe(true);
@@ -626,7 +622,7 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		}
 
 		expect(await snapshot()).toEqual(before);
-		expect(printed()).toContain("is on an older magus layout");
+		expect(printed()).toContain("uses an old magus profile format");
 		expect(await fs.pathExists(activeMarkerPath(project))).toBe(false);
 	});
 
@@ -640,11 +636,9 @@ describe("older layouts: Claude Code's edits are kept, the old directory is back
 		const counts = await reportProfileState(project, false);
 
 		const out = printed();
-		expect(out).toContain(
-			'No active-profile marker, but the live config matches profile "other" exactly',
-		);
+		expect(out).toContain('This project\'s plugins match profile "other"');
 		// The contradicting line is gone, and so is the failure.
-		expect(out).not.toContain("matches no single profile");
+		expect(out).not.toContain("match none of the profiles");
 		expect(counts).toEqual({ fixable: 0, unfixable: 0 });
 		// Report only: the marker is not restored.
 		expect(await readActiveMarker(project)).toBeNull();
@@ -686,7 +680,7 @@ function git(cwd: string, ...args: string[]) {
 	);
 }
 
-describe("generated files git still tracks", () => {
+describe("generated files git still tracks: written, and warned about", () => {
 	/** A repo that committed profiles.json AND settings.json, like magus-src. */
 	async function commitTrackedSettings(): Promise<void> {
 		expect(git(project, "init", "-q").status).toBe(0);
@@ -698,61 +692,70 @@ describe("generated files git still tracks", () => {
 		expect(git(project, "commit", "-q", "-m", "init").status).toBe(0);
 	}
 
-	/** Everything B1 says must not change when magus refuses. */
-	async function untouched(): Promise<void> {
-		expect(git(project, "status", "--porcelain").stdout).toBe("");
-		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
-			false,
-		);
-		expect(await fs.pathExists(backupRoot(project))).toBe(false);
-		expect(await fs.pathExists(join(project, ".gitignore"))).toBe(false);
-	}
+	/** magus never runs git: nothing is staged, whatever it wrote. */
+	const nothingStaged = () =>
+		expect(git(project, "diff", "--cached", "--name-only").stdout).toBe("");
 
-	test("B1: activating over a tracked settings.json writes nothing and names the fix", async () => {
+	// The notice is short lines: the problem, then the command on its own line.
+	const PROBLEM = "git tracks .claude/settings.json, but magus rewrites it";
+	const FIX = "git rm --cached .claude/settings.json, then commit";
+	/** Both lines, each printed exactly once. */
+	const warnedOnce = (out: string) => {
+		expect(out.split(PROBLEM).length - 1).toBe(1);
+		expect(out.split(FIX).length - 1).toBe(1);
+	};
+
+	test("B7: activating over a tracked settings.json writes it and names the fix", async () => {
 		await commitTrackedSettings();
 
-		const error = await activateProfile(MANIFEST, "team", project, {
+		const result = await activateProfile(MANIFEST, "team", project, {
 			onDisplace: () => {},
-		}).then(
-			() => null,
-			(e: unknown) => e,
-		);
+		});
 
-		expect(error).toBeInstanceOf(TrackedLiveFileError);
-		const message = (error as Error).message;
-		expect(message).toContain(".claude/settings.json");
-		expect(message).toContain("git rm --cached .claude/settings.json");
-		expect(message).toContain("Nothing was changed.");
-		await untouched();
+		expect(result.tracked).toEqual([".claude/settings.json"]);
+		expect(activationNotes(result)).toContain(PROBLEM);
+		expect(activationNotes(result)).toContain(FIX);
+		expect((await fs.readJson(settingsPath())).enabledPlugins).toEqual({
+			"dev@magus": true,
+			"terminal@magus": false,
+		});
+		expect((await readActiveMarker(project))?.profile).toBe("team");
+		expect(git(project, "status", "--porcelain").stdout).toContain(
+			" M .claude/settings.json",
+		);
+		nothingStaged();
 	});
 
-	test("B1: the gate, the switch path and a startup choice all refuse, writing nothing", async () => {
+	test("B7: the gate, the switch path and a startup choice all write", async () => {
 		await commitTrackedSettings();
 
-		const prep = await prepareProfileState(project);
-		expect(prep.refusal).toBeInstanceOf(TrackedLiveFileError);
-		expect(prep.problems[0]).toContain("git rm --cached .claude/settings.json");
-		expect(await profileGate(project)).toBe(false);
-
-		const switched = await switchToProfile(project, "other", {
-			onDisplace: () => {},
-		});
-		expect(switched.activation).toBeNull();
-		expect(switched.problems[0]).toContain(".claude/settings.json");
-
 		for (const choice of [
 			{ kind: "activate", id: "team" },
 			{ kind: "adopt", id: "default-2" },
 		] as const) {
-			await expect(
-				applyProfileChoice(choice, MANIFEST, project, { onDisplace: () => {} }),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
+			const result = await applyProfileChoice(choice, MANIFEST, project, {
+				onDisplace: () => {},
+			});
+			expect(result.profileId).toBe(choice.id);
 		}
-		await untouched();
+		const prep = await prepareProfileState(project);
+		expect(prep.problems).toEqual([]);
+		expect(await profileGate(project)).toBe(true);
+
+		const switched = await switchToProfile(project, "other", {
+			onDisplace: () => {},
+		});
+		expect(switched.problems).toEqual([]);
+		expect(switched.activation?.profileId).toBe("other");
+		expect(
+			(await fs.readJson(settingsPath())).enabledPlugins["terminal@magus"],
+		).toBe(true);
+		nothingStaged();
 	});
 
-	test("B1: the CLI router exits 1 for `magus profile switch`, and writes nothing", async () => {
+	test("B7: `magus profile switch` exits 0 and warns once, running no git", async () => {
 		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const cwd = process.cwd();
 		process.chdir(project);
 		let outcome: Awaited<ReturnType<typeof route>>;
@@ -761,63 +764,47 @@ describe("generated files git still tracks", () => {
 		} finally {
 			process.chdir(cwd);
 		}
-		expect(outcome.exitCode).toBe(1);
-		expect(printed()).toContain("git rm --cached .claude/settings.json");
-		await untouched();
+		expect(outcome.exitCode).toBe(0);
+		warnedOnce(printed());
+		expect((await readActiveMarker(project))?.profile).toBe("other");
+		nothingStaged();
+	});
+
+	test("B7: `magus update` warns once about a tracked generated file, running no git", async () => {
+		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+		// A named profile that does not exist: the command stops right after the
+		// warning, before anything reaches the network.
+		expect(await runUpdateCommand(["no-such-profile"], project)).toBe(1);
+		warnedOnce(printed());
+		nothingStaged();
 	});
 
-	test("B1: once settings.json is tracked, a pulled change regenerates nothing", async () => {
+	test("B7: once settings.json is tracked, a pulled change is still regenerated", async () => {
 		expect(git(project, "init", "-q").status).toBe(0);
 		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		// Somebody commits the generated file after all.
 		git(project, "add", "-f", ".claude/settings.json");
 		git(project, "add", ".claude/profiles.json");
 		expect(git(project, "commit", "-q", "-m", "oops").status).toBe(0);
-		const before = await fs.readFile(settingsPath(), "utf8");
 		// A teammate's pull changes the profile.
 		const pulled = structuredClone(MANIFEST);
 		(pulled.profiles.team as { plugins: Record<string, string> }).plugins[
 			"mnemex@magus"
 		] = "latest";
 		await writeManifest(pulled, project);
-		const manifestBefore = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
 
 		const prep = await prepareProfileState(project);
-		expect(prep.problems[0]).toContain("git rm --cached .claude/settings.json");
-		expect((await reconcileActiveProfile(project)).problems[0]).toContain(
-			".claude/settings.json",
-		);
-		await expect(regenerateLiveFiles(project)).rejects.toBeInstanceOf(
-			TrackedLiveFileError,
-		);
-		expect(await fs.readFile(settingsPath(), "utf8")).toBe(before);
-		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBefore);
-	});
-
-	test("B1: after `git rm --cached` and a commit, activation proceeds and keeps the committed profiles.json", async () => {
-		await commitTrackedSettings();
-		git(project, "rm", "-q", "--cached", ".claude/settings.json");
-		expect(git(project, "commit", "-q", "-m", "untrack").status).toBe(0);
-		const manifestBytes = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
 
-		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
-
-		expect((await lstat(settingsPath())).isFile()).toBe(true);
-		expect((await readActiveMarker(project))?.profile).toBe("team");
+		expect(prep.problems).toEqual([]);
+		expect(prep.lines.join("\n")).toContain("regenerated");
 		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBytes);
+			(await fs.readJson(settingsPath())).enabledPlugins["mnemex@magus"],
+		).toBe(true);
+		nothingStaged();
 	});
 
-	test("B1: adopting a repo with no profiles.json and a tracked settings.json writes nothing", async () => {
+	test("B7: adopting a repo with no profiles.json and a tracked settings.json writes and warns", async () => {
 		await fs.remove(join(project, ".claude", "profiles.json"));
 		expect(git(project, "init", "-q").status).toBe(0);
 		await fs.outputJson(settingsPath(), {
@@ -829,112 +816,113 @@ describe("generated files git still tracks", () => {
 		const savedHome = process.env.HOME;
 		process.env.HOME = home;
 		try {
-			await expect(
-				ensureManifest(project, { allowAdopt: true }),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
+			expect(
+				await ensureManifest(project, { allowAdopt: true }),
+			).not.toBeNull();
 		} finally {
 			process.env.HOME = savedHome;
 			await rm(home, { recursive: true, force: true });
 		}
-		expect(await fs.pathExists(join(project, ".claude", "profiles.json"))).toBe(
-			false,
+		const manifest = await readManifest(project);
+		expect(Object.keys(manifest.profiles)).toHaveLength(1);
+		expect(await activeProfile(project)).toBe(
+			Object.keys(manifest.profiles)[0],
 		);
-		await untouched();
+		warnedOnce(printed());
+		nothingStaged();
 	});
 
-	test("B1: doctor counts a tracked live file as a problem", async () => {
+	test("B7: doctor notes a tracked live file with the fix, and does not count it", async () => {
 		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const counts = await reportProfileState(project, false);
-		expect(counts.unfixable).toBeGreaterThan(0);
-		expect(printed()).toContain("git rm --cached .claude/settings.json");
-		await untouched();
+		expect(counts.unfixable).toBe(0);
+		expect(printed()).toContain(`• ${PROBLEM}`);
+		expect(printed()).toContain(FIX);
 	});
 
-	test("review M1: writeSettings and writeMcpConfig refuse a tracked live file and leave it as it is", async () => {
+	test("B7: writeSettings and writeMcpConfig write a tracked live file", async () => {
 		await commitTrackedSettings();
 		await fs.outputJson(join(project, ".mcp.json"), { mcpServers: {} });
 		git(project, "add", ".mcp.json");
 		expect(git(project, "commit", "-q", "-m", "mcp").status).toBe(0);
-		const before = await fs.readFile(settingsPath(), "utf8");
 
 		// What the TUI Profiles tab's "apply predefined" does.
 		const settings = await readSettings(project);
-		(settings.enabledPlugins as Record<string, boolean>)["frontend@magus"] =
-			true;
-		await expect(writeSettings(settings, project)).rejects.toBeInstanceOf(
-			TrackedLiveFileError,
-		);
-		await expect(
-			writeMcpConfig({ mcpServers: { x: { command: "x" } } }, project),
-		).rejects.toBeInstanceOf(TrackedLiveFileError);
-
-		expect(await fs.readFile(settingsPath(), "utf8")).toBe(before);
-		await untouched();
-	});
-
-	test("review M1: a project-scope Claude CLI install or uninstall is refused before the CLI runs", async () => {
-		await commitTrackedSettings();
-		const cwd = process.cwd();
-		const pathBefore = process.env.PATH;
-		// git stays reachable; `claude` does not — were the refusal missing, the
-		// CLI could not run here and touch this machine's plugins anyway.
-		const gitDir = spawnSync("sh", ["-c", "command -v git"], {
-			encoding: "utf8",
-		}).stdout.trim();
-		process.env.PATH = gitDir.slice(0, gitDir.lastIndexOf("/"));
-		process.chdir(project);
-		try {
-			await expect(
-				installPlugin("dev@magus", "project"),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
-			await expect(
-				uninstallPlugin("dev@magus", "project", project),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
-		} finally {
-			process.chdir(cwd);
-			process.env.PATH = pathBefore;
-		}
-		await untouched();
-	});
-
-	test("review M1: a project without profiles writes its own settings.json as before", async () => {
-		await commitTrackedSettings();
-		await writeManifest({ version: 2, profiles: {} }, project);
-		const settings = await readSettings(project);
 		(settings.enabledPlugins as Record<string, boolean>)["frontend@magus"] =
 			true;
 		await writeSettings(settings, project);
+		await writeMcpConfig({ mcpServers: { x: { command: "x" } } }, project);
+
 		expect(
 			(await fs.readJson(settingsPath())).enabledPlugins["frontend@magus"],
 		).toBe(true);
+		expect((await fs.readJson(join(project, ".mcp.json"))).mcpServers).toEqual({
+			x: { command: "x" },
+		});
+		nothingStaged();
 	});
 
-	test("review 3a: inside a work tree git cannot read, activation refuses with git's own message", async () => {
+	test("B7: inside a work tree git cannot read, activation writes and says git could not be asked", async () => {
 		// A .git pointing at a repository that is not there: git exits 128.
 		await fs.outputFile(
 			join(project, ".git"),
 			`gitdir: ${join(project, "no-such-repository")}\n`,
 		);
 
-		const error = await activateProfile(MANIFEST, "team", project, {
+		const result = await activateProfile(MANIFEST, "team", project, {
 			onDisplace: () => {},
-		}).then(
-			() => null,
-			(e: unknown) => e,
+		});
+
+		expect(await fs.pathExists(settingsPath())).toBe(true);
+		expect(typeof result.tracked).toBe("string");
+		expect(activationNotes(result).join("\n")).toContain(
+			"magus could not check which files git tracks in this project",
 		);
+		expect((await prepareProfileState(project)).problems).toEqual([]);
+	});
 
-		expect(error).toBeInstanceOf(GitCheckError);
-		expect((error as Error).message).toContain("not a git repository");
-		expect((error as Error).message).toContain("Nothing was changed.");
-		expect(await fs.pathExists(settingsPath())).toBe(false);
-		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
-			false,
+	test("B7 review L3: converting an older layout where git cannot answer exits 1 with git's message, no stack trace", async () => {
+		// 7.4.1 layout, a listed skill linked: the conversion must ask git which
+		// skill folders the team committed. `--dry-run` skips the entry gate, so
+		// the error reaches the router's own handler.
+		const withSkill = structuredClone(MANIFEST);
+		(withSkill.profiles.team as { skills: unknown[] }).skills = [
+			{ name: "alpha", repo: "a/b", path: "skills/alpha" },
+		];
+		await writeManifest(withSkill, project);
+		const old = join(project, ".claude", "_profiles", "team");
+		await fs.outputFile(join(old, "skills", "alpha", "SKILL.md"), "# alpha\n");
+		await fs.outputJson(join(old, "settings.json"), {
+			enabledPlugins: { "dev@magus": true },
+		});
+		await fs.symlink("_profiles/team/settings.json", settingsPath());
+		await fs.symlink(
+			"_profiles/team/skills",
+			join(project, ".claude", "skills"),
+		);
+		await fs.outputFile(
+			join(project, ".git"),
+			`gitdir: ${join(project, "no-such-repository")}\n`,
+		);
+		const cwd = process.cwd();
+		process.chdir(project);
+		let outcome: Awaited<ReturnType<typeof route>>;
+		try {
+			outcome = await route(
+				["profile", "switch", "team", "--dry-run"],
+				"0.0.0-test",
+			);
+		} finally {
+			process.chdir(cwd);
+		}
+		expect(outcome.exitCode).toBe(1);
+		expect(printed()).toContain(
+			"magus could not check which files git tracks in this project. git said:",
 		);
-		const prep = await prepareProfileState(project);
-		expect(prep.refusal).toBeInstanceOf(GitCheckError);
 	});
 
-	test("review 3a: git missing is a refusal inside a work tree, and no check outside one", async () => {
+	test("git missing is an error inside a work tree, and no check outside one", async () => {
 		expect(git(project, "init", "-q").status).toBe(0);
 		const outside = await mkdtemp(join(tmpdir(), "no-git-"));
 		const pathBefore = process.env.PATH;

package/src/__tests__/scope-action.test.ts

@@ -8,41 +8,37 @@ import { planPluginUpdates, scopeIsBehind } from "../services/update-plan.js";
 
 /**
  * The scope keys (u / p / l) and the Enter scope picker both decide between
- * install, update and uninstall. That decision used to read `scope.enabled` —
- * the `enabledPlugins` flag from a settings file — and ignore `scope.version`,
- * which is the registry-backed answer to "did Claude Code actually install
- * this".
+ * install, update and uninstall. That decision used to read the settings flag
+ * alone and ignore `scope.version`.
  *
- * Those two disagree in a real, common state: a plugin listed in
+ * The two disagree in a real, common state: a plugin listed in
  * `enabledPlugins` with no entry in `installed_plugins.json` for the current
- * project path. The list row renders it "not installed" (isEnabledButNotInstalled),
- * and pressing its scope key ran `claude plugin uninstall`. The user asked to
- * install the thing the UI told them was missing, and it was removed instead.
+ * project path — installed, with its files missing (hasMissingFiles). Pressing
+ * its scope key ran `claude plugin uninstall`. The user asked to repair the
+ * thing the UI told them was broken, and it was removed instead.
  */
 
 describe("isInstalledInScope", () => {
-	test("enabled with a registry version is installed", () => {
-		expect(isInstalledInScope({ enabled: true, version: "3.0.2" })).toBe(true);
+	test("installed with a registry version is installed", () => {
+		expect(isInstalledInScope({ installed: true, version: "3.0.2" })).toBe(
+			true,
+		);
 	});
 
-	test("enabled with NO version is not installed — the broken state", () => {
+	test("installed with NO version is still installed — files missing", () => {
 		// dev@magus, measured: `.claude/settings.json` had "dev@magus": true while
 		// installed_plugins.json had no entry resolving for the project path.
-		expect(isInstalledInScope({ enabled: true })).toBe(false);
+		// Installed is the settings fact; the missing version is the broken
+		// sub-state, and the scope key still resolves it to `install` (below).
+		expect(isInstalledInScope({ installed: true })).toBe(true);
 	});
 
-	test("a registry version with the flag off IS installed", () => {
-		// Installation and enablement are separate facts. This asserted `false`
-		// until it was measured against the other direction: a plugin with a real
-		// registry row that the user had simply switched off reported "not
-		// installed", so its row offered to install what was already on disk, and
-		// the header counted it out.
-		//
-		// The hazard the sibling test above guards — pressing a scope key on
-		// enabled-with-no-version and having it run `uninstall` — is untouched:
-		// that case has no version, so it is still not installed, and still
-		// resolves to `install`.
-		expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(true);
+	test("a registry version with the settings flag off is NOT installed", () => {
+		// A registry row alone never makes Claude Code load a plugin, and it can
+		// be inherited from another checkout of the same repository.
+		expect(isInstalledInScope({ installed: false, version: "3.0.2" })).toBe(
+			false,
+		);
 	});
 
 	test("an absent scope is not installed", () => {
@@ -50,7 +46,9 @@ describe("isInstalledInScope", () => {
 	});
 
 	test('"0.0.0" counts as installed — Anthropic official plugins record it', () => {
-		expect(isInstalledInScope({ enabled: true, version: "0.0.0" })).toBe(true);
+		expect(isInstalledInScope({ installed: true, version: "0.0.0" })).toBe(
+			true,
+		);
 	});
 });
 
@@ -59,34 +57,34 @@ describe("resolveScopeAction", () => {
 	// takes from the classifier (`scopeIsBehind`). It used to be the catalog
 	// version, compared here with raw string inequality — a fourth rule.
 
-	test("REGRESSION: enabled but not installed resolves to install, never uninstall", () => {
+	test("REGRESSION: files missing resolves to install, never uninstall", () => {
 		// This is the reported bug. Before the fix this returned "uninstall".
-		expect(resolveScopeAction({ enabled: true }, false)).toBe("install");
+		expect(resolveScopeAction({ installed: true }, false)).toBe("install");
 		// Whatever the classifier says: the safety branch comes first.
-		expect(resolveScopeAction({ enabled: true }, true)).toBe("install");
+		expect(resolveScopeAction({ installed: true }, true)).toBe("install");
 	});
 
-	test("a scope that was never enabled resolves to install", () => {
+	test("a scope that was never installed resolves to install", () => {
 		expect(resolveScopeAction(undefined, false)).toBe("install");
-		expect(resolveScopeAction({ enabled: false }, false)).toBe("install");
+		expect(resolveScopeAction({ installed: false }, false)).toBe("install");
 	});
 
 	test("a healthy install at the latest version resolves to uninstall (toggle off)", () => {
-		expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, false)).toBe(
-			"uninstall",
-		);
+		expect(
+			resolveScopeAction({ installed: true, version: "3.0.2" }, false),
+		).toBe("uninstall");
 	});
 
 	test("a healthy install behind the catalog resolves to update", () => {
-		expect(resolveScopeAction({ enabled: true, version: "2.9.0" }, true)).toBe(
-			"update",
-		);
+		expect(
+			resolveScopeAction({ installed: true, version: "2.9.0" }, true),
+		).toBe("update");
 	});
 });
 
 /** The screen's path: classify, then ask `scopeIsBehind` for the pressed scope. */
 function keyFor(installed: string, catalogVersion: string | null) {
-	const scope = { enabled: true, version: installed };
+	const scope = { installed: true, version: installed };
 	const [status] = planPluginUpdates(
 		{ "x@magus": "latest" },
 		new Map([
@@ -99,7 +97,6 @@ function keyFor(installed: string, catalogVersion: string | null) {
 					description: "",
 					marketplace: "magus",
 					marketplaceDisplay: "Magus",
-					enabled: true,
 					projectScope: scope,
 				} as PluginInfo,
 			],