claudeup 6.5.1 → 6.7.1

package/src/__tests__/models-presets-marketplace.test.ts

@@ -0,0 +1,141 @@
+/**
+ * The agent tier table is keyed by agent id, and nothing else checks those ids.
+ *
+ * `DEFAULT_AGENT_GRADES` in `data/models-presets.ts` names
+ * agents as `plugin:name`. A rename in the marketplace (`code-search:analyze` →
+ * something else, `dev:synthesizer` → `dev:aggregator`) breaks the key with no signal: the
+ * renamed agent silently falls to the preset's fallback, and the stale key routes nothing.
+ * This test reads the marketplace source tree beside this repo and fails on either drift.
+ *
+ * Two directions:
+ *   (a) every preset key names an agent that exists (or is a Claude Code built-in);
+ *   (b) every marketplace agent is classified — in the tier table, in the frontmatter map,
+ *       a vision agent, or explicitly left to the fallback in FALLBACK_BY_DESIGN below.
+ *       Absence is a legitimate routing choice (fallback = `normal`), but it must be a
+ *       choice: a new agent fails here until someone decides.
+ */
+import { describe, expect, test } from "bun:test";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { DEFAULT_AGENT_GRADES, VISION_AGENTS } from "../data/models-presets.js";
+import { PREDEFINED_PROFILES } from "../data/predefined-profiles.js";
+
+const REPO = resolve(import.meta.dir, "..", "..", "..", "..");
+const MARKETPLACE = join(REPO, ".claude-plugin", "marketplace.json");
+const inMagusSrc = existsSync(MARKETPLACE) && existsSync(join(REPO, "plugins"));
+
+/** Claude Code's own agents: not in any marketplace, addressed by bare name. */
+const BUILT_IN = new Set([
+	"Explore",
+	"Plan",
+	"general-purpose",
+	"statusline-setup",
+	"claude-code-guide",
+]);
+
+/**
+ * Marketplace agents deliberately left to the preset's `fallback` grade. Each entry is a
+ * decision, not an omission: remove the line when the agent gets a tier. A NEW agent is not
+ * on this list, so adding one to the marketplace fails (b) until it is placed somewhere.
+ */
+const FALLBACK_BY_DESIGN = new Set([
+	"dev:developer",
+	"dev:devops",
+	"dev:frontend-developer",
+	"dev:researcher",
+	"dev:qa-engineer",
+	"madbench:bench",
+	"video-editing:timeline-builder",
+	"video-editing:transcriber",
+	"video-editing:video-processor",
+]);
+
+interface MarketplaceAgent {
+	id: string;
+	file: string;
+	frontmatterModel: string | undefined;
+}
+
+/** Every `plugins/<p>/agents/*.md` of every plugin the marketplace lists, by frontmatter name. */
+function marketplaceAgents(): MarketplaceAgent[] {
+	const manifest = JSON.parse(readFileSync(MARKETPLACE, "utf8")) as {
+		plugins: { name: string; source: string }[];
+	};
+	const out: MarketplaceAgent[] = [];
+	for (const plugin of manifest.plugins) {
+		const agentsDir = join(REPO, plugin.source, "agents");
+		if (!existsSync(agentsDir)) continue;
+		for (const entry of readdirSync(agentsDir)) {
+			if (!entry.endsWith(".md")) continue;
+			const file = join(agentsDir, entry);
+			const text = readFileSync(file, "utf8");
+			const fm = text.match(/^---\n([\s\S]*?)\n---/);
+			if (!fm) continue;
+			const name = fm[1].match(/^name:\s*(.+?)\s*$/m)?.[1];
+			if (!name) continue;
+			const model = fm[1].match(/^model:\s*(.+?)\s*$/m)?.[1];
+			out.push({
+				id: `${plugin.name}:${name}`,
+				file: join(plugin.source, "agents", entry),
+				frontmatterModel: model,
+			});
+		}
+	}
+	return out;
+}
+
+describe.skipIf(!inMagusSrc)(
+	"models-presets agent ids track the marketplace",
+	() => {
+		const agents = marketplaceAgents();
+		const ids = new Set(agents.map((a) => a.id));
+		const presetKeys = [...Object.keys(DEFAULT_AGENT_GRADES)];
+
+		test("reads a non-trivial marketplace", () => {
+			expect(agents.length).toBeGreaterThan(10);
+		});
+
+		test("(a) every preset key names an existing agent or a built-in", () => {
+			const dead = presetKeys.filter((k) => !BUILT_IN.has(k) && !ids.has(k));
+			expect(dead).toEqual([]);
+		});
+
+		test("(b) every marketplace agent is classified somewhere", () => {
+			const classified = new Set<string>([
+				...presetKeys,
+				...VISION_AGENTS,
+				...FALLBACK_BY_DESIGN,
+			]);
+			const unplaced = agents
+				.filter((a) => !classified.has(a.id))
+				.map((a) => a.id);
+			expect(unplaced).toEqual([]);
+		});
+
+		test("FALLBACK_BY_DESIGN and VISION_AGENTS name agents that still exist", () => {
+			const stale = [...FALLBACK_BY_DESIGN, ...VISION_AGENTS].filter(
+				(k) => !ids.has(k),
+			);
+			expect(stale).toEqual([]);
+		});
+
+		// A profile's magusPlugins is an install list, not documentation: resolver.ts expands
+		// each entry to `<name>@<marketplace>: latest`. A plugin rename moves under it silently,
+		// which is how 13.0.0's code-analysis -> code-search rename left six profiles installing
+		// a plugin the marketplace no longer lists. The agent checks above never read this array.
+		test("(d) every predefined profile names plugins the marketplace still lists", () => {
+			const marketplace = JSON.parse(readFileSync(MARKETPLACE, "utf8")) as {
+				plugins: { name: string }[];
+			};
+			const known = new Set(marketplace.plugins.map((p) => p.name));
+			const dead: string[] = [];
+			for (const profile of PREDEFINED_PROFILES) {
+				for (const entry of profile.magusPlugins ?? []) {
+					const name = entry.split("@")[0];
+					if (!known.has(name)) dead.push(`${profile.id}: ${entry}`);
+				}
+			}
+			expect(dead).toEqual([]);
+		});
+	},
+);

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

@@ -15,7 +15,7 @@
  *
  * Both exit 0. The no-op is indistinguishable from success at every layer
  * above, so every claudeup update path — the TUI's `U`, "update all", the
- * scope menu, `claudeup update`, the prerunner's auto-update — reported
+ * scope menu, `claudeup update` — reported
  * success and changed nothing, for ever.
  *
  * Mocking the CLI cannot catch that: a stub answers whatever the test asks it

package/src/__tests__/plugin-manager-fallback.test.ts

@@ -83,7 +83,7 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
 				"magus",
 				buildLocalMarketplace("magus", [
 					{
-						name: "code-analysis",
+						name: "code-search",
 						version: "5.3.0",
 						description: "Codebase investigation tools",
 						category: "development",
@@ -108,12 +108,10 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
 
 		expect(resolved.plugins).toHaveLength(2);
 		expect(resolved.plugins.map((p) => p.name).sort()).toEqual([
-			"code-analysis",
+			"code-search",
 			"dev",
 		]);
-		const codeAnalysis = resolved.plugins.find(
-			(p) => p.name === "code-analysis",
-		);
+		const codeAnalysis = resolved.plugins.find((p) => p.name === "code-search");
 		expect(codeAnalysis?.version).toBe("5.3.0");
 		expect(codeAnalysis?.description).toBe("Codebase investigation tools");
 		expect(codeAnalysis?.category).toBe("development");

package/src/__tests__/plugin-row-text.test.ts

@@ -0,0 +1,336 @@
+import { describe, expect, test } from "bun:test";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import {
+	type PluginUpdateItem,
+	classifyPluginRows,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import type { Marketplace } from "../types/index.js";
+import {
+	type PluginPluginItem,
+	buildPluginBrowserItems,
+} from "../ui/adapters/pluginsAdapter.js";
+import { pluginRowText } from "../ui/renderers/pluginRowText.js";
+import { pluginStatusText } from "../ui/renderers/pluginStatusText.js";
+
+/**
+ * `pluginRowText` is exactly what a Plugins row prints after the name, in
+ * every branch of `pluginRow` — selected, unselected, orphan. So asserting on
+ * it asserts on the screen.
+ *
+ * Rows here are built the way the screen builds them: `classifyPluginRows` over
+ * the plugin list and the profile's pins, then `buildPluginBrowserItems`. The
+ * note each row must contain is taken from `planPluginUpdates` — the CLI's own
+ * answer — never retyped, so the two front ends are compared, not two copies.
+ */
+
+const OFFICIAL: Marketplace = {
+	name: "claude-plugins-official",
+	displayName: "Anthropic Official",
+	source: { source: "github", repo: "anthropics/claude-plugins-official" },
+	description: "",
+} as Marketplace;
+
+const MAGUS: Marketplace = {
+	name: "magus",
+	displayName: "Magus",
+	source: { source: "github", repo: "MadAppGang/magus" },
+	description: "",
+	owned: true,
+} as Marketplace;
+
+function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
+	const [name, marketplace] = over.id.split("@");
+	return {
+		name,
+		version: null,
+		description: "",
+		marketplace,
+		marketplaceDisplay: "",
+		enabled: true,
+		author: { name: "Anthropic" },
+		...over,
+	} as PluginInfo;
+}
+
+/** Real: `code-review@claude-plugins-official` in /Users/jack/mag/claudish. */
+const CODE_REVIEW = info({
+	id: "code-review@claude-plugins-official",
+	version: null, // the official catalog publishes no version for it
+	installedVersion: "3ea32df27be7",
+	projectScope: { enabled: true, version: "3ea32df27be7" },
+});
+
+/** A registry "0.0.0" — the value the old row hid every status behind. */
+const ZERO = info({
+	id: "zero-version@claude-plugins-official",
+	version: null,
+	installedVersion: "0.0.0",
+	projectScope: { enabled: true, version: "0.0.0" },
+});
+
+/** Other listed ids, so each marketplace demonstrably was read. */
+const LISTED = [
+	info({ id: "dev@magus", version: "4.7.0", author: { name: "MadAppGang" } }),
+	info({ id: "github@claude-plugins-official", version: null }),
+];
+
+function rows(
+	plugins: PluginInfo[],
+	pins: Record<string, string> = {},
+): Map<string, PluginPluginItem> {
+	const all = [...plugins, ...LISTED];
+	const items = buildPluginBrowserItems({
+		marketplaces: [MAGUS, OFFICIAL],
+		plugins: all,
+		collapsedMarketplaces: new Set(),
+		statuses: classifyPluginRows(all, pins),
+	});
+	return new Map(
+		items
+			.filter((i): i is PluginPluginItem => i.kind === "plugin")
+			.map((i) => [i.plugin.id, i]),
+	);
+}
+
+/** The note `claudeup update` prints for this plugin under this pin. */
+function cliNote(
+	plugins: PluginInfo[],
+	id: string,
+	pin = "latest",
+): string | undefined {
+	const all = [...plugins, ...LISTED];
+	const [item] = planPluginUpdates(
+		{ [id]: pin },
+		new Map(all.map((p) => [p.id, p])),
+	);
+	return item?.note;
+}
+
+describe("pluginRowText — a status never depends on a displayable version", () => {
+	test("a sha-versioned unknown carries the CLI's reason verbatim", () => {
+		// The old row said "? not comparable" here; the CLI said the sentence
+		// below. Same state, different reason — the R2 violation.
+		const row = rows([CODE_REVIEW]).get(CODE_REVIEW.id);
+		const note = cliNote([CODE_REVIEW], CODE_REVIEW.id);
+		expect(note).toBe(
+			"its marketplace publishes no version for this plugin, so there is nothing to compare",
+		);
+		const { text } = pluginRowText(row as PluginPluginItem);
+		expect(text).toBe(` v3ea32df27be7 ? ${note}`);
+		expect(text).not.toContain("not comparable");
+	});
+
+	test('REGRESSION: a "0.0.0" unknown is no longer blank', () => {
+		// Every old status clause was gated on a displayable version, so this row
+		// printed nothing after its name and read as healthy.
+		const row = rows([ZERO]).get(ZERO.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("unknown");
+		const { text, segments } = pluginRowText(row);
+		expect(text).toBe(` ? ${cliNote([ZERO], ZERO.id)}`);
+		// The version itself is still never printed.
+		expect(text).not.toContain("0.0.0");
+		expect(segments.at(-1)?.tone).toBe("warning");
+	});
+});
+
+describe("pluginRowText — orphans say what the CLI says (F9)", () => {
+	test("an orphan that moved names where it went", () => {
+		const seo = info({
+			id: "seo@magus",
+			version: "1.8.0",
+			installedVersion: "1.8.0",
+			isOrphaned: true,
+			movedTo: "magus-marketing",
+			projectScope: { enabled: true, version: "1.8.0" },
+		});
+		const row = rows([seo]).get(seo.id) as PluginPluginItem;
+		expect(cliNote([seo], seo.id)).toBe("moved to magus-marketing");
+		expect(pluginRowText(row).text).toBe(" v1.8.0 ? moved to magus-marketing");
+	});
+
+	test("an orphan with no movedTo, from a marketplace we read, is 'not offered'", () => {
+		const gone = info({
+			id: "gone@magus",
+			version: "2.0.0",
+			installedVersion: "2.0.0",
+			isOrphaned: true,
+			projectScope: { enabled: true, version: "2.0.0" },
+		});
+		const row = rows([gone]).get(gone.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(
+			` v2.0.0 ? ${cliNote([gone], gone.id)}`,
+		);
+		expect(pluginRowText(row).text).toContain(
+			"not offered by any configured marketplace",
+		);
+	});
+
+	test("the old words are gone: no 'deprecated', no 'moved →'", () => {
+		const seo = info({
+			id: "seo@magus",
+			installedVersion: "1.8.0",
+			isOrphaned: true,
+			movedTo: "magus-marketing",
+			projectScope: { enabled: true, version: "1.8.0" },
+		});
+		const { text } = pluginRowText(rows([seo]).get(seo.id) as PluginPluginItem);
+		expect(text).not.toContain("deprecated");
+		expect(text).not.toContain("moved →");
+	});
+});
+
+describe("pluginRowText — history badges combine with the state", () => {
+	const updated = (over: Partial<PluginInfo>) =>
+		info({
+			id: "terminal@magus",
+			version: "3.3.1",
+			installedVersion: "3.0.1",
+			projectScope: { enabled: true, version: "3.0.1" },
+			author: { name: "MadAppGang" },
+			...over,
+		});
+
+	test("'updated' and a pending update are both shown", () => {
+		// An external update moved 2.9.0 → 3.0.1 while 3.3.1 is already out.
+		const p = updated({ recentlyUpdatedFrom: "2.9.0" });
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		const { text, segments } = pluginRowText(row);
+		expect(text).toBe(" v2.9.0 → v3.0.1 updated → v3.3.1 available");
+		expect(segments.map((s) => s.tone)).toEqual(["success", "warning"]);
+	});
+
+	test("'new' and a pending update are both shown", () => {
+		const p = updated({ recentlyInstalled: true });
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(" v3.0.1 new → v3.3.1 available");
+	});
+
+	test("'new' with no displayable version still says new", () => {
+		const p = updated({
+			recentlyInstalled: true,
+			version: "0.0.0",
+			installedVersion: "0.0.0",
+			projectScope: { enabled: true, version: "0.0.0" },
+		});
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(" new");
+	});
+
+	test("a current row shows only its version", () => {
+		const p = updated({
+			version: "3.0.1",
+		});
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("current");
+		expect(pluginRowText(row).text).toBe(" v3.0.1");
+	});
+});
+
+describe("pluginRowText — rows with no state claim none", () => {
+	test("an undeclared, uninstalled catalog entry has no status and no text", () => {
+		const browse = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+		});
+		const row = rows([browse]).get(browse.id) as PluginPluginItem;
+		expect(row.status).toBeNull();
+		expect(pluginRowText(row).text).toBe("");
+	});
+
+	test("the same entry DECLARED by the profile says the profile wants it", () => {
+		const declared = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+		});
+		const row = rows([declared], { "kanban@magus": "latest" }).get(
+			declared.id,
+		) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(
+			" not installed — profile declares it",
+		);
+	});
+});
+
+describe("pluginStatusText — absent is not enabled-not-installed (LOW 6)", () => {
+	const status = (over: Partial<PluginUpdateItem>): PluginUpdateItem => ({
+		pluginId: "x@magus",
+		pinned: "latest",
+		installed: null,
+		available: "1.0.0",
+		target: "1.0.0",
+		action: "install",
+		reason: "absent",
+		scopes: [],
+		beforeVersions: {},
+		...over,
+	});
+
+	test("absent — only ever from a profile pin — may say the profile declares it", () => {
+		expect(pluginStatusText(status({}))).toEqual({
+			suffix: " not installed — profile declares it",
+			tone: "warning",
+		});
+	});
+
+	test("enabled-not-installed shows its note and never claims a declaration", () => {
+		const got = pluginStatusText(
+			status({
+				reason: "enabled-not-installed",
+				note: "enabled in settings, but no files on disk",
+			}),
+		);
+		expect(got).toEqual({
+			suffix: " not installed (enabled in settings, but no files on disk)",
+			tone: "danger",
+		});
+		expect(got.suffix).not.toContain("profile");
+	});
+
+	test("an undeclared enabled-but-not-installed ROW gets the enabled text", () => {
+		const broken = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+			localScope: { enabled: true },
+		});
+		const row = rows([broken]).get(broken.id) as PluginPluginItem;
+		expect(row.status?.reason).toBe("enabled-not-installed");
+		expect(pluginRowText(row).text).toBe(
+			" not installed (enabled in settings, but no files on disk)",
+		);
+	});
+
+	test("null status says nothing", () => {
+		expect(pluginStatusText(null)).toEqual({ suffix: "", tone: "muted" });
+	});
+
+	test("update with a pin-undeliverable note carries it", () => {
+		expect(
+			pluginStatusText(
+				status({
+					action: "update",
+					reason: "pin-undeliverable",
+					target: "9.9.9",
+					note: "manifest pins 4.6.1; the marketplace offers only 9.9.9",
+				}),
+			).suffix,
+		).toBe(
+			" → v9.9.9 available (manifest pins 4.6.1; the marketplace offers only 9.9.9)",
+		);
+	});
+
+	test("repair carries its note", () => {
+		expect(
+			pluginStatusText(
+				status({
+					action: "repair",
+					reason: "content-stale",
+					note: "files changed without a version bump",
+				}),
+			).suffix,
+		).toBe(" stale — reinstall (files changed without a version bump)");
+	});
+});

package/src/__tests__/resolver.test.ts

@@ -91,9 +91,9 @@ describe("resolveExtends", () => {
 			extends: "growth-marketer",
 		};
 		const merged = resolveExtends(entry);
-		// image-generate/video-editing ship on the magus-marketing channel and
+		// image/video-editing ship on the magus-marketing channel and
 		// pin it explicitly — they must NOT be rewritten to @magus.
-		expect(merged.plugins!["image-generate@magus-marketing"]).toBe("latest");
+		expect(merged.plugins!["image@magus-marketing"]).toBe("latest");
 		expect(merged.plugins!["video-editing@magus-marketing"]).toBe("latest");
 		expect(merged.plugins!["image-generate@magus"]).toBeUndefined();
 		// Bare names still default to @magus.
@@ -302,7 +302,7 @@ describe("marketplaces derived from plugin ids", () => {
 				name: "Mixed",
 				plugins: {
 					"dev@magus": "latest",
-					"image-generate@magus-marketing": "latest",
+					"image@magus-marketing": "latest",
 					"feature-dev@claude-plugins-official": "latest",
 				},
 			},

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

@@ -1,8 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import {
+	type PluginInfo,
 	isInstalledInScope,
 	resolveScopeAction,
 } from "../services/plugin-manager.js";
+import { planPluginUpdates, scopeIsBehind } from "../services/update-plan.js";
 
 /**
  * The scope keys (u / p / l) and the Enter scope picker both decide between
@@ -29,10 +31,18 @@ describe("isInstalledInScope", () => {
 		expect(isInstalledInScope({ enabled: true })).toBe(false);
 	});
 
-	test("a version with the flag off is not installed either", () => {
-		expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(
-			false,
-		);
+	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("an absent scope is not installed", () => {
@@ -45,40 +55,80 @@ describe("isInstalledInScope", () => {
 });
 
 describe("resolveScopeAction", () => {
+	// The second argument is "is this scope provably behind?", which the screen
+	// 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", () => {
 		// This is the reported bug. Before the fix this returned "uninstall".
-		expect(resolveScopeAction({ enabled: true }, "3.0.2")).toBe("install");
+		expect(resolveScopeAction({ enabled: true }, false)).toBe("install");
+		// Whatever the classifier says: the safety branch comes first.
+		expect(resolveScopeAction({ enabled: true }, true)).toBe("install");
 	});
 
 	test("a scope that was never enabled resolves to install", () => {
-		expect(resolveScopeAction(undefined, "3.0.2")).toBe("install");
-		expect(resolveScopeAction({ enabled: false }, "3.0.2")).toBe("install");
+		expect(resolveScopeAction(undefined, false)).toBe("install");
+		expect(resolveScopeAction({ enabled: 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" }, "3.0.2"),
-		).toBe("uninstall");
+		expect(resolveScopeAction({ enabled: 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" }, "3.0.2"),
-		).toBe("update");
+		expect(resolveScopeAction({ enabled: 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 [status] = planPluginUpdates(
+		{ "x@magus": "latest" },
+		new Map([
+			[
+				"x@magus",
+				{
+					id: "x@magus",
+					name: "x",
+					version: catalogVersion,
+					description: "",
+					marketplace: "magus",
+					marketplaceDisplay: "Magus",
+					enabled: true,
+					projectScope: scope,
+				} as PluginInfo,
+			],
+		]),
+	);
+	return resolveScopeAction(scope, scopeIsBehind(status, "project"));
+}
+
+describe("resolveScopeAction through the classifier — the screen's real path", () => {
 	test('an unknown catalog version ("0.0.0") never fabricates an update', () => {
 		// There is nothing to update *to*, so toggling must still mean uninstall.
-		expect(
-			resolveScopeAction({ enabled: true, version: "3.0.2" }, "0.0.0"),
-		).toBe("uninstall");
+		expect(keyFor("3.0.2", "0.0.0")).toBe("uninstall");
 	});
 
 	test("installed with unknown version resolves to update when a real version is published", () => {
 		// "0.0.0" installed against a real catalog version is a genuine upgrade
 		// path, not the broken state — it must not be treated as uninstall.
-		expect(
-			resolveScopeAction({ enabled: true, version: "0.0.0" }, "3.0.2"),
-		).toBe("update");
+		expect(keyFor("0.0.0", "3.0.2")).toBe("update");
+	});
+
+	test("REGRESSION: a scope AHEAD of the catalog no longer resolves to update", () => {
+		// Raw string inequality called 3.1.0 vs 3.0.2 "behind" and offered an
+		// update that could only reinstall the older version or no-op.
+		expect(keyFor("3.1.0", "3.0.2")).toBe("uninstall");
+	});
+
+	test("REGRESSION: an unorderable scope no longer resolves to update", () => {
+		// A sha against a semver cannot be ordered. The row says "?", so the key
+		// must not act as though it knew the scope was behind.
+		expect(keyFor("3ea32df27be7", "3.0.2")).toBe("uninstall");
 	});
 });