magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/models-screen-state.test.ts

@@ -0,0 +1,315 @@
+import { describe, expect, test } from "bun:test";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { DEFAULT_PRESET, findPreset } from "../data/models-presets.js";
+import type { ModelsStatus } from "../services/models-core.js";
+import { appReducer, initialState } from "../ui/state/reducer.js";
+import type { AppAction, AppState, ModelsSnapshot } from "../ui/state/types.js";
+import { asyncValue } from "../ui/state/types.js";
+
+function run(actions: AppAction[], from: AppState = initialState): AppState {
+	return actions.reduce(appReducer, from);
+}
+
+function status(over: Partial<ModelsStatus> = {}): ModelsStatus {
+	return { state: "off", preset: null, drift: [], warnings: [], ...over };
+}
+
+function snapshot(over: Partial<ModelsSnapshot> = {}): ModelsSnapshot {
+	return {
+		status: status(),
+		config: null,
+		path: "/x/.claude/models.json",
+		...over,
+	};
+}
+
+/** Drop `//` line comments and block comments, so a source guard matches code only. */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+
+/** Navigating away and back is what unmounts the screen. */
+const roundTrip: AppAction[] = [
+	{ type: "NAVIGATE", route: { screen: "plugins" } },
+	{ type: "NAVIGATE", route: { screen: "models" } },
+];
+
+describe("models screen initial state", () => {
+	test("starts idle, unfiltered, and with no message", () => {
+		expect(initialState.models.data.status).toBe("idle");
+		expect(initialState.models.searchQuery).toBe("");
+		expect(initialState.models.status).toBeNull();
+		expect(initialState.models.isApplying).toBe(false);
+		// The mate slots are not drawn until something says they can be served. Starting
+		// true would put three rows on screen before anything had been asked.
+		expect(initialState.models.matesAvailable).toBe(false);
+	});
+
+	test("the models route is reachable and NAVIGATE keeps the screen's state", () => {
+		const state = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			...roundTrip,
+		]);
+		expect(state.currentRoute.screen).toBe("models");
+		expect(state.models.data.status).toBe("success");
+	});
+});
+
+describe("models search state", () => {
+	test("appending builds up the query one character at a time", () => {
+		// The regression this guards: computing `searchQuery + char` in the screen
+		// reads a value captured at render time, so keystrokes arriving faster
+		// than React re-renders all start from the same stale string.
+		const state = run([
+			{ type: "MODELS_SEARCH_APPEND", char: "o" },
+			{ type: "MODELS_SEARCH_APPEND", char: "p" },
+			{ type: "MODELS_SEARCH_APPEND", char: "u" },
+			{ type: "MODELS_SEARCH_APPEND", char: "s" },
+		]);
+		expect(state.models.searchQuery).toBe("opus");
+	});
+
+	test("appending resets the cursor so it cannot sit past the filtered list", () => {
+		const state = run([
+			{ type: "MODELS_SELECT", index: 4 },
+			{ type: "MODELS_SEARCH_APPEND", char: "h" },
+		]);
+		expect(state.models.selectedIndex).toBe(0);
+	});
+
+	test("backspace removes one character at a time", () => {
+		const typed = run([
+			{ type: "MODELS_SEARCH_APPEND", char: "a" },
+			{ type: "MODELS_SEARCH_APPEND", char: "b" },
+			{ type: "MODELS_SEARCH_APPEND", char: "c" },
+		]);
+		expect(
+			run([{ type: "MODELS_SEARCH_BACKSPACE" }], typed).models.searchQuery,
+		).toBe("ab");
+	});
+
+	test("backspace on an empty query is harmless", () => {
+		expect(run([{ type: "MODELS_SEARCH_BACKSPACE" }]).models.searchQuery).toBe(
+			"",
+		);
+	});
+
+	test("clearing the filter is one action, and it leaves the data alone", () => {
+		const filtered = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			{ type: "MODELS_SEARCH_APPEND", char: "z" },
+		]);
+		const cleared = run([{ type: "MODELS_SET_SEARCH", query: "" }], filtered);
+		expect(cleared.models.searchQuery).toBe("");
+		expect(cleared.models.data.status).toBe("success");
+	});
+});
+
+describe("models data state", () => {
+	test("a reload keeps the last snapshot on screen", () => {
+		// Reading the routing scans session transcripts to resolve the live model
+		// id behind each alias, so a reload is not instant. Without `previous` the
+		// list blanks to "Reading…" every time — including on every tab switch,
+		// because the router unmounts the screen and the effect refetches.
+		const loaded = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot({ path: "/a" }) },
+			{ type: "MODELS_DATA_LOADING" },
+		]);
+		expect(loaded.models.data.status).toBe("loading");
+		expect(asyncValue(loaded.models.data)?.path).toBe("/a");
+	});
+
+	test("a FIRST load has nothing to carry, and says so", () => {
+		const loading = run([{ type: "MODELS_DATA_LOADING" }]);
+		expect(asyncValue(loading.models.data)).toBeUndefined();
+	});
+
+	test("success stores the whole snapshot, config included", () => {
+		const config = findPreset(DEFAULT_PRESET) ?? null;
+		const state = run([
+			{
+				type: "MODELS_DATA_SUCCESS",
+				snapshot: snapshot({
+					status: status({ state: "on", preset: DEFAULT_PRESET }),
+					config,
+				}),
+			},
+		]);
+		const value = asyncValue(state.models.data);
+		expect(value?.status.state).toBe("on");
+		expect(value?.config?.preset).toBe(DEFAULT_PRESET);
+	});
+
+	test("an error replaces the data rather than hiding behind stale rows", () => {
+		const state = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			{ type: "MODELS_DATA_ERROR", error: new Error("unreadable") },
+		]);
+		expect(state.models.data.status).toBe("error");
+		expect(asyncValue(state.models.data)).toBeUndefined();
+	});
+});
+
+describe("models status line", () => {
+	test("survives the screen unmounting, because it lives in app state", () => {
+		// `Router` swaps the component type on a tab change, so a message held in
+		// the screen's own useState is destroyed by 0 → 1 → 0 — and the message is
+		// the only record of what the last apply did.
+		const messaged = run([
+			{
+				type: "MODELS_STATUS_SET",
+				status: { text: "Routed opus-lead", tone: "success" },
+			},
+		]);
+		expect(run(roundTrip, messaged).models.status?.text).toBe(
+			"Routed opus-lead",
+		);
+	});
+
+	test("is replaced by the next message, not appended to", () => {
+		const state = run([
+			{ type: "MODELS_STATUS_SET", status: { text: "one", tone: "success" } },
+			{ type: "MODELS_STATUS_SET", status: { text: "two", tone: "error" } },
+		]);
+		expect(state.models.status).toEqual({ text: "two", tone: "error" });
+	});
+
+	test("clearing removes it", () => {
+		const state = run([
+			{ type: "MODELS_STATUS_SET", status: { text: "one", tone: "success" } },
+			{ type: "MODELS_STATUS_CLEAR" },
+		]);
+		expect(state.models.status).toBeNull();
+	});
+});
+
+describe("apply-in-flight state", () => {
+	test("survives the screen unmounting", () => {
+		// An apply rewrites the profile, re-materializes it and registers a hook.
+		// Held locally, the flag died on a tab switch and a returning user could
+		// launch a second write on top of the first.
+		const applying = run([{ type: "MODELS_APPLY_START" }]);
+		expect(applying.models.isApplying).toBe(true);
+		expect(run(roundTrip, applying).models.isApplying).toBe(true);
+	});
+
+	test("clears when the write finishes", () => {
+		expect(
+			run([{ type: "MODELS_APPLY_START" }, { type: "MODELS_APPLY_END" }]).models
+				.isApplying,
+		).toBe(false);
+	});
+});
+
+describe("the mate slots' availability", () => {
+	test("survives the screen unmounting, so the lookup happens once a session", () => {
+		// Unlike the two file reads this screen does on mount, this answer costs a
+		// marketplace resolution with network timeouts behind it. Held locally it would die
+		// on every tab switch and be paid for again on every return — for something that
+		// cannot change while the TUI is open.
+		const available = run([
+			{ type: "MODELS_MATES_AVAILABLE", available: true },
+		]);
+		expect(available.models.matesAvailable).toBe(true);
+		expect(run(roundTrip, available).models.matesAvailable).toBe(true);
+	});
+
+	test("a false answer is recorded, not treated as no answer", () => {
+		// "Not installed" and "never asked" render the same, and that is deliberate — but
+		// the reducer still has to hold the difference, or a later dispatch could not undo it.
+		const state = run([
+			{ type: "MODELS_MATES_AVAILABLE", available: true },
+			{ type: "MODELS_MATES_AVAILABLE", available: false },
+		]);
+		expect(state.models.matesAvailable).toBe(false);
+	});
+
+	test("it touches no other part of the models state", () => {
+		const before = run([
+			{ type: "MODELS_SELECT", index: 2 },
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+		]);
+		const after = run(
+			[{ type: "MODELS_MATES_AVAILABLE", available: true }],
+			before,
+		);
+		expect(after.models.selectedIndex).toBe(2);
+		expect(after.models.data).toBe(before.models.data);
+		expect(after.styles).toBe(before.styles);
+	});
+});
+
+describe("selection state", () => {
+	test("select records the index verbatim", () => {
+		expect(
+			run([{ type: "MODELS_SELECT", index: 3 }]).models.selectedIndex,
+		).toBe(3);
+	});
+
+	test("models actions touch no other screen's state", () => {
+		// One shared reducer, so a mistyped spread is a real hazard: `...state`
+		// rather than `...state.models` would wipe every other screen.
+		const before = initialState;
+		const after = run([
+			{ type: "MODELS_SELECT", index: 2 },
+			{ type: "MODELS_APPLY_START" },
+			{ type: "MODELS_SEARCH_APPEND", char: "x" },
+		]);
+		expect(after.styles).toBe(before.styles);
+		expect(after.plugins).toBe(before.plugins);
+		expect(after.skills).toBe(before.skills);
+	});
+});
+
+// ─── Keybindings ──────────────────────────────────────────────────────────────
+
+const SCREEN = join(import.meta.dir, "..", "ui", "screens", "ModelsScreen.tsx");
+
+describe("ModelsScreen keybindings", () => {
+	test("a and Enter both apply, and c clears", async () => {
+		const src = await fs.readFile(SCREEN, "utf8");
+		expect(src).toContain('event.name === "a"');
+		expect(src).toContain('event.name === "c"');
+		expect(src).toContain('event.name === "r"');
+		expect(src).toContain('event.name === "/"');
+		// Enter is the same action as `a`. There is nothing to "open" here, so
+		// binding the most obvious key to nothing would be the wrong lesson.
+		const enter = src.indexOf('event.name === "return"');
+		expect(enter).toBeGreaterThan(-1);
+		expect(src.slice(enter, enter + 400)).toContain("handleApply()");
+	});
+
+	test("digits are treated as navigation, so a message survives a tab round trip", async () => {
+		// Every digit now navigates, 0 included. Clearing the status line on the
+		// way OUT of the tab loses the message the state was changed to preserve.
+		const src = await fs.readFile(SCREEN, "utf8");
+		expect(src).toContain("/^[0-9]$/.test(event.name");
+	});
+
+	test("no screen still treats 0 as a non-navigation key", async () => {
+		// The Styles screen shipped `/^[1-9]$/` before Models existed on key 0.
+		const styles = await fs.readFile(
+			join(import.meta.dir, "..", "ui", "screens", "StylesScreen.tsx"),
+			"utf8",
+		);
+		expect(styles).not.toContain("/^[1-9]$/");
+	});
+
+	test("screen state is held in the reducer, never in useState", async () => {
+		// The rule the two "survives unmounting" tests above enforce at runtime,
+		// pinned at the source so a new piece of state cannot quietly opt out.
+		//
+		// Comments are stripped first, the way hook-import-policy.test.ts does it. The rule
+		// is about CODE, and this screen documents why each piece of its state lives in the
+		// reducer — naming the hook it is deliberately not using is the clearest way to say
+		// that, and a guard reading the prose would forbid the explanation along with the
+		// thing explained.
+		const src = stripComments(await fs.readFile(SCREEN, "utf8"));
+		expect(src).not.toContain("useState");
+		// Negative control: stripping must not have eaten the code being guarded. A guard
+		// over an empty string passes forever.
+		expect(src).toContain("useEffect");
+		expect(src).toContain("useCallback");
+	});
+});

package/src/__tests__/open-file.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { openInDefaultApp, openerFor } from "../utils/open-file.js";
+
+describe("openerFor", () => {
+	test("uses the macOS opener on darwin", () => {
+		expect(openerFor("darwin")).toEqual({ command: "open", args: [] });
+	});
+
+	test("uses xdg-open on linux", () => {
+		// magus ships a linux-x64 binary, and the pre-existing `open "${url}"`
+		// call elsewhere in the UI silently does nothing there.
+		expect(openerFor("linux")).toEqual({ command: "xdg-open", args: [] });
+	});
+
+	test("passes an empty window title to cmd start on windows", () => {
+		// `start` treats its first quoted argument as the window title, so
+		// without the empty string a quoted path is consumed as one.
+		expect(openerFor("win32")).toEqual({
+			command: "cmd",
+			args: ["/c", "start", ""],
+		});
+	});
+
+	test("falls back to xdg-open on anything else", () => {
+		expect(openerFor("freebsd").command).toBe("xdg-open");
+	});
+});
+
+describe("openInDefaultApp", () => {
+	const missingOpener = {
+		command: "magus-test-opener-that-cannot-exist",
+		args: [],
+	};
+
+	test("reports a missing opener rather than failing silently", async () => {
+		// An injected command that cannot exist, NOT a real platform's opener.
+		// The first version assumed `xdg-open` was absent — true on a Mac dev
+		// box, false on the Ubuntu CI runner, where it both failed the
+		// assertion and spawned a real opener on the build machine.
+		await expect(
+			openInDefaultApp("/tmp/whatever.md", "linux", missingOpener),
+		).rejects.toThrow(/not on PATH/);
+	});
+
+	test("settles promptly instead of hanging", async () => {
+		// The promise must settle when the child is spawned, not when the viewer
+		// is closed — waiting for exit would freeze the TUI for as long as the
+		// user's editor stayed open. Asserted on the error path so the suite
+		// never launches a real application on the developer's desktop.
+		const settled = await Promise.race([
+			openInDefaultApp("/tmp/whatever.md", "linux", missingOpener).then(
+				() => "resolved",
+				() => "rejected",
+			),
+			new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
+		]);
+		expect(settled).not.toBe("timeout");
+	});
+});

package/src/__tests__/owned-marketplaces.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Change B: our own marketplaces (magus, magus-marketing) are always listed in
+ * the plugins TUI — even when unregistered — and sorted to the top.
+ *
+ * `magus-marketing` is deliberately NOT `featured`, so before this change it was
+ * invisible until manually registered. The `owned` flag both (a) qualifies it
+ * for the plugin-manager "always include" gate and (b) sorts it first.
+ */
+import { describe, expect, it } from "bun:test";
+import {
+	defaultMarketplaces,
+	getAllMarketplaces,
+} from "../data/marketplaces.js";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+import type { Marketplace } from "../types/index.js";
+import { buildPluginBrowserItems } from "../ui/adapters/pluginsAdapter.js";
+
+describe("owned marketplaces", () => {
+	it("marks magus and magus-marketing as owned, and leaves others untouched", () => {
+		const magus = defaultMarketplaces.find((m) => m.name === "magus");
+		const marketing = defaultMarketplaces.find(
+			(m) => m.name === "magus-marketing",
+		);
+		expect(magus?.owned).toBe(true);
+		expect(marketing?.owned).toBe(true);
+		expect(
+			defaultMarketplaces.find((m) => m.name === "claude-plugins-official")
+				?.owned,
+		).toBeUndefined();
+	});
+
+	it("qualifies magus-marketing for the always-show gate without being featured", () => {
+		const marketing = defaultMarketplaces.find(
+			(m) => m.name === "magus-marketing",
+		);
+		expect(marketing).toBeDefined();
+		// The plugin-manager gate: configured || official || featured || owned.
+		const alwaysShown = !!(
+			marketing?.official ||
+			marketing?.featured ||
+			marketing?.owned
+		);
+		expect(alwaysShown).toBe(true);
+		expect(marketing?.featured).toBeUndefined(); // and NOT via featured
+	});
+
+	it("sorts owned first and deprecated last, regardless of input order", () => {
+		const mk = (name: string, extra: Partial<Marketplace>): Marketplace => ({
+			name,
+			displayName: name,
+			source: { source: "github", repo: `x/${name}` },
+			description: "",
+			...extra,
+		});
+		// Deliberately "wrong" order: official, deprecated, owned.
+		const marketplaces: Marketplace[] = [
+			mk("official-one", { official: true }),
+			mk("claude-code-plugins", { deprecated: true }),
+			mk("mine", { owned: true }),
+		];
+
+		const items = buildPluginBrowserItems({
+			marketplaces,
+			plugins: [],
+			collapsedMarketplaces: new Set(),
+		});
+
+		const order: string[] = [];
+		for (const i of items)
+			if (i.kind === "category") order.push(i.marketplace.name);
+
+		expect(order[0]).toBe("mine"); // owned first
+		expect(order[order.length - 1]).toBe("claude-code-plugins"); // deprecated last
+	});
+
+	it("preserves owned when getAllMarketplaces rebuilds a locally-cached marketplace", () => {
+		// The local-cache path reconstructs the Marketplace object; owned must
+		// survive so already-cloned magus still sorts first / always shows.
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"magus",
+				{
+					name: "Magus",
+					description: "",
+					gitRepo: "MadAppGang/magus",
+					plugins: [],
+				},
+			],
+		]);
+		const magus = getAllMarketplaces(local).find((m) => m.name === "magus");
+		expect(magus?.owned).toBe(true);
+	});
+});

package/src/__tests__/plugin-checkout.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "bun:test";
+import path from "node:path";
+import {
+	checkoutDirName,
+	checkoutPath,
+	ensureCheckout,
+} from "../services/plugin-checkout.js";
+
+/**
+ * A checkout is a read-only shallow clone magus owns, used so that browsing
+ * what a plugin contains never requires installing it and never spends the
+ * GitHub API budget (60 requests an hour, unauthenticated, shared across every
+ * repo on screen).
+ */
+describe("checkoutDirName", () => {
+	it("flattens owner/repo into one filesystem-safe segment", () => {
+		expect(checkoutDirName("addyosmani/agent-skills")).toBe(
+			"addyosmani__agent-skills",
+		);
+		expect(checkoutDirName("MadAppGang/magus")).toBe("MadAppGang__magus");
+	});
+
+	it("never yields a name containing a path separator", () => {
+		for (const repo of [
+			"a/b",
+			"../../etc/passwd",
+			"owner/repo.git",
+			"weird name/with spaces",
+		]) {
+			const name = checkoutDirName(repo);
+			expect(name).not.toContain("/");
+			expect(name).not.toContain("\\");
+			// A traversal attempt must not survive as one: `..` collapses into the
+			// same separator run as everything else, so the result cannot escape
+			// the checkout root.
+			expect(path.basename(name)).toBe(name);
+		}
+	});
+
+	it("keeps dots that are part of a real repo name", () => {
+		expect(checkoutDirName("owner/repo.js")).toBe("owner__repo.js");
+	});
+});
+
+describe("checkoutPath", () => {
+	it("puts every checkout under one root, outside Claude Code's own dirs", () => {
+		const a = checkoutPath("owner/one");
+		const b = checkoutPath("owner/two");
+
+		expect(path.dirname(a)).toBe(path.dirname(b));
+		expect(path.dirname(a)).toContain("magus-checkouts");
+		// Claude Code owns `plugins/`; a checkout must not look like installed
+		// state, or a reader could mistake it for something Claude Code loads.
+		expect(a).not.toContain(`${path.sep}plugins${path.sep}`);
+	});
+});
+
+describe("ensureCheckout", () => {
+	it("refuses to clone from a test run", async () => {
+		// Not a precaution. A test that only meant to exercise the tree-API path
+		// shallow-cloned a real GitHub repo, because stubbing `globalThis.fetch`
+		// does not stop `git`.
+		expect(process.env.NODE_ENV).toBe("test");
+		expect(await ensureCheckout("blader/humanizer")).toBeNull();
+	});
+});

package/src/__tests__/plugin-cli-argv.test.ts

@@ -0,0 +1,109 @@
+/**
+ * What `claude` subcommand does each plugin operation actually run?
+ *
+ * This file exists because the answer was wrong for a long time and nothing
+ * could see it. `updatePlugin` ran `claude plugin install`, on a comment that
+ * asserted install "handles both fresh installs and re-installs (upgrades)".
+ * It does not. Measured against Claude Code 2.1.252, with designer@magus
+ * installed at 0.6.0 and 0.6.1 published:
+ *
+ *     $ claude plugin install designer@magus --scope project
+ *     ✔ Plugin "designer@magus" is already installed (scope: project)   # exit 0
+ *
+ *     $ claude plugin update designer@magus --scope project
+ *     ✔ Plugin "designer" updated from 0.6.0 to 0.6.1 for scope project # exit 0
+ *
+ * Both exit 0. The no-op is indistinguishable from success at every layer
+ * above, so every magus update path — the TUI's `U`, "update all", the
+ * scope menu, `magus update` — reported
+ * success and changed nothing, for ever.
+ *
+ * Mocking the CLI cannot catch that: a stub answers whatever the test asks it
+ * to. Only the argv is checkable here, so the argv is what these assert, with a
+ * real `claude` shim on PATH recording what it was called with.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	chmodSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+	installPlugin,
+	repairPlugin,
+	updatePlugin,
+} from "../services/claude-cli.js";
+
+let root: string;
+let logFile: string;
+let savedPath: string | undefined;
+
+beforeEach(() => {
+	root = mkdtempSync(path.join(tmpdir(), "claude-argv-"));
+	const bin = path.join(root, "bin");
+	mkdirSync(bin);
+	logFile = path.join(root, "argv.log");
+
+	// A real executable, so this goes through which(1), execFile and the whole
+	// wrapper rather than a module double.
+	const shim = path.join(bin, "claude");
+	writeFileSync(shim, `#!/bin/sh\necho "$@" >> "${logFile}"\nexit 0\n`);
+	chmodSync(shim, 0o755);
+
+	savedPath = process.env.PATH;
+	// The shim dir goes FIRST so it shadows a real claude, but the system dirs
+	// stay: `getClaudePath` resolves through which(1), which lives in /usr/bin.
+	process.env.PATH = [bin, "/usr/bin", "/bin"].join(path.delimiter);
+});
+
+afterEach(() => {
+	process.env.PATH = savedPath ?? "";
+	rmSync(root, { recursive: true, force: true });
+});
+
+/** Every argv the shim saw, one line per invocation. */
+function calls(): string[] {
+	try {
+		return readFileSync(logFile, "utf8").trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
+describe("which claude subcommand each operation runs", () => {
+	test("updatePlugin runs `plugin update` — NOT `plugin install`", async () => {
+		await updatePlugin("designer@magus", "project");
+		expect(calls()).toEqual(["plugin update designer@magus --scope project"]);
+	});
+
+	test("installPlugin runs `plugin install`", async () => {
+		await installPlugin("designer@magus", "project");
+		expect(calls()).toEqual(["plugin install designer@magus --scope project"]);
+	});
+
+	test("repairPlugin uninstalls then installs, in that order", async () => {
+		// Content drift under an unchanged version: `update` has no version bump
+		// to act on and `install` answers "already installed", so only the
+		// uninstall+install pair re-copies the files.
+		await repairPlugin("designer@magus", "project", root);
+		expect(calls()).toEqual([
+			"plugin uninstall designer@magus --scope project",
+			"plugin install designer@magus --scope project",
+		]);
+	});
+
+	test("the scope reaches the CLI verbatim, at every scope", async () => {
+		await updatePlugin("dev@magus", "user");
+		await updatePlugin("dev@magus", "local");
+		expect(calls()).toEqual([
+			"plugin update dev@magus --scope user",
+			"plugin update dev@magus --scope local",
+		]);
+	});
+});