magus-cli 7.5.3 → 7.5.4

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

@@ -145,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");
 	});
@@ -224,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;
@@ -265,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",
 		]);
@@ -316,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);
@@ -426,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());
@@ -478,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.
@@ -577,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);
@@ -623,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);
 	});
 
@@ -637,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();
@@ -699,8 +696,14 @@ describe("generated files git still tracks: written, and warned about", () => {
 	const nothingStaged = () =>
 		expect(git(project, "diff", "--cached", "--name-only").stdout).toBe("");
 
-	const WARNING =
-		".claude/settings.json is generated from .claude/profiles.json but tracked by git — run `git rm --cached .claude/settings.json`, then commit";
+	// 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();
@@ -710,7 +713,8 @@ describe("generated files git still tracks: written, and warned about", () => {
 		});
 
 		expect(result.tracked).toEqual([".claude/settings.json"]);
-		expect(activationNotes(result)).toContain(WARNING);
+		expect(activationNotes(result)).toContain(PROBLEM);
+		expect(activationNotes(result)).toContain(FIX);
 		expect((await fs.readJson(settingsPath())).enabledPlugins).toEqual({
 			"dev@magus": true,
 			"terminal@magus": false,
@@ -761,7 +765,7 @@ describe("generated files git still tracks: written, and warned about", () => {
 			process.chdir(cwd);
 		}
 		expect(outcome.exitCode).toBe(0);
-		expect(printed().split(WARNING).length - 1).toBe(1);
+		warnedOnce(printed());
 		expect((await readActiveMarker(project))?.profile).toBe("other");
 		nothingStaged();
 	});
@@ -772,7 +776,7 @@ describe("generated files git still tracks: written, and warned about", () => {
 		// 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);
-		expect(printed().split(WARNING).length - 1).toBe(1);
+		warnedOnce(printed());
 		nothingStaged();
 	});
 
@@ -824,7 +828,7 @@ describe("generated files git still tracks: written, and warned about", () => {
 		expect(await activeProfile(project)).toBe(
 			Object.keys(manifest.profiles)[0],
 		);
-		expect(printed()).toContain(WARNING);
+		warnedOnce(printed());
 		nothingStaged();
 	});
 
@@ -833,7 +837,8 @@ describe("generated files git still tracks: written, and warned about", () => {
 		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const counts = await reportProfileState(project, false);
 		expect(counts.unfixable).toBe(0);
-		expect(printed()).toContain(`• ${WARNING}`);
+		expect(printed()).toContain(`• ${PROBLEM}`);
+		expect(printed()).toContain(FIX);
 	});
 
 	test("B7: writeSettings and writeMcpConfig write a tracked live file", async () => {

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,
 			],

package/src/__tests__/scope-row-lookup.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Which registry row a question reads — the pure halves of two fixes whose
+ * end-to-end cases are in installed-version-scope.test.tsx.
+ *
+ * - `ownRegistryEntry`: "does THIS project hold a row at this scope?" — the
+ *   apply engine's guard before `update`. It used to be answered by the lookup
+ *   that falls back to inherited rows and then the user row.
+ * - `contentDriftEntry`: the row whose commit a content-drift check compares.
+ *   It used to be the project lookup for every plugin, installed there or not.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { ownRegistryEntry } from "../services/claude-settings.js";
+import {
+	type PluginInfo,
+	contentDriftEntry,
+} from "../services/plugin-manager.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+
+const REPO = "/work/repo";
+const HERE = "/work/repo/sub";
+
+const row = (over: Partial<InstalledPluginEntry>): InstalledPluginEntry => ({
+	scope: "user",
+	installPath: "/cache",
+	version: "1.0.0",
+	installedAt: "",
+	lastUpdated: "",
+	...over,
+});
+
+describe("ownRegistryEntry — this project's own row, exactly", () => {
+	test("never falls back to the user row for project or local scope", () => {
+		const rows = [row({ scope: "user" })];
+		expect(ownRegistryEntry(rows, "project", HERE)).toBeUndefined();
+		expect(ownRegistryEntry(rows, "local", HERE)).toBeUndefined();
+		expect(ownRegistryEntry(rows, "user", HERE)?.scope).toBe("user");
+	});
+
+	test("never takes a row inherited from the repository root", () => {
+		const rows = [row({ scope: "project", projectPath: REPO })];
+		expect(ownRegistryEntry(rows, "project", HERE)).toBeUndefined();
+	});
+
+	test("matches scope and path exactly — a local row is not a project row", () => {
+		const local = row({ scope: "local", projectPath: HERE, version: "3.0.0" });
+		const project = row({
+			scope: "project",
+			projectPath: `${HERE}/`,
+			version: "2.0.0",
+		});
+		expect(ownRegistryEntry([local], "project", HERE)).toBeUndefined();
+		expect(ownRegistryEntry([local, project], "project", HERE)?.version).toBe(
+			"2.0.0",
+		);
+		expect(ownRegistryEntry([local, project], "local", HERE)?.version).toBe(
+			"3.0.0",
+		);
+	});
+});
+
+describe("contentDriftEntry — the row behind an installed scope", () => {
+	const USER = row({ scope: "user", version: "0.9.0", gitCommitSha: "user" });
+	const INHERITED = row({
+		scope: "project",
+		projectPath: REPO,
+		version: "0.8.1",
+		gitCommitSha: "inherited",
+	});
+	const OWN = row({
+		scope: "project",
+		projectPath: HERE,
+		version: "0.9.0",
+		gitCommitSha: "own",
+	});
+	const plugin = (over: Partial<PluginInfo>): PluginInfo => ({
+		id: "probe@magus",
+		name: "probe",
+		version: "0.9.0",
+		description: "",
+		marketplace: "magus",
+		marketplaceDisplay: "Magus",
+		installedVersion: "0.9.0",
+		...over,
+	});
+
+	test("installed at user, beside an inherited project row of another version: the user row", () => {
+		const entry = contentDriftEntry(
+			plugin({
+				userScope: { installed: true, version: "0.9.0" },
+				projectScope: { installed: false, version: "0.8.1" },
+			}),
+			[USER, INHERITED],
+			HERE,
+			[REPO],
+		);
+		expect(entry?.gitCommitSha).toBe("user");
+	});
+
+	test("installed at both at the same version: this directory's row first", () => {
+		const entry = contentDriftEntry(
+			plugin({
+				userScope: { installed: true, version: "0.9.0" },
+				projectScope: { installed: true, version: "0.9.0" },
+			}),
+			[USER, OWN],
+			HERE,
+			[REPO],
+		);
+		expect(entry?.gitCommitSha).toBe("own");
+	});
+
+	test("no installed scope with a version: no row", () => {
+		const entry = contentDriftEntry(
+			plugin({
+				installedVersion: undefined,
+				userScope: { installed: true },
+				projectScope: { installed: false, version: "0.8.1" },
+			}),
+			[INHERITED],
+			HERE,
+			[REPO],
+		);
+		expect(entry).toBeUndefined();
+	});
+});

package/src/__tests__/select-restore.test.ts

@@ -0,0 +1,209 @@
+/**
+ * `selectOption` always puts the terminal back.
+ *
+ * It sets raw mode, attaches a keypress listener and hides the cursor, and only
+ * Enter, Esc and Ctrl+C undid them. A throw while drawing, a SIGTERM or a SIGHUP
+ * left the shell in raw mode with no cursor — typing blind until `reset`.
+ *
+ * `process.stdin` and `process.stdout` are swapped for fakes for the length of
+ * each case, so no real terminal is touched; `process.exit` is stubbed wherever
+ * a signal handler would call it.
+ */
+
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import { selectOption } from "../cli/select.js";
+
+const SHOW_CURSOR = "\x1b[?25h";
+const HIDE_CURSOR = "\x1b[?25l";
+/** Every frame row is written with this prefix; control sequences are not. */
+const FRAME_ROW = "\x1b[2K";
+
+class FakeStdin extends EventEmitter {
+	isTTY = true;
+	isRaw = false;
+	setRawMode(raw: boolean): this {
+		this.isRaw = raw;
+		return this;
+	}
+	resume(): this {
+		return this;
+	}
+	pause(): this {
+		return this;
+	}
+	key(name: string, extra: Record<string, unknown> = {}): void {
+		this.emit("keypress", "", { name, ...extra });
+	}
+}
+
+class FakeStdout {
+	isTTY = true;
+	writes: string[] = [];
+	frames = 0;
+	/** Throw on this frame (1-based): the first draw, or a redraw. */
+	constructor(private readonly throwOnFrame = 0) {}
+	write(chunk: string): boolean {
+		if (chunk.includes(FRAME_ROW) && ++this.frames === this.throwOnFrame) {
+			throw new Error("the terminal went away");
+		}
+		this.writes.push(chunk);
+		return true;
+	}
+}
+
+const WATCHED = ["exit", "SIGTERM", "SIGHUP"] as const;
+const listenerCounts = () =>
+	Object.fromEntries(WATCHED.map((e) => [e, process.listenerCount(e)]));
+
+const originals = {
+	stdin: Object.getOwnPropertyDescriptor(process, "stdin"),
+	stdout: Object.getOwnPropertyDescriptor(process, "stdout"),
+};
+
+function useFakes(stdout = new FakeStdout()) {
+	const stdin = new FakeStdin();
+	Object.defineProperty(process, "stdin", {
+		value: stdin,
+		configurable: true,
+		writable: true,
+	});
+	Object.defineProperty(process, "stdout", {
+		value: stdout,
+		configurable: true,
+		writable: true,
+	});
+	return { stdin, stdout };
+}
+
+let exitSpy: ReturnType<typeof spyOn> | null = null;
+
+afterEach(() => {
+	if (originals.stdin) Object.defineProperty(process, "stdin", originals.stdin);
+	if (originals.stdout)
+		Object.defineProperty(process, "stdout", originals.stdout);
+	exitSpy?.mockRestore();
+	exitSpy = null;
+});
+
+const ITEMS = [{ label: "One" }, { label: "Two" }, { label: "Three" }];
+
+/** Raw mode off, no keypress listener, the cursor shown after it was hidden. */
+function expectRestored(stdin: FakeStdin, stdout: FakeStdout): void {
+	expect(stdin.isRaw).toBe(false);
+	expect(stdin.listenerCount("keypress")).toBe(0);
+	const hidden = stdout.writes.lastIndexOf(HIDE_CURSOR);
+	expect(hidden).toBeGreaterThanOrEqual(0);
+	expect(stdout.writes.lastIndexOf(SHOW_CURSOR)).toBeGreaterThan(hidden);
+}
+
+describe("an answer still behaves as it did", () => {
+	test("Enter picks the current row, and the terminal is back", async () => {
+		const { stdin, stdout } = useFakes();
+		const baseline = listenerCounts();
+		const answer = selectOption("Pick", ITEMS);
+		stdin.key("down");
+		stdin.key("return");
+
+		expect(await answer).toBe(1);
+		expectRestored(stdin, stdout);
+		// The cursor is shown last, after the one-line answer.
+		expect(stdout.writes.at(-1)).toBe(SHOW_CURSOR);
+		expect(stdout.writes.at(-2)).toContain("Two");
+		expect(listenerCounts()).toEqual(baseline);
+	});
+
+	test("Esc and Ctrl+C cancel with null, and the terminal is back", async () => {
+		for (const key of [{ name: "escape" }, { name: "c", ctrl: true }]) {
+			const { stdin, stdout } = useFakes();
+			const answer = selectOption("Pick", ITEMS);
+			stdin.key(key.name, key);
+			expect(await answer).toBeNull();
+			expectRestored(stdin, stdout);
+		}
+	});
+
+	test("keys after the answer in the same read are not handled", async () => {
+		const { stdin, stdout } = useFakes();
+		const answer = selectOption("Pick", ITEMS);
+		stdin.key("return");
+		stdin.key("down");
+		stdin.key("return");
+		expect(await answer).toBe(0);
+		expect(stdout.writes.filter((w) => w.includes("One")).length).toBe(2);
+	});
+});
+
+describe("anything else that ends it puts the terminal back too", () => {
+	test("a throw on the first draw rejects, and the terminal is back", async () => {
+		const { stdin, stdout } = useFakes(new FakeStdout(1));
+		const baseline = listenerCounts();
+
+		await expect(selectOption("Pick", ITEMS)).rejects.toThrow(
+			"the terminal went away",
+		);
+		expectRestored(stdin, stdout);
+		expect(listenerCounts()).toEqual(baseline);
+	});
+
+	test("a throw redrawing after a key rejects instead of escaping the listener", async () => {
+		const { stdin, stdout } = useFakes(new FakeStdout(2));
+		const answer = selectOption("Pick", ITEMS);
+
+		expect(() => stdin.key("down")).not.toThrow();
+		await expect(answer).rejects.toThrow("the terminal went away");
+		expectRestored(stdin, stdout);
+	});
+
+	for (const [signal, code] of [
+		["SIGTERM", 143],
+		["SIGHUP", 129],
+	] as const) {
+		test(`${signal} puts the terminal back, then exits ${code}`, () => {
+			const { stdin, stdout } = useFakes();
+			const baseline = listenerCounts();
+			exitSpy = spyOn(process, "exit").mockImplementation(
+				(() => undefined) as never,
+			);
+			void selectOption("Pick", ITEMS);
+
+			process.emit(signal);
+
+			expectRestored(stdin, stdout);
+			expect(exitSpy).toHaveBeenCalledWith(code);
+			// One-shot, and the others went with it.
+			expect(listenerCounts()).toEqual(baseline);
+		});
+	}
+
+	test("the process exiting while it is open puts the terminal back", () => {
+		const { stdin, stdout } = useFakes();
+		const before = process.listeners("exit");
+		void selectOption("Pick", ITEMS);
+		const added = process.listeners("exit").filter((l) => !before.includes(l));
+
+		// Its own listener only: emitting "exit" would run everyone's.
+		expect(added).toHaveLength(1);
+		(added[0] as (code: number) => void)(0);
+
+		expectRestored(stdin, stdout);
+		expect(process.listeners("exit")).toEqual(before);
+	});
+});
+
+describe("the handlers live exactly as long as the list", () => {
+	test("one each while it is open, none after it answers", async () => {
+		const { stdin } = useFakes();
+		const baseline = listenerCounts();
+		const answer = selectOption("Pick", ITEMS);
+
+		expect(listenerCounts()).toEqual({
+			exit: baseline.exit + 1,
+			SIGTERM: baseline.SIGTERM + 1,
+			SIGHUP: baseline.SIGHUP + 1,
+		});
+		stdin.key("return");
+		await answer;
+		expect(listenerCounts()).toEqual(baseline);
+	});
+});

package/src/__tests__/stale-load-repair.test.ts

@@ -874,10 +874,9 @@ describe("the popup count equals the Plugins header count", () => {
 					description: "",
 					marketplace: id.split("@")[1] ?? "magus",
 					marketplaceDisplay: "",
-					enabled: true,
 					installedVersion: mine,
 					loadedVersion: loaded[id] ?? null,
-					projectScope: { enabled: true, version: mine },
+					projectScope: { installed: true, version: mine },
 				} as PluginInfo;
 			},
 		);

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

@@ -177,7 +177,14 @@ describe("scope handling", () => {
 	test("a fresh install goes to project scope only", async () => {
 		const { deps, installed } = stubDeps("2.0.0");
 		await applyPlugins(
-			[item({ action: "install", installed: null, scopes: [] })],
+			[
+				item({
+					action: "install",
+					reason: "absent",
+					installed: null,
+					scopes: [],
+				}),
+			],
 			PROJECT,
 			deps,
 		);
@@ -228,7 +235,14 @@ describe("scope handling", () => {
 	test("a fresh install runs `install`, never `update`", async () => {
 		const { deps, installed, updated } = stubDeps("2.0.0");
 		await applyPlugins(
-			[item({ action: "install", installed: null, scopes: [] })],
+			[
+				item({
+					action: "install",
+					reason: "absent",
+					installed: null,
+					scopes: [],
+				}),
+			],
 			PROJECT,
 			deps,
 		);
@@ -715,6 +729,7 @@ describe("applyPlugins — read-back against beforeVersions", () => {
 			[
 				item({
 					action: "install",
+					reason: "absent",
 					installed: null,
 					scopes: [],
 					beforeVersions: {},
@@ -733,6 +748,7 @@ describe("applyPlugins — read-back against beforeVersions", () => {
 			[
 				item({
 					action: "install",
+					reason: "absent",
 					installed: null,
 					scopes: [],
 					beforeVersions: {},