magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/blackbox-parity.test.ts

@@ -0,0 +1,725 @@
+/**
+ * BLACK-BOX parity test (R7 / R2 / R3). Written from requirements.md and the
+ * architecture §7/§8 contracts only — no implementation bodies were read.
+ *
+ * ONE fixture (catalog + registry-derived installed versions + profile pins +
+ * tool facts) is fed through the CLI planning path (`planPluginUpdates`,
+ * `planBinUpdates`) and the TUI state path (`classifyPluginRows` →
+ * `buildPluginBrowserItems` → `pluginRowText`; `specForCatalogTool` →
+ * `buildToolRow`). For every shared id the state and the reason string must be
+ * identical.
+ *
+ * Real values: the 5 `claude-plugins-official` rows carry the registry versions
+ * read (read-only) from ~/.claude/plugins/installed_plugins.json for project
+ * /Users/jack/mag/claudish on 2026-09-12; the 17 declared plugins are the real
+ * /Users/jack/mag/claudish/.claude/profiles.json `default` profile; tmux,
+ * browser-use and mcp facts are validation/baseline-tools.md. Rows marked
+ * _synthetic exist only to reach states the real data lacks.
+ */
+import { describe, expect, test } from "bun:test";
+import { cliTools } from "../data/cli-tools.js";
+import { selectProfileId } from "../services/active-closure.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import { resolveProfile } from "../services/resolver.js";
+import { type ToolFacts, specForCatalogTool } from "../services/tool-probe.js";
+import {
+	type BinUpdateItem,
+	type PluginUpdateItem,
+	classifyPluginRows,
+	countPluginStates,
+	planBinUpdates,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import type {
+	BinRequirement,
+	Marketplace,
+	ProfileManifest,
+	ResolvedClosure,
+} from "../types/index.js";
+import { buildToolRow } from "../ui/adapters/cliToolsAdapter.js";
+import {
+	type PluginPluginItem,
+	buildPluginBrowserItems,
+} from "../ui/adapters/pluginsAdapter.js";
+import { pluginRowText } from "../ui/renderers/pluginRowText.js";
+
+// ── fixture ────────────────────────────────────────────────────────────────
+
+const OFFICIAL = "claude-plugins-official";
+
+/** Real registry versions (project scope, /Users/jack/mag/claudish). Catalog publishes none. */
+const REAL_OFFICIAL: Record<string, string> = {
+	[`code-review@${OFFICIAL}`]: "3ea32df27be7",
+	[`code-simplifier@${OFFICIAL}`]: "1.0.0",
+	[`explanatory-output-style@${OFFICIAL}`]: "1.0.0",
+	[`playground@${OFFICIAL}`]: "3b600518a637",
+	[`skill-creator@${OFFICIAL}`]: "517b2fcd1b60",
+};
+
+const NO_PUBLISHED_VERSION_NOTE =
+	"its marketplace publishes no version for this plugin, so there is nothing to compare";
+
+function marketplace(
+	name: string,
+	extra: Partial<Marketplace> = {},
+): Marketplace {
+	return {
+		name,
+		displayName: name,
+		source: { source: "github", repo: `example/${name}` },
+		description: "",
+		...extra,
+	};
+}
+
+function makeMarketplaces(): Marketplace[] {
+	return [
+		marketplace(OFFICIAL, { official: true }),
+		marketplace("magus", { owned: true }),
+		marketplace("magus-marketing", { owned: true }),
+	];
+}
+
+function row(
+	id: string,
+	catalogVersion: string | null,
+	installed: string | null,
+	extra: Partial<PluginInfo> = {},
+): PluginInfo {
+	const at = id.indexOf("@");
+	const name = id.slice(0, at);
+	const mp = id.slice(at + 1);
+	return {
+		id,
+		name,
+		version: catalogVersion,
+		description: "",
+		marketplace: mp,
+		marketplaceDisplay: mp,
+		enabled: installed !== null,
+		...(installed !== null
+			? {
+					installedVersion: installed,
+					projectScope: { enabled: true, version: installed },
+				}
+			: {}),
+		...extra,
+	};
+}
+
+function makeCatalog(): PluginInfo[] {
+	return [
+		// the 5 real unversioned official plugins
+		...Object.entries(REAL_OFFICIAL).map(([id, v]) => row(id, null, v)),
+		row(`typescript-lsp@${OFFICIAL}`, "1.0.0", "1.0.0"),
+		// _synthetic: the real "0.0.0" registry value, unversioned in the catalog
+		row(`zero-version@${OFFICIAL}`, null, "0.0.0"),
+		// real magus ids from the profile
+		row("browser-use@magus", "1.4.0", "1.4.0"),
+		row("designer@magus", "2.0.0", "1.5.0"),
+		row("code-analysis@magus", "3.1.0", "3.1.0"),
+		row("multimodel@magus", "2.2.0", "2.2.0"),
+		row("dev@magus", "7.4.0", "7.4.0"),
+		row("terminal@magus", "1.3.0", "1.3.0"),
+		row("madbench@magus", "1.0.0", "1.0.0", { contentStale: true }),
+		row("claudish@magus", "2.0.0", "2.0.0", {
+			updateCheckFailed: true,
+			catalogSource: "local-clone",
+		}),
+		row("mnemex@magus", "1.2.0", "1.2.0"),
+		row("bunjs@magus", "0.4.4", null),
+		row("setup@magus", "1.0.0", "1.0.0"),
+		// _synthetic orphans
+		row("seo@magus", null, "1.0.0", {
+			isOrphaned: true,
+		}),
+		row("legacy-tool@magus", null, "0.5.0", { isOrphaned: true }),
+		row("seo@magus-marketing", "1.1.0", null),
+		// _synthetic exact pins
+		row("pinned-behind@magus", "2.1.0", "2.0.0"),
+		row("pinned-unorderable@magus", "1.0.0", "3ea32df27be7"),
+		row("pinned-undeliverable@magus", "3.0.0", "1.0.0"),
+		// _synthetic TUI-only rows
+		row("installed-undeclared@magus", "1.0.0", "1.0.0"),
+		row("enabled-only@magus", "1.0.0", null, {
+			enabled: true,
+			userScope: { enabled: true },
+		}),
+		row("browse-only@magus", "1.0.0", null),
+	];
+}
+
+const REAL_PROFILE_PLUGINS = [
+	`code-review@${OFFICIAL}`,
+	`code-simplifier@${OFFICIAL}`,
+	`explanatory-output-style@${OFFICIAL}`,
+	`playground@${OFFICIAL}`,
+	`typescript-lsp@${OFFICIAL}`,
+	`skill-creator@${OFFICIAL}`,
+	"browser-use@magus",
+	"designer@magus",
+	"code-analysis@magus",
+	"multimodel@magus",
+	"dev@magus",
+	"terminal@magus",
+	"madbench@magus",
+	"claudish@magus",
+	"mnemex@magus",
+	"bunjs@magus",
+	"setup@magus",
+];
+
+function makeManifest(): ProfileManifest {
+	const plugins: Record<string, string> = {};
+	for (const id of REAL_PROFILE_PLUGINS) plugins[id] = "latest";
+	Object.assign(plugins, {
+		[`zero-version@${OFFICIAL}`]: "latest",
+		"seo@magus": "latest",
+		"legacy-tool@magus": "latest",
+		"gone@magus": "latest", // CLI-only: not in the catalog at all
+		"pinned-behind@magus": "2.1.0",
+		"pinned-unorderable@magus": "1.0.0",
+		"pinned-undeliverable@magus": "1.0.0",
+	});
+	return {
+		version: 2,
+		profiles: {
+			default: {
+				name: "Default",
+				plugins,
+				cliTools: {
+					claudish: "latest",
+					mnemex: "1.0.0",
+					crush: "latest",
+					codex: "latest",
+					gemini: "latest",
+					qwen: "latest",
+				},
+			},
+			other: { name: "Other", plugins: { "dev@magus": "latest" } },
+		},
+	};
+}
+
+const PLUGIN_BINS: Record<string, BinRequirement[]> = {
+	"terminal@magus": [
+		{ name: "tmux", via: "brew", check: "tmux -V" },
+		{
+			name: "tmux-mcp",
+			via: "go",
+			module: "github.com/MadAppGang/tmux-mcp/v2",
+			version: "v2.0.0",
+		},
+	],
+	"browser-use@magus": [
+		{ name: "browser-use", via: "pip" },
+		{ name: "mcp", via: "pip" },
+	],
+};
+
+async function fixtureBins(pluginId: string): Promise<BinRequirement[]> {
+	return (PLUGIN_BINS[pluginId] ?? []).map((b) => ({ ...b }));
+}
+
+function facts(name: string, over: Partial<ToolFacts>): ToolFacts {
+	return {
+		name,
+		present: true,
+		resolvedPath: `/usr/local/bin/${name}`,
+		installed: null,
+		latest: null,
+		behind: null,
+		managed: true,
+		sources: ["path"],
+		...over,
+	};
+}
+
+function makeFacts(): ToolFacts[] {
+	return [
+		// baseline-tools.md: brew outdated tmux → [], tmux 3.7c
+		facts("tmux", {
+			resolvedPath: "/opt/homebrew/Cellar/tmux/3.7c/bin/tmux",
+			installed: "3.7c",
+			behind: false,
+			sources: ["path", "brew"],
+		}),
+		// baseline-tools.md: absent from `uv tool list --outdated`
+		facts("browser-use", {
+			resolvedPath:
+				"/Users/jack/.local/share/uv/tools/browser-use/bin/browser-use",
+			installed: "0.13.10",
+			behind: false,
+			sources: ["path", "uv"],
+		}),
+		facts("mcp", {
+			resolvedPath: "/Users/jack/.local/share/uv/tools/mcp/bin/mcp",
+			installed: "2.2.0",
+			behind: false,
+			sources: ["path", "uv"],
+		}),
+		facts("tmux-mcp", {
+			resolvedPath: "/Users/jack/go/bin/tmux-mcp",
+			installed: "v2.0.0",
+			sources: ["path", "go-buildinfo"],
+		}),
+		facts("claudish", {
+			resolvedPath:
+				"/Users/jack/.bun/install/global/node_modules/claudish/dist/index.js",
+			installed: "9.3.0",
+			latest: "9.3.0",
+			sources: ["path", "bun-global", "npm-registry"],
+		}),
+		facts("mnemex", {
+			resolvedPath:
+				"/Users/jack/.bun/install/global/node_modules/mnemex/dist/index.js",
+			installed: "0.9.0",
+			latest: "1.2.0",
+			sources: ["path", "bun-global", "npm-registry"],
+		}),
+		facts("crush", {
+			resolvedPath:
+				"/Users/jack/.nvm/versions/node/v22.14.0/lib/node_modules/@charmland/crush/bin/crush",
+			installed: "0.7.0",
+			latest: "0.8.0",
+			managed: false,
+			sources: ["path", "npm-registry"],
+		}),
+		facts("codex", {
+			installed: "0.40.0",
+			latest: "0.41.0",
+			sources: ["path", "npm-global", "npm-registry"],
+		}),
+		facts("gemini", {
+			installed: "0.5.0",
+			latest: null,
+			behind: null,
+			failure: "timed out after 8s",
+			sources: ["path", "npm-global"],
+		}),
+		facts("qwen", {
+			present: false,
+			resolvedPath: null,
+			installed: null,
+			latest: "0.1.0",
+			managed: null,
+			sources: ["npm-registry"],
+		}),
+	];
+}
+
+// ── the two paths ──────────────────────────────────────────────────────────
+
+interface Paths {
+	closure: ResolvedClosure;
+	cliPlugins: Map<string, PluginUpdateItem>;
+	tuiRows: Map<string, PluginPluginItem>;
+	sharedPluginIds: string[];
+	cliBins: Map<string, BinUpdateItem>;
+	tuiTools: Map<string, ReturnType<typeof buildToolRow>>;
+	sharedToolNames: string[];
+	catalog: PluginInfo[];
+}
+
+async function runBothPaths(): Promise<Paths> {
+	const manifest = makeManifest();
+	const catalog = makeCatalog();
+	const profileId = selectProfileId(
+		Object.keys(manifest.profiles),
+		undefined,
+		"default",
+	);
+	if (profileId === null) throw new Error("fixture: no profile selected");
+	const closure = await resolveProfile(manifest, profileId, {
+		binResolver: fixtureBins,
+	});
+
+	// CLI path
+	const cliPluginList = planPluginUpdates(
+		closure.plugins,
+		new Map(catalog.map((p) => [p.id, p])),
+	);
+	const cliPlugins = new Map(cliPluginList.map((i) => [i.pluginId, i]));
+
+	// TUI path
+	const statuses = classifyPluginRows(catalog, closure.plugins);
+	const items = buildPluginBrowserItems({
+		marketplaces: makeMarketplaces(),
+		plugins: catalog,
+		collapsedMarketplaces: new Set(),
+		statuses,
+	});
+	const tuiRows = new Map<string, PluginPluginItem>();
+	for (const it of items) {
+		if (it.kind === "plugin") tuiRows.set(it.plugin.id, it);
+	}
+
+	const sharedPluginIds = [...cliPlugins.keys()]
+		.filter((id) => tuiRows.has(id))
+		.sort();
+
+	// tools
+	const factList = makeFacts();
+	const cliBins = new Map(
+		planBinUpdates(closure.bins, factList).map((b) => [b.name, b]),
+	);
+	const factsByName = new Map(factList.map((f) => [f.name, f]));
+	const declared = new Set(closure.bins.map((b) => b.name));
+	const tuiTools = new Map<string, ReturnType<typeof buildToolRow>>();
+	for (const tool of cliTools) {
+		if (!declared.has(tool.name)) continue;
+		tuiTools.set(
+			tool.name,
+			buildToolRow(
+				tool,
+				specForCatalogTool(tool, closure.bins, undefined),
+				factsByName.get(tool.name),
+			),
+		);
+	}
+	const sharedToolNames = [...tuiTools.keys()]
+		.filter((n) => cliBins.has(n))
+		.sort();
+
+	return {
+		closure,
+		cliPlugins,
+		tuiRows,
+		sharedPluginIds,
+		cliBins,
+		tuiTools,
+		sharedToolNames,
+		catalog,
+	};
+}
+
+function pickPlugin(i: PluginUpdateItem | null | undefined) {
+	if (!i) return i;
+	return { action: i.action, reason: i.reason, note: i.note, target: i.target };
+}
+
+// ── assertions ─────────────────────────────────────────────────────────────
+
+describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
+	test("the intersections are non-vacuous and include every reported official plugin", async () => {
+		const p = await runBothPaths();
+
+		expect(p.sharedPluginIds.length).toBeGreaterThanOrEqual(8);
+		for (const id of Object.keys(REAL_OFFICIAL)) {
+			expect(p.sharedPluginIds).toContain(id);
+		}
+		expect(p.sharedPluginIds).toContain(`zero-version@${OFFICIAL}`);
+		expect(p.sharedToolNames.length).toBeGreaterThanOrEqual(3);
+	});
+
+	test("every shared plugin has the same action, reason, note and target in both front ends", async () => {
+		const p = await runBothPaths();
+
+		for (const id of p.sharedPluginIds) {
+			const cli = p.cliPlugins.get(id);
+			const tui = p.tuiRows.get(id)?.status;
+			expect({ id, s: pickPlugin(tui) }).toEqual({ id, s: pickPlugin(cli) });
+		}
+	});
+
+	test("every non-current shared plugin row renders non-empty text containing the CLI note verbatim", async () => {
+		const p = await runBothPaths();
+
+		for (const id of p.sharedPluginIds) {
+			const cli = p.cliPlugins.get(id);
+			if (!cli || cli.action === "current") continue;
+			const row = p.tuiRows.get(id);
+			if (!row) throw new Error(`no TUI row for ${id}`);
+			const { text } = pluginRowText(row);
+			expect({ id, empty: text.trim() === "" }).toEqual({ id, empty: false });
+			if (cli.note) {
+				expect({ id, containsNote: text.includes(cli.note) }).toEqual({
+					id,
+					containsNote: true,
+				});
+			}
+		}
+	});
+
+	// These 5 are CURRENT now, not unknown: their marketplace publishes no
+	// version, so there is nothing newer to be behind. R7 is unchanged and is
+	// still what this asserts — the two front ends must give the same answer,
+	// whatever that answer is. The reason code survives so the WHY is still
+	// recorded; the note does not, because nothing here is actionable.
+	test("the 5 official plugins get the same verdict on both paths", async () => {
+		const p = await runBothPaths();
+
+		for (const id of Object.keys(REAL_OFFICIAL)) {
+			const cli = p.cliPlugins.get(id);
+			const tui = p.tuiRows.get(id)?.status;
+			expect({ id, action: cli?.action, reason: cli?.reason }).toEqual({
+				id,
+				action: "current",
+				reason: "no-published-version",
+			});
+			// Parity, the point of the file: same note (none), same rendered row.
+			expect(tui?.note).toBe(cli?.note);
+			expect(cli?.note).toBeUndefined();
+			const row = p.tuiRows.get(id);
+			if (!row) throw new Error(`no TUI row for ${id}`);
+			expect(pluginRowText(row).text).not.toContain(NO_PUBLISHED_VERSION_NOTE);
+		}
+	});
+
+	test("each fixture row has its expected state on both paths", async () => {
+		const p = await runBothPaths();
+		const expected: Record<
+			string,
+			{ action: string; reason?: string; target?: string | null }
+		> = {
+			// No published version to be behind → current. The reason still records
+			// that the verdict came from an absent catalog version, not a match.
+			[`zero-version@${OFFICIAL}`]: {
+				action: "current",
+				reason: "no-published-version",
+			},
+			[`typescript-lsp@${OFFICIAL}`]: {
+				action: "current",
+				reason: "up-to-date",
+			},
+			"browser-use@magus": { action: "current", reason: "up-to-date" },
+			"dev@magus": { action: "current", reason: "up-to-date" },
+			"designer@magus": { action: "update", reason: "behind", target: "2.0.0" },
+			"bunjs@magus": { action: "install", reason: "absent" },
+			"madbench@magus": { action: "repair", reason: "content-stale" },
+			"claudish@magus": {
+				action: "unknown",
+				reason: "catalog-unverified",
+				target: null,
+			},
+			// Was `moved`, which guessed a destination from a bare name match and
+			// could not tell a move from a dual publication. An orphan is simply
+			// not offered.
+			"seo@magus": { action: "unknown", reason: "not-offered", target: null },
+			"legacy-tool@magus": {
+				action: "unknown",
+				reason: "not-offered",
+				target: null,
+			},
+			"pinned-behind@magus": {
+				action: "update",
+				reason: "behind",
+				target: "2.1.0",
+			},
+			// `unorderable` is gone: when two versions cannot be ordered we assume
+			// the install is the latest rather than raising a warning no action
+			// can clear.
+			"pinned-unorderable@magus": { action: "current" },
+		};
+
+		for (const [id, want] of Object.entries(expected)) {
+			for (const [side, item] of [
+				["cli", p.cliPlugins.get(id)],
+				["tui", p.tuiRows.get(id)?.status],
+			] as const) {
+				const got: Record<string, unknown> = { id, side, action: item?.action };
+				const exp: Record<string, unknown> = { id, side, action: want.action };
+				if (want.reason !== undefined) {
+					got.reason = item?.reason;
+					exp.reason = want.reason;
+				}
+				if (want.target !== undefined) {
+					got.target = item?.target;
+					exp.target = want.target;
+				}
+				expect(got).toEqual(exp);
+			}
+		}
+
+		const undeliverable = p.cliPlugins.get("pinned-undeliverable@magus");
+		expect(undeliverable?.reason).toBe("pin-undeliverable");
+		expect(["current", "update"]).toContain(undeliverable?.action ?? "");
+		expect(undeliverable?.note).toBeTruthy();
+
+		// declared but absent from the catalog: a CLI item, never a TUI row
+		expect(p.cliPlugins.get("gone@magus")?.action).toBe("unknown");
+		expect(p.tuiRows.has("gone@magus")).toBe(false);
+	});
+
+	test("TUI-only rows: installed or enabled rows get a status, browse-only rows get none", async () => {
+		const p = await runBothPaths();
+
+		expect(p.tuiRows.get("installed-undeclared@magus")?.status?.action).toBe(
+			"current",
+		);
+		const enabledOnly = p.tuiRows.get("enabled-only@magus")?.status;
+		expect({
+			action: enabledOnly?.action,
+			reason: enabledOnly?.reason,
+		}).toEqual({
+			action: "install",
+			reason: "enabled-not-installed",
+		});
+		const enabledRow = p.tuiRows.get("enabled-only@magus");
+		if (!enabledRow) throw new Error("no enabled-only row");
+		expect(pluginRowText(enabledRow).text).not.toContain("profile declares it");
+		expect(p.tuiRows.get("browse-only@magus")?.status).toBeNull();
+		expect(p.tuiRows.get("seo@magus-marketing")?.status).toBeNull();
+	});
+
+	test("per-state counts over the shared set are equal on both paths and match the fixture", async () => {
+		const p = await runBothPaths();
+		const cliItems = p.sharedPluginIds.map(
+			(id) => p.cliPlugins.get(id) as PluginUpdateItem,
+		);
+		const tuiItems = p.sharedPluginIds.map(
+			(id) => p.tuiRows.get(id)?.status as PluginUpdateItem,
+		);
+
+		const cliCounts = countPluginStates(cliItems);
+		expect(countPluginStates(tuiItems)).toEqual(cliCounts);
+		expect(cliCounts.install).toBe(1); // bunjs
+		expect(cliCounts.repair).toBe(1); // madbench
+		// Was 10. Seven of those rows are `current` now, and each for the same
+		// reason: nothing could be compared, so nothing is known to be behind.
+		//   − 5 official  (marketplace publishes no version)
+		//   − zero-version  (installed "0.0.0", no published version)
+		//   − pinned-unorderable  (sha install against a semver pin)
+		// What is left is unknown because something is genuinely wrong or unread:
+		//   claudish        catalog-unverified — the check itself failed
+		//   seo@magus       not-offered — an orphan
+		//   legacy-tool     not-offered — an orphan
+		expect(cliCounts.unknown).toBe(3);
+		expect(cliCounts.update).toBeGreaterThanOrEqual(2); // designer, pinned-behind
+	});
+
+	test("every shared tool has the same state, reason, note and target in both front ends", async () => {
+		const p = await runBothPaths();
+
+		for (const name of p.sharedToolNames) {
+			const cli = p.cliBins.get(name);
+			const tui = p.tuiTools.get(name);
+			expect({ name, checking: tui?.checking }).toEqual({
+				name,
+				checking: false,
+			});
+			expect({
+				name,
+				state: tui?.status?.state,
+				reason: tui?.status?.reason,
+				note: tui?.status?.note,
+				target: tui?.status?.target,
+			}).toEqual({
+				name,
+				state: cli?.action,
+				reason: cli?.reason,
+				note: cli?.note,
+				target: cli?.target,
+			});
+			// the TUI judges a declared tool against the closure's own spec
+			const declared = p.closure.bins.find((b) => b.name === name);
+			expect({ name, via: tui?.spec.via, version: tui?.spec.version }).toEqual({
+				name,
+				via: declared?.via,
+				version: declared?.version,
+			});
+		}
+	});
+
+	test("each fixture tool has its expected state; the user's looping trio is current", async () => {
+		const p = await runBothPaths();
+		const expected: Record<
+			string,
+			{ action: string; reason?: string; target?: string }
+		> = {
+			tmux: { action: "current" },
+			"browser-use": { action: "current" },
+			mcp: { action: "current" },
+			"tmux-mcp": { action: "current", reason: "at-pin" },
+			claudish: { action: "current" },
+			mnemex: { action: "upgrade", reason: "behind-pin", target: "1.0.0" },
+			codex: { action: "upgrade", reason: "behind", target: "0.41.0" },
+			gemini: { action: "unknown" },
+			qwen: { action: "install", reason: "absent" },
+		};
+
+		for (const [name, want] of Object.entries(expected)) {
+			const item = p.cliBins.get(name);
+			const got: Record<string, unknown> = { name, action: item?.action };
+			const exp: Record<string, unknown> = { name, action: want.action };
+			if (want.reason) {
+				got.reason = item?.reason;
+				exp.reason = want.reason;
+			}
+			if (want.target) {
+				got.target = item?.target;
+				exp.target = want.target;
+			}
+			expect(got).toEqual(exp);
+		}
+
+		const crush = p.cliBins.get("crush");
+		expect(crush?.reason).toBe("not-managed");
+		expect(crush?.action).not.toBe("upgrade");
+		expect(p.cliBins.get("gemini")?.note).toBeTruthy();
+	});
+
+	test("planning the same fixture twice yields identical plans", async () => {
+		const a = await runBothPaths();
+		const b = await runBothPaths();
+
+		expect([...b.cliPlugins.values()]).toEqual([...a.cliPlugins.values()]);
+		expect([...b.cliBins.values()]).toEqual([...a.cliBins.values()]);
+	});
+});
+
+describe("fixture discriminates the pre-change logic", () => {
+	/** requirements.md, root causes: `present ? (bin.version ? "current" : "upgrade") : "install"`. */
+	function legacyPlanBin(present: boolean, pinned: boolean): string {
+		return present ? (pinned ? "current" : "upgrade") : "install";
+	}
+
+	/** Pre-change TUI row state from the PluginInfo flags alone (requirements: "reads hasUpdate / updateCheckFailed"). */
+	function legacyFlagState(info: PluginInfo): string {
+		if (info.updateCheckFailed) return "unknown";
+		if (info.hasUpdate) return "update";
+		return "healthy";
+	}
+
+	test("legacy bin rule upgrades tmux, browser-use and mcp on every run; the new plan says current", async () => {
+		const p = await runBothPaths();
+
+		for (const name of ["tmux", "browser-use", "mcp"]) {
+			const spec = p.closure.bins.find((b) => b.name === name);
+			expect(legacyPlanBin(true, Boolean(spec?.version))).toBe("upgrade");
+			expect(p.cliBins.get(name)?.action).toBe("current");
+		}
+	});
+
+	// The fixture must still tell the two designs apart, or every test above it
+	// could pass against the old flag-derived logic and prove nothing.
+	//
+	// It no longer discriminates on the UNVERSIONED rows: both call them
+	// healthy/current. That is a real narrowing and it is stated rather than
+	// hidden — the surviving difference there is that the classifier records WHY
+	// (`no-published-version`) while the flags carry no reason at all.
+	test("flag-derived state cannot reach the states the classifier does", async () => {
+		const p = await runBothPaths();
+
+		// Same verdict, different information: the flags have no reason field.
+		for (const id of [
+			...Object.keys(REAL_OFFICIAL),
+			`zero-version@${OFFICIAL}`,
+		]) {
+			const info = p.catalog.find((c) => c.id === id) as PluginInfo;
+			expect(legacyFlagState(info)).toBe("healthy");
+			expect(p.tuiRows.get(id)?.status?.action).toBe("current");
+			expect(p.tuiRows.get(id)?.status?.reason).toBe("no-published-version");
+		}
+
+		// Where they still disagree outright: an orphan carries neither
+		// `hasUpdate` nor `updateCheckFailed`, so the flags call it healthy while
+		// the classifier says no marketplace offers it at all.
+		for (const id of ["seo@magus", "legacy-tool@magus"]) {
+			const info = p.catalog.find((c) => c.id === id) as PluginInfo;
+			expect(legacyFlagState(info)).toBe("healthy");
+			expect(p.tuiRows.get(id)?.status?.action).toBe("unknown");
+			expect(p.tuiRows.get(id)?.status?.reason).toBe("not-offered");
+		}
+	});
+});