magus-cli 7.0.0 → 7.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.0.0",
-    "magus-cli-darwin-x64": "7.0.0",
-    "magus-cli-linux-x64": "7.0.0"
+    "magus-cli-darwin-arm64": "7.2.0",
+    "magus-cli-darwin-x64": "7.2.0",
+    "magus-cli-linux-x64": "7.2.0"
   }
 }

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

@@ -132,7 +132,6 @@ function makeCatalog(): PluginInfo[] {
 		// _synthetic orphans
 		row("seo@magus", null, "1.0.0", {
 			isOrphaned: true,
-			movedTo: "magus-marketing",
 		}),
 		row("legacy-tool@magus", null, "0.5.0", { isOrphaned: true }),
 		row("seo@magus-marketing", "1.1.0", null),
@@ -442,7 +441,12 @@ describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
 		}
 	});
 
-	test("the 5 reported official plugins are UNKNOWN with the same no-published-version reason on both paths", async () => {
+	// 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)) {
@@ -450,14 +454,15 @@ describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
 			const tui = p.tuiRows.get(id)?.status;
 			expect({ id, action: cli?.action, reason: cli?.reason }).toEqual({
 				id,
-				action: "unknown",
+				action: "current",
 				reason: "no-published-version",
 			});
-			expect(cli?.note ?? "").toContain(NO_PUBLISHED_VERSION_NOTE);
+			// 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).toContain(NO_PUBLISHED_VERSION_NOTE);
+			expect(pluginRowText(row).text).not.toContain(NO_PUBLISHED_VERSION_NOTE);
 		}
 	});
 
@@ -467,7 +472,12 @@ describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
 			string,
 			{ action: string; reason?: string; target?: string | null }
 		> = {
-			[`zero-version@${OFFICIAL}`]: { action: "unknown" },
+			// 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",
@@ -482,7 +492,10 @@ describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
 				reason: "catalog-unverified",
 				target: null,
 			},
-			"seo@magus": { action: "unknown", reason: "moved", 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",
@@ -493,11 +506,10 @@ describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
 				reason: "behind",
 				target: "2.1.0",
 			},
-			"pinned-unorderable@magus": {
-				action: "unknown",
-				reason: "unorderable",
-				target: null,
-			},
+			// `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)) {
@@ -563,8 +575,16 @@ describe("R7 parity: one fixture through the CLI path and the TUI path", () => {
 		expect(countPluginStates(tuiItems)).toEqual(cliCounts);
 		expect(cliCounts.install).toBe(1); // bunjs
 		expect(cliCounts.repair).toBe(1); // madbench
-		// 5 official + zero-version + claudish (unverified) + 2 orphans + unorderable
-		expect(cliCounts.unknown).toBe(10);
+		// 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
 	});
 
@@ -671,14 +691,35 @@ describe("fixture discriminates the pre-change logic", () => {
 		}
 	});
 
-	test("flag-derived TUI state calls the unversioned rows healthy; the shared status says unknown", async () => {
+	// 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();
-		const ids = [...Object.keys(REAL_OFFICIAL), `zero-version@${OFFICIAL}`];
 
-		for (const id of ids) {
+		// 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");
 		}
 	});
 });

package/src/__tests__/blackbox-plugin-state.test.ts

@@ -170,7 +170,12 @@ describe("classifyPlugin — one state plus a human reason", () => {
 		});
 	});
 
-	test("unversioned catalog with a commit-sha install is unknown, never current (report #1)", () => {
+	// Report #1 asked for the opposite of this, and that decision was REVERSED:
+	// a catalog that publishes no version leaves the install `current`, because
+	// there is no newer version to be behind. The reason code still records WHY
+	// the verdict was reached, so the state is not lost — it just stops being
+	// reported as a problem the reader must act on.
+	test("unversioned catalog with a commit-sha install is current, with the reason kept", () => {
 		const idx = indexCatalog([
 			info("code-review@claude-plugins-official", null, "3ea32df27be7"),
 		]);
@@ -181,16 +186,12 @@ describe("classifyPlugin — one state plus a human reason", () => {
 			idx,
 		);
 
-		expect({
-			action: got.action,
-			reason: got.reason,
-			target: got.target,
-		}).toEqual({
-			action: "unknown",
+		expect({ action: got.action, reason: got.reason }).toEqual({
+			action: "current",
 			reason: "no-published-version",
-			target: null,
 		});
-		expect(got.note).toBeTruthy();
+		// No note: nothing here is actionable, so there is nothing to tell anyone.
+		expect(got.note).toBeUndefined();
 	});
 
 	test("a failed catalog check on a latest pin is unknown / catalog-unverified, never current", () => {
@@ -214,13 +215,11 @@ describe("classifyPlugin — one state plus a human reason", () => {
 			info("e@nowhere", null, "0.3.0", { isOrphaned: true }),
 		]);
 
-		for (const id of [
-			"a@magus",
-			"b@magus",
-			"c@magus",
-			"d@magus",
-			"e@nowhere",
-		]) {
+		// `a@magus` is deliberately NOT in this list: a catalog that publishes no
+		// version is `current` now, not unknown. It is the negative control
+		// below — without it this loop would pass even if every state collapsed
+		// into one.
+		for (const id of ["b@magus", "c@magus", "d@magus", "e@nowhere"]) {
 			const got = classifyPlugin(id, "latest", idx);
 			expect({ id, action: got.action }).toEqual({ id, action: "unknown" });
 			expect({ id, target: got.target, hasNote: Boolean(got.note) }).toEqual({
@@ -229,6 +228,12 @@ describe("classifyPlugin — one state plus a human reason", () => {
 				hasNote: true,
 			});
 		}
+
+		// The control: same catalog, same call, the opposite verdict — and
+		// crucially no note, because nothing about it is actionable.
+		const a = classifyPlugin("a@magus", "latest", idx);
+		expect(a.action).toBe("current");
+		expect(a.note).toBeUndefined();
 	});
 });
 
@@ -486,14 +491,31 @@ describe("pluginRowText", () => {
 		};
 	}
 
-	test("an unknown status on a 0.0.0 install still renders the note (no version gate)", () => {
-		const plugin = info("zero-version@claude-plugins-official", null, "0.0.0");
-		const status = classifyPlugin(plugin.id, "latest", indexCatalog([plugin]));
+	// The gate this guards: every status clause used to be conditional on the
+	// installed version being displayable, so a plugin recorded as "0.0.0"
+	// printed nothing after its name and read as healthy.
+	//
+	// The fixture is an ORPHAN at 0.0.0, not a plain 0.0.0 install. A plain one
+	// is `current` with no note now, which would leave nothing for this test to
+	// find and let the gate come back unnoticed.
+	test("a note renders on a 0.0.0 install — no version gate", () => {
+		const plugin = info("zero-version@magus", null, "0.0.0", {
+			isOrphaned: true,
+		});
+		const sibling = info("dev@magus", "1.0.0", "1.0.0");
+		const status = classifyPlugin(
+			plugin.id,
+			"latest",
+			indexCatalog([plugin, sibling]),
+		);
 
 		const out = pluginRowText(rowItem(plugin, status));
 
 		expect(status.action).toBe("unknown");
+		expect(status.note).toBeTruthy();
 		expect(out.text).toContain(status.note ?? "<missing note>");
+		// The undisplayable version itself is still never printed.
+		expect(out.text).not.toContain("0.0.0");
 	});
 
 	test("text is exactly the segments joined, and contains the status suffix", () => {

package/src/__tests__/cli-update-view.test.ts

@@ -25,7 +25,6 @@ import {
 	stepRecord,
 	summaryLine,
 	uncheckedGateNotice,
-	unknownPluginsNotice,
 	unknownToolsNotice,
 } from "../cli/update-view.js";
 import type { UpdatePlan } from "../services/update-plan.js";
@@ -167,7 +166,10 @@ describe("alignment", () => {
 		const rows = planReport(p).filter((l) => l.includes("@"));
 		const cols = rows.map((r) => r.search(/(1\.7\.0|4\.6\.1|latest|1\.8\.0)/));
 		expect(new Set(cols).size).toBe(1);
-		expect(rows[0]).toContain(long);
+		// Not `rows[0]`: grouping means row order follows state, not plan order,
+		// and this fixture's long id is `current` — the LAST group. The claim is
+		// that the id is printed in full somewhere, not where it lands.
+		expect(rows.some((r) => r.includes(long))).toBe(true);
 	});
 });
 
@@ -195,13 +197,30 @@ describe("NO_COLOR", () => {
 	test("every action stays distinguishable without colour", () => {
 		setColorEnabled(false);
 		const out = planReport(plan()).join("\n");
-		// Colour never carries meaning alone: each action has its own word AND
-		// its own glyph, so the report survives a pipe and colour blindness.
-		for (const label of ["CURRENT", "UPDATE", "INSTALL", "UNKNOWN", "UPGRADE"])
+		// Colour never carries meaning alone: the report has to survive a pipe
+		// and colour blindness. Plugins say their state as a GROUP HEADING and a
+		// glyph; the tool and skill sections still badge each row with its own
+		// action word.
+		for (const heading of ["Update", "Fix required", "Current"])
+			expect(out).toContain(heading);
+		for (const label of ["CURRENT", "UPGRADE", "INSTALL"])
 			expect(out).toContain(label);
 		for (const glyph of ["=", "↑", "+", "?"]) expect(out).toContain(glyph);
 	});
 
+	// Two states that an apply treats very differently, and which a reader must
+	// never have to tell apart by hue. `unknown` is grouped under Current and
+	// wears `?`; an update wears `↑` under its own heading.
+	test("an unverified row is not confusable with an up-to-date one", () => {
+		setColorEnabled(false);
+		const rows = planReport(plan());
+		const unknown = rows.find((l) => l.includes("designer@magus"))!;
+		const current = rows.find((l) => l.includes("agentdev@magus"))!;
+		expect(unknown).toContain("?");
+		expect(current).toContain("=");
+		expect(unknown).toContain("catalog unreachable");
+	});
+
 	test("a note rides along on the row it explains", () => {
 		setColorEnabled(false);
 		const row = planReport(plan()).find((l) => l.includes("designer@magus"))!;
@@ -240,7 +259,10 @@ describe("bars", () => {
 		expect(frame[2]).not.toMatch(/[█░]/);
 	});
 
-	test("the record scales each step against the slowest, not the total", () => {
+	// The record carries NO bar: a share-of-the-slowest meter restated the
+	// millisecond column next to it. The durations themselves still have to be
+	// right, and still have to rank the steps.
+	test("the record reports each step's duration and draws no bar", () => {
 		setColorEnabled(false);
 		const record = stepRecord(
 			[
@@ -261,18 +283,19 @@ describe("bars", () => {
 			],
 			1000,
 		);
-		const bars = record.map((r) => r.match(/[█░]+/)![0]);
-		expect(bars[1]!.split("█").length - 1).toBe(18);
-		expect(bars[0]!.split("█").length - 1).toBe(2);
+		for (const row of record) expect(row).not.toMatch(/[█░]/);
+		expect(record[0]).toContain("100ms");
+		expect(record[1]).toContain("1.0s");
 	});
 
-	test("a step that never ran does not divide by zero", () => {
+	test("a step that never ran reports no elapsed time, and does not throw", () => {
 		setColorEnabled(false);
 		const record = stepRecord(
 			[{ label: "x", state: "pending", detail: "" }],
 			0,
 		);
-		expect(record[0]).toContain("░");
+		expect(record[0]).toContain("x");
+		expect(record[0]).not.toMatch(/[█░]/);
 	});
 
 	test("the apply meter is full exactly when the work is done", () => {
@@ -317,13 +340,69 @@ describe("sections", () => {
 		expect(out).not.toContain("Skills");
 	});
 
-	test("a section legend counts every action it contains", () => {
+	// The Plugins section is grouped by state, so its counts live on the group
+	// headings, not on one legend line. The invariant that matters is the one
+	// that broke once already: the counts printed must add up to the rows
+	// printed. A fixed heading order used to render an unnamed group as nothing
+	// while the total above still counted it — "Plugins 4" over three rows.
+	test("every plugin row sits under a heading, and the headings add up", () => {
 		setColorEnabled(false);
-		const line = planReport(plan()).find((l) => l.includes("Plugins"))!;
-		expect(line).toContain("1 current");
-		expect(line).toContain("1 update");
-		expect(line).toContain("1 install");
-		expect(line).toContain("1 unknown");
+		const out = planReport(plan());
+		const total = out.find((l) => /^\s+Plugins\s+\d+$/.test(l))!;
+		expect(total).toContain("4");
+
+		// Matches ANY "<words>  <count>" heading, not a fixed alternation of the
+		// group names. A named list silently stops counting a group that is added
+		// later, which is the same blind spot as the fixed order above — the sum
+		// then holds against a subset and the test passes while rows go unheaded.
+		const headings = out.flatMap((l) => {
+			const m = l.match(/^\s+([A-Z][A-Za-z ]+?)\s\s+(\d+)$/);
+			return m && m[1] !== "Plugins"
+				? [{ group: m[1], count: Number(m[2]) }]
+				: [];
+		});
+		// This fixture has one of each except Deprecated, whose row would need a
+		// `not-offered` reason. `designer@magus` is unknown with a note, so it is
+		// Unverified — NOT Current, which would claim a failed check succeeded.
+		expect(headings.map((h) => h.group)).toEqual([
+			"Update",
+			"Fix required",
+			"Unverified",
+			"Current",
+		]);
+		// Every counted row is a row on screen: 1 + 1 + 1 + 1 === the 4 above.
+		const rows = out.filter((l) => l.includes("@"));
+		expect(headings.reduce((n, h) => n + h.count, 0)).toBe(rows.length);
+		expect(rows.length).toBe(4);
+	});
+
+	// The regression the reviewer caught before release: a pin naming a plugin no
+	// marketplace offers, with nothing installed, was filtered out of the table
+	// on the grounds that a notice printed it instead. That notice never existed.
+	// The row appeared nowhere while the closing lines still counted it.
+	test("a pin nothing offers still gets a row", () => {
+		setColorEnabled(false);
+		const p = plan();
+		p.plugins = [
+			{
+				pluginId: "agentdev@magus",
+				pinned: "latest",
+				installed: null,
+				available: null,
+				target: null,
+				action: "unknown",
+				reason: "not-offered",
+				scopes: [],
+			},
+			...p.plugins,
+		] as UpdatePlan["plugins"];
+
+		const out = planReport(p);
+		expect(out.join("\n")).toContain("agentdev@magus");
+		// And it is counted where it is shown, not somewhere else.
+		const total = out.find((l) => /^\s+Plugins\s+\d+$/.test(l))!;
+		expect(total).toContain("5");
+		expect(out.filter((l) => l.includes("@")).length).toBe(5);
 	});
 
 	test("a CLI upgrade shows the command that will run", () => {
@@ -398,7 +477,6 @@ describe("unverified notices", () => {
 	// once the catalog is reachable", which is false advice for a plugin whose
 	// marketplace publishes no version — the case a real dry run showed five of.
 	const notices = () => [
-		unknownPluginsNotice(5),
 		nothingToApplyNotice(5),
 		unknownToolsNotice(1, ["crush"]),
 		uncheckedGateNotice(6),
@@ -413,11 +491,12 @@ describe("unverified notices", () => {
 		}
 	});
 
+	// There is no per-plugin notice under the plan any more: every unverified
+	// plugin is a row in the table, under a heading naming its state, so the
+	// line restated the table and miscounted it. `nothingToApplyNotice` is a
+	// different case — it fires when there IS no table worth reading.
 	test("an unverified plugin is never reported as up to date", () => {
 		setColorEnabled(false);
-		const under = unknownPluginsNotice(5);
-		expect(under).toContain("5 plugin(s) could not be checked");
-		expect(under).toContain("They are NOT reported as up to date.");
 		const nothing = nothingToApplyNotice(5);
 		expect(nothing.trimStart()).toStartWith("⚠  Nothing to apply.");
 		expect(nothing).toContain("5 plugin(s) could not be checked");

package/src/__tests__/local-marketplace-scan.test.ts

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import fs from "fs-extra";
 import {
+	registeredMarketplaceNames,
 	scanMcpServers,
 	scanSkillDirs,
 } from "../services/local-marketplace.js";
@@ -172,3 +173,76 @@ describe("clone walkers", () => {
 		expect(await walkMarkdown(path.join(root, "nope"))).toEqual([]);
 	});
 });
+
+/**
+ * REGRESSION: a directory under `marketplaces/` was treated as a marketplace.
+ *
+ * `scanLocalMarketplaces` enumerated the directory and accepted anything with a
+ * parseable manifest — never asking `known_marketplaces.json` whether it was
+ * registered. Claude Code refreshes a marketplace by delete-then-clone and
+ * leaves `<name>.bak` behind, so the reporter's machine carried a 13M
+ * `magus.bak` holding an older magus manifest. It cost them twice:
+ *
+ *  - `getAllMarketplaces()` dedupes by repo, first-come, and `magus.bak`
+ *    reported the same repo — so the REAL magus was dropped from the plugin
+ *    list entirely. That is the "nothing installed and magus is not first"
+ *    screenshot.
+ *  - `findPluginInOtherMarketplace` then answered from it: `kanban@magus`
+ *    rendered `moved → magus.bak`, pointing the user at a backup folder.
+ *
+ * `claude plugin marketplace list` never showed it — six entries, never seven —
+ * because Claude Code reads the registry. This is magus agreeing with it.
+ */
+describe("registeredMarketplaceNames", () => {
+	it("accepts a registry key", () => {
+		const names = registeredMarketplaceNames({
+			magus: { installLocation: "/h/.claude/plugins/marketplaces/magus" },
+		});
+		expect(names?.has("magus")).toBe(true);
+	});
+
+	it("rejects a directory with no registry entry — the magus.bak case", () => {
+		const names = registeredMarketplaceNames({
+			magus: { installLocation: "/h/.claude/plugins/marketplaces/magus" },
+		});
+		expect(names?.has("magus.bak")).toBe(false);
+	});
+
+	it("also accepts the basename of installLocation when it differs from the key", () => {
+		// Nothing enforces key === directory name. Dropping a real marketplace is
+		// far worse than keeping a stray directory, so both spellings count.
+		const names = registeredMarketplaceNames({
+			magus: {
+				installLocation: "/h/.claude/plugins/marketplaces/magus-pinned",
+			},
+		});
+		expect(names?.has("magus")).toBe(true);
+		expect(names?.has("magus-pinned")).toBe(true);
+	});
+
+	it("returns null for input it cannot use, so nothing is filtered", () => {
+		// THE failure mode to avoid. Null means "no opinion" and the caller keeps
+		// every directory. Returning an empty set here instead would delete every
+		// marketplace on a corrupt registry, and every installed plugin would
+		// report as withdrawn — the exact "unknown rendered as a determinate
+		// negative" this whole change removes, rebuilt one level up.
+		expect(registeredMarketplaceNames(null)).toBeNull();
+		expect(registeredMarketplaceNames(undefined)).toBeNull();
+		expect(registeredMarketplaceNames("not an object")).toBeNull();
+		expect(registeredMarketplaceNames(["magus"])).toBeNull();
+	});
+
+	it("treats an empty registry as an answer, not as missing data", () => {
+		// A file that exists and parses to {} says nothing is registered. An
+		// ABSENT file is what returns null, upstream in readKnownMarketplacesOrNull.
+		const names = registeredMarketplaceNames({});
+		expect(names).not.toBeNull();
+		expect(names?.size).toBe(0);
+	});
+
+	it("survives an entry with no installLocation", () => {
+		const names = registeredMarketplaceNames({ magus: {} });
+		expect(names?.has("magus")).toBe(true);
+		expect(names?.size).toBe(1);
+	});
+});

package/src/__tests__/marketplace-refresh.test.ts

@@ -214,19 +214,24 @@ describe("refreshRegisteredMarketplaces — selection & skips", () => {
 		expect(r.skipped).toEqual(["local"]);
 	});
 
-	it("reports a marketplace with autoUpdate === false separately from ordinary skips", async () => {
-		// Not lumped into `skipped`: opting out here freezes the catalog, so the
-		// marketplace's plugins read as up to date forever. The caller has to be
-		// able to tell the user, which it cannot do if this looks like "no clone
-		// on disk". A real magus clone sat 11 days behind exactly this way.
+	// `autoUpdateDisabled` is GONE, and so is the warning built on it. The
+	// premise was that opting out freezes the catalog, so the marketplace's
+	// plugins read as up to date forever. MEASURED against a real clone, that is
+	// false: `readCatalogFromRemote` does its own `git fetch` plus
+	// `git show origin/<branch>`, so a clone pinned at dev 7.4.0 with autoUpdate
+	// off still reported 7.4.1 available. The flag does not hide updates, and the
+	// warning told users to fix something that was not broken.
+	//
+	// It is an ordinary skip now: nothing was pulled, and that is all we claim.
+	it("an autoUpdate === false marketplace is an ordinary skip", async () => {
 		installClone("magus");
 		publishV2();
 		configured = { magus: gh() };
 		autoUpdate = { magus: false };
 		const r = await refreshRegisteredMarketplaces();
 		expect(r.refreshed).toEqual([]);
-		expect(r.autoUpdateDisabled).toEqual(["magus"]);
-		expect(r.skipped).toEqual([]);
+		expect(r.skipped).toEqual(["magus"]);
+		expect(r).not.toHaveProperty("autoUpdateDisabled");
 	});
 
 	it("honors the skip set (already handled this run)", async () => {