magus-cli 7.0.0 → 7.1.0

package/src/cli/update-view.ts

@@ -31,6 +31,7 @@ import type {
 	SkillUpdateItem,
 	UpdatePlan,
 } from "../services/update-plan.js";
+import { type ReportBadgeKind, reportBadge } from "../ui/theme-mode.js";
 import { brand } from "../ui/theme.js";
 import { formatCommand } from "../utils/command-utils.js";
 import {
@@ -84,8 +85,11 @@ type ActionKey =
 const ACTIONS: Record<ActionKey, ActionStyle> = {
 	current: { glyph: "=", label: "CURRENT", color: brand.muted, chrome: true },
 	install: { glyph: "+", label: "INSTALL", color: brand.link },
-	update: { glyph: "↑", label: "UPDATE", color: brand.warning },
-	upgrade: { glyph: "↑", label: "UPGRADE", color: brand.warning },
+	// Green, the tone magus uses for an update everywhere else. Amber stays
+	// on `unknown` below, so the two states remain distinguishable: green is
+	// "a newer version exists", amber is "we could not tell".
+	update: { glyph: "↑", label: "UPDATE", color: brand.success },
+	upgrade: { glyph: "↑", label: "UPGRADE", color: brand.success },
 	repair: { glyph: "⟳", label: "REPAIR", color: brand.info },
 	refresh: { glyph: "⟳", label: "REFRESH", color: brand.info },
 	// Warning, not danger: "cannot tell" is not a failure, and red UNKNOWN read
@@ -207,24 +211,24 @@ export function stepFrame(steps: Step[], tick: number, now: number): string[] {
 }
 
 /**
- * The permanent record, with a duration bar per step.
+ * The permanent record: one row per step, its duration, and what it found.
  *
- * The bar is each step's share of the SLOWEST step, not of the total — the
- * question a reader has when an update felt slow is "which part was it?", and
- * shares of a total flatten to a uniform smear once there are four of them.
- * Colour ramps green to red with that share, so the offender is the red one.
+ * NO BAR. Each row carried an 18-cell meter of that step's share of the
+ * slowest step — which is precisely what the right-aligned millisecond column
+ * beside it already says, so the row stated one fact twice. A shape earns its
+ * width by making something readable that the number does not; a share of a
+ * five-row set, already sorted into a column, is not that.
+ *
+ * The LIVE frame keeps its bar (`stepFrame` above) and that is not the same
+ * widget: there the bar is a progress meter or an indeterminate sweep on the
+ * step running right now, and it answers "is this working or hung?" — a
+ * question no printed number can answer.
  */
 export function stepRecord(steps: Step[], now: number): string[] {
-	const times = steps.map((s) => stepDuration(s, now) ?? 0);
-	const slowest = Math.max(1, ...times);
-	return steps.map((step, i) => {
-		const share = (times[i] / slowest) * 100;
-		const bar = meter(share, BAR, ramps.severity);
+	return steps.map((step) => {
 		const label = padEnd(step.label, STEP_LABEL_WIDTH);
-		const time = dim(padStart(elapsed(times[i]), 6));
-		return `${PAD}${stepMark(step, 0)}  ${label} ${bar} ${time}  ${dim(
-			step.detail,
-		)}`;
+		const time = dim(padStart(elapsed(stepDuration(step, now) ?? 0), 6));
+		return `${PAD}${stepMark(step, 0)}  ${label} ${time}  ${dim(step.detail)}`;
 	});
 }
 
@@ -236,15 +240,30 @@ function pluginAction(item: PluginUpdateItem): ActionKey {
 
 /** What the row says on its right: versions, never the action word again. */
 function pluginDetail(item: PluginUpdateItem): string {
-	const note = item.note ? `  ${dim(`(${item.note})`)}` : "";
+	// A note the row's own badge already states is noise, not information. The
+	// DEPRECATED chip and the heading above it both say "no configured
+	// marketplace offers this", so printing the sentence again put the longest
+	// string in the table on the least interesting rows.
+	//
+	// The note stays on the item. The TUI has no heading to lean on and renders
+	// it as that row's only explanation — this is a rendering decision about a
+	// table that carries the fact twice, not a change to what is known.
+	const note =
+		item.note && item.reason !== "not-offered"
+			? `  ${dim(`(${item.note})`)}`
+			: "";
 	switch (item.action) {
 		case "install":
 			return `${item.target ?? "latest"}${note}`;
 		case "update":
+			// The GROUP's page tone, not a literal and not ACTIONS: the arrow and
+			// the target sit in the same row as that group's glyph and chip, so
+			// they must resolve per page from the same place. A hardcoded tone
+			// here is how the row ended up half green and half amber.
 			return `${dim(item.installed ?? "—")} ${fg(
-				brand.warning,
+				groupStyle("Update").text,
 				"→",
-			)} ${fg(brand.warning, item.target ?? "?")}${note}`;
+			)} ${fg(groupStyle("Update").text, item.target ?? "?")}${note}`;
 		case "repair":
 		case "unknown":
 			return `${item.installed ?? "—"}${note}`;
@@ -272,8 +291,11 @@ function binDetail(item: BinUpdateItem, plan: UpdatePlan): string {
 				item.version ? `  ${dim(`pinned ${item.version}`)}` : ""
 			}`;
 		case "upgrade":
-			return `${dim(item.installed ?? "—")} ${fg(brand.warning, "→")} ${fg(
-				brand.warning,
+			return `${dim(item.installed ?? "—")} ${fg(
+				ACTIONS.upgrade.color,
+				"→",
+			)} ${fg(
+				ACTIONS.upgrade.color,
 				item.target ?? "?",
 			)}${command ? `  ${command}` : ""}${
 				// An upgrade that also changes the tool's owner says so here; a
@@ -295,6 +317,183 @@ function binDetail(item: BinUpdateItem, plan: UpdatePlan): string {
  * The bar is the section's whole story in one line — a reader who takes in
  * nothing else knows whether this section is mostly settled or mostly work.
  */
+/**
+ * Which heading a plugin row sits under.
+ *
+ * Read off the plan's machine codes — `action` and `reason` — never the human
+ * note. Five headings, and no more:
+ *
+ *   Update        something an apply would move forward
+ *   Deprecated    no configured marketplace offers it
+ *   Fix required  declared or enabled, with nothing on disk
+ *   Unverified    the check itself did not complete
+ *   Current       settled — the version was compared, or there was none to compare
+ *
+ * `Current` is last on purpose: it is the biggest group and the least
+ * interesting, and leading with it buries the few rows that need a decision.
+ *
+ * UNVERIFIED IS NOT CURRENT, and the two must not share a heading. A row whose
+ * catalog read failed used to land under `Current` carrying a `?` glyph and a
+ * note saying the catalog was unreachable — a row that contradicted the heading
+ * above it, while the closing notices insisted those rows are NOT reported as up
+ * to date. That is a different claim from "nothing could be compared, so we
+ * assume the install is the latest", which IS `current` and reaches it in the
+ * classifier, not here.
+ *
+ * "Unverified" is the word `summaryLine` already prints for this count; it is
+ * this report's existing vocabulary, not a new one.
+ */
+function pluginGroup(item: PluginUpdateItem): string {
+	if (item.action === "update" || item.action === "repair") return "Update";
+	if (item.action === "install") return "Fix required";
+	if (item.action === "unknown") {
+		return item.reason === "not-offered" ? "Deprecated" : "Unverified";
+	}
+	return "Current";
+}
+
+const GROUP_ORDER = [
+	"Update",
+	"Deprecated",
+	"Fix required",
+	"Unverified",
+	"Current",
+];
+
+/**
+ * Colour and emphasis per GROUP.
+ *
+ * "Dim the chrome, saturate the signal" is this file's own rule, stated at the
+ * top; the signal is the groups an apply would act on. Every colour comes from
+ * `brand`, which ui/theme.ts contrast-checks against BOTH a cream and a
+ * near-black terminal, so a light theme needs no second palette.
+ */
+const GROUP_KIND: Record<string, ReportBadgeKind> = {
+	Update: "update",
+	Deprecated: "deprecated",
+	"Fix required": "fix",
+};
+
+interface GroupStyle {
+	/** Heading and glyph, drawn on the page. */
+	text: string;
+	/** Badge fill and its ink. Absent on a chrome group, which carries no badge. */
+	fill?: string;
+	ink?: string;
+	chrome?: boolean;
+}
+
+/**
+ * A group's colours, for the page this run resolved.
+ *
+ * `reportBadge` answers per page — pale fill with deep ink on cream, saturated
+ * fill with pale ink on near-black — so this is the one place the report stops
+ * using a single set of hues for both. `brand` is still right for everything
+ * else here: those tokens are chosen to clear 3:1 as INK on either page, which
+ * is a different question from what a filled chip should look like.
+ */
+function groupStyle(group: string): GroupStyle {
+	const kind = GROUP_KIND[group];
+	if (!kind) return { text: brand.muted, chrome: true };
+	const ink = reportBadge(kind);
+	return { text: ink.text, fill: ink.fill, ink: ink.ink };
+}
+
+/** The badge's word: the heading, uppercased. Never a second vocabulary. */
+function groupBadge(group: string): string {
+	return group.toUpperCase();
+}
+
+/**
+ * Badge column width, from the labels THIS report shows — a run with nothing
+ * deprecated does not pay for the longest word. `width` ignores escape bytes,
+ * so measuring an already painted badge is safe.
+ */
+function badgeWidth(items: PluginUpdateItem[]): number {
+	return Math.max(
+		0,
+		...items
+			.filter((item) => !groupStyle(pluginGroup(item)).chrome)
+			.map((item) => {
+				const style = groupStyle(pluginGroup(item));
+				return (
+					width(
+						badge(
+							groupBadge(pluginGroup(item)),
+							style.fill ?? brand.muted,
+							style.ink,
+						),
+					) + 2
+				);
+			}),
+	);
+}
+
+function pluginRow(
+	item: PluginUpdateItem,
+	nameWidth: number,
+	chipWidth: number,
+): string {
+	const group = pluginGroup(item);
+	const style = groupStyle(group);
+	const name = padEnd(item.pluginId, nameWidth);
+	// Only an actionable row is badged; a chrome row gets the same width in
+	// spaces, so every version still starts in one column.
+	const chip = padEnd(
+		style.chrome
+			? ""
+			: badge(groupBadge(group), style.fill ?? brand.muted, style.ink),
+		chipWidth,
+	);
+	return `${PAD}${fg(style.text, ACTIONS[item.action].glyph)}  ${
+		style.chrome ? dim(name) : name
+	}  ${chip}${pluginDetail(item)}`;
+}
+
+/** The Plugins section: grouped by state, `Current` last. */
+function pluginSection(items: PluginUpdateItem[], nameWidth: number): string[] {
+	if (items.length === 0) return [];
+
+	const byGroup = new Map<string, PluginUpdateItem[]>();
+	for (const item of items) {
+		const group = pluginGroup(item);
+		const list = byGroup.get(group);
+		if (list) list.push(item);
+		else byGroup.set(group, [item]);
+	}
+
+	// GROUP_ORDER first, then anything it does not name. A report may never
+	// silently drop a row: driving the output purely from a fixed list would
+	// render an unexpected group as nothing at all while the header still
+	// counted it.
+	const ordered = [
+		...GROUP_ORDER.filter((g) => byGroup.has(g)),
+		...[...byGroup.keys()].filter((g) => !GROUP_ORDER.includes(g)),
+	];
+
+	const chipWidth = badgeWidth(items);
+	// No bar: it stacked the mix into one strip above groups that already print
+	// their own counts, in a form nobody can read a number off.
+	const lines: string[] = [
+		"",
+		`${PAD}${bold("Plugins")}  ${dim(String(items.length))}`,
+	];
+
+	for (const group of ordered) {
+		const rows = byGroup.get(group);
+		if (!rows || rows.length === 0) continue;
+		lines.push(
+			"",
+			`${PAD}${bold(fg(groupStyle(group).text, group))}  ${dim(
+				String(rows.length),
+			)}`,
+		);
+		for (const row of rows) lines.push(pluginRow(row, nameWidth, chipWidth));
+	}
+
+	return lines;
+}
+
 function section(
 	title: string,
 	rows: Array<{ action: ActionKey; name: string; detail: string }>,
@@ -304,13 +503,6 @@ function section(
 	const counts = new Map<ActionKey, number>();
 	for (const row of rows)
 		counts.set(row.action, (counts.get(row.action) ?? 0) + 1);
-	const bar = stackedBar(
-		BAR,
-		[...counts].map(([action, value]) => ({
-			value,
-			color: ACTIONS[action].color,
-		})),
-	);
 	const legend = [...counts]
 		.map(([action, n]) =>
 			fg(ACTIONS[action].color, `${n} ${ACTIONS[action].label.toLowerCase()}`),
@@ -319,7 +511,7 @@ function section(
 
 	return [
 		"",
-		`${PAD}${bold(padEnd(title, 9))} ${bar} ${dim(
+		`${PAD}${bold(padEnd(title, 9))} ${dim(
 			padStart(String(rows.length), 3),
 		)}  ${legend}`,
 		"",
@@ -341,16 +533,22 @@ export function planReport(plan: UpdatePlan): string[] {
 		...plan.skills.map((s) => width(s.name)),
 	);
 
+	// EVERY planned plugin gets a row. There is no filter here and there must
+	// not be one.
+	//
+	// A previous revision dropped `unknown` + `not-offered` + not-installed rows
+	// — a pin naming a plugin no marketplace offers — on the grounds that a
+	// notice named them instead. That notice did not exist: the function the
+	// comment cited was never written. The row appeared in no table and no
+	// notice, while the closing lines still counted it and said "Reasons are
+	// shown above", pointing at nothing.
+	//
+	// A report may never silently drop a row. That is the whole defect this
+	// file's grouping was written to end, and a filter here reintroduces it in a
+	// form that is harder to see, because the header count agrees with the rows
+	// and only the plan knows something is missing.
 	return [
-		...section(
-			"Plugins",
-			plan.plugins.map((item) => ({
-				action: pluginAction(item),
-				name: item.pluginId,
-				detail: pluginDetail(item),
-			})),
-			nameWidth,
-		),
+		...pluginSection(plan.plugins, nameWidth),
 		...section(
 			"CLI",
 			plan.bins.map((item: BinUpdateItem) => ({
@@ -488,13 +686,6 @@ export function note(text: string): string {
 // false for a plugin whose marketplace publishes no version: re-running changes
 // nothing, and the reader went looking for a network fault that did not exist.
 
-/** Unverified plugins, under the plan. Never "up to date" — that is the point. */
-export function unknownPluginsNotice(count: number): string {
-	return warn(
-		`${bold(String(count))} plugin(s) could not be checked — not applied. They are NOT reported as up to date. Reasons are shown above.`,
-	);
-}
-
 /** Unverified tools, under the plan. */
 export function unknownToolsNotice(count: number, names: string[]): string {
 	return warn(

package/src/cli/update.ts

@@ -88,7 +88,6 @@ import {
 	stepRecord,
 	summaryLine,
 	uncheckedGateNotice,
-	unknownPluginsNotice,
 	unknownToolsNotice,
 	warn as warnLine,
 } from "./update-view.js";
@@ -293,30 +292,13 @@ export async function runUpdateCommand(
 	});
 	steps.marketplaces.detail = [
 		`${refresh.refreshed.length} refreshed`,
-		refresh.autoUpdateDisabled.length > 0
-			? `${refresh.autoUpdateDisabled.length} auto-update off`
-			: "",
 		refresh.failed.length > 0 ? `${refresh.failed.length} failed` : "",
 		refresh.skipped.length > 0 ? `${refresh.skipped.length} skipped` : "",
 	]
 		.filter(Boolean)
 		.join(" · ");
 	if (refresh.failed.length > 0) steps.marketplaces.state = "fail";
-	else if (refresh.autoUpdateDisabled.length > 0)
-		steps.marketplaces.state = "warn";
 
-	for (const name of refresh.autoUpdateDisabled) {
-		notices.push(
-			warnLine(
-				`${bold(name)}: auto-update disabled — its catalog will not refresh, so updates stay hidden.`,
-			),
-		);
-		notices.push(
-			noteLine(
-				`claude plugin marketplace update ${name}  # to refresh it once`,
-			),
-		);
-	}
 	for (const name of refresh.failed) {
 		notices.push(
 			failLine(
@@ -405,11 +387,16 @@ export async function runUpdateCommand(
 		.map((b) => b.name);
 	const toolUnknownLine = () =>
 		unknownToolsNotice(counts.unknownTools, unknownToolNames);
-	if (counts.unknownPlugins > 0 || counts.unknownTools > 0) console.log("");
-	if (counts.unknownPlugins > 0) {
-		console.log(unknownPluginsNotice(counts.unknownPlugins));
+	// No plugin equivalent of `toolUnknownLine`. Every unverified plugin is
+	// already a row in the table above, under a heading that names its state,
+	// so a trailing "N plugin(s) could not be checked" restated the table in
+	// prose and — since the grouping landed — miscounted it: the count is raw
+	// `unknown`, which now includes rows filed under Current. A tool has no
+	// such row, which is why that notice stays and names them.
+	if (counts.unknownTools > 0) {
+		console.log("");
+		console.log(toolUnknownLine());
 	}
-	if (counts.unknownTools > 0) console.log(toolUnknownLine());
 
 	// `--check` gates on planIsBehind, not planHasWork. An already-installed
 	// skill is re-fetched on every apply because its manifest ref carries no

package/src/main.tsx

@@ -84,7 +84,7 @@ async function main(): Promise<void> {
 	// top-level flags (--version/--help). A bare invocation falls through to
 	// the interactive TUI below.
 	const { route } = await import("./cli/router.js");
-	const outcome = await route(args, VERSION);
+	const outcome = await route(args, VERSION, themeEnv);
 	if (outcome.handled) {
 		process.exit(outcome.exitCode ?? 0);
 	}

package/src/services/claude-settings.ts

@@ -816,24 +816,15 @@ async function writeKnownMarketplaces(
 }
 
 /**
- * Set autoUpdate flag for a marketplace in known_marketplaces.json
- * This is where Claude Code actually reads the autoUpdate setting
- */
-export async function setMarketplaceAutoUpdate(
-	marketplaceName: string,
-	autoUpdate: boolean,
-): Promise<boolean> {
-	const known = await readKnownMarketplaces();
-	if (known[marketplaceName]) {
-		known[marketplaceName].autoUpdate = autoUpdate;
-		await writeKnownMarketplaces(known);
-		return true;
-	}
-	return false; // Marketplace not yet installed by Claude Code
-}
-
-/**
- * Get autoUpdate status for a marketplace
+ * Read a marketplace's `autoUpdate` flag — Claude Code's refresh policy.
+ *
+ * READ ONLY, and there is deliberately no setter. `autoUpdate` is Claude Code's
+ * field (50 occurrences in the 2.1.269 binary, with its own manifest-schema
+ * entry and a "Synced autoUpdate= from settings" path), so Claude Code decides
+ * its value. magus used to write `true` into every MadAppGang entry on TUI
+ * startup, which is a direct write to `known_marketplaces.json` — the file at
+ * the top of CLAUDE.md's never-write-directly list — and it fought Claude Code's
+ * own sync for ownership of the same byte.
  */
 export async function getMarketplaceAutoUpdate(
 	marketplaceName: string,
@@ -843,7 +834,6 @@ export async function getMarketplaceAutoUpdate(
 }
 
 export interface MarketplaceRecoveryResult {
-	enabledAutoUpdate: string[];
 	removed: string[];
 	reregistered: string[];
 }
@@ -1189,24 +1179,19 @@ export async function migrateMarketplaceRename(
 	return result;
 }
 
-/**
- * Check if a marketplace is from Magus (MadAppGang)
- */
-function isMadAppGangMarketplace(entry: KnownMarketplaceEntry): boolean {
-	const repo = entry.source?.repo?.toLowerCase() || "";
-	return repo.includes("madappgang");
-}
-
 /**
  * Recover/sync marketplace settings:
- * - Enable autoUpdate for Magus marketplaces that don't have it set
  * - Remove entries for marketplaces whose installLocation no longer exists
  * - Fix stale "directory" source for known Magus marketplaces that should be "github"
+ *
+ * It does NOT touch `autoUpdate`. It used to set it to `true` on every
+ * MadAppGang entry whose flag was unset, on every TUI startup — writing a
+ * Claude Code-owned field that Claude Code also syncs from settings. See
+ * {@link getMarketplaceAutoUpdate}.
  */
 export async function recoverMarketplaceSettings(): Promise<MarketplaceRecoveryResult> {
 	const known = await readKnownMarketplaces();
 	const result: MarketplaceRecoveryResult = {
-		enabledAutoUpdate: [],
 		removed: [],
 		reregistered: [],
 	};
@@ -1249,21 +1234,11 @@ export async function recoverMarketplaceSettings(): Promise<MarketplaceRecoveryR
 			}
 		}
 
-		// Enable autoUpdate if not set - only for Magus (MadAppGang) marketplaces
-		if (entry.autoUpdate === undefined && isMadAppGangMarketplace(entry)) {
-			entry.autoUpdate = true;
-			result.enabledAutoUpdate.push(name);
-		}
-
 		updatedKnown[name] = entry;
 	}
 
 	// Write back if any changes were made
-	if (
-		result.enabledAutoUpdate.length > 0 ||
-		result.removed.length > 0 ||
-		result.reregistered.length > 0
-	) {
+	if (result.removed.length > 0 || result.reregistered.length > 0) {
 		await writeKnownMarketplaces(updatedKnown);
 	}
 

package/src/services/local-marketplace.ts

@@ -64,17 +64,73 @@ interface KnownMarketplaceEntry {
 type KnownMarketplaces = Record<string, KnownMarketplaceEntry>;
 
 /**
- * Read known_marketplaces.json (Claude Code's internal marketplace tracking)
+ * Read known_marketplaces.json, or null when it cannot be read honestly.
+ *
+ * The null matters. {@link readKnownMarketplaces} collapses "absent",
+ * "unparseable" and "genuinely empty" into `{}`, which is fine for a lookup and
+ * catastrophic for a filter: intersecting the marketplaces directory against an
+ * empty registry deletes every marketplace, and every installed plugin then
+ * reports as no longer published. A registry we could not read is UNKNOWN, and
+ * unknown must not render as a determinate negative.
  */
-async function readKnownMarketplaces(): Promise<KnownMarketplaces> {
+async function readKnownMarketplacesOrNull(): Promise<KnownMarketplaces | null> {
 	try {
-		if (await fs.pathExists(KNOWN_MARKETPLACES_FILE)) {
-			return await fs.readJson(KNOWN_MARKETPLACES_FILE);
+		if (!(await fs.pathExists(KNOWN_MARKETPLACES_FILE))) return null;
+		const parsed = await fs.readJson(KNOWN_MARKETPLACES_FILE);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			return null;
 		}
+		return parsed as KnownMarketplaces;
 	} catch {
-		// Return empty if can't read
+		return null;
+	}
+}
+
+/**
+ * Read known_marketplaces.json (Claude Code's internal marketplace tracking)
+ */
+async function readKnownMarketplaces(): Promise<KnownMarketplaces> {
+	return (await readKnownMarketplacesOrNull()) ?? {};
+}
+
+/**
+ * Directory names a parsed `known_marketplaces.json` registers, or null when it
+ * says nothing usable.
+ *
+ * Pure, and exported, because `scanLocalMarketplaces` resolves its paths from
+ * `os.homedir()` at module load and cannot be pointed at a temp directory. The
+ * decision this encodes is the part worth testing; the IO around it is not.
+ *
+ * Keyed by BOTH the registry key and the basename of `installLocation`: the two
+ * are normally equal and nothing enforces it, and dropping a real marketplace
+ * is far worse than keeping a stray directory.
+ *
+ * An empty object is an ANSWER — nothing is registered — and filters everything
+ * out. Only unusable input is null. The distinction lives in
+ * {@link readKnownMarketplacesOrNull}, which returns null for an absent file,
+ * so a machine that has never added a marketplace stays permissive.
+ */
+export function registeredMarketplaceNames(
+	parsed: unknown,
+): Set<string> | null {
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		return null;
+	}
+	const names = new Set<string>();
+	for (const [name, entry] of Object.entries(
+		parsed as Record<string, unknown>,
+	)) {
+		names.add(name);
+		const loc = (entry as { installLocation?: unknown })?.installLocation;
+		if (typeof loc === "string" && loc.length > 0) {
+			names.add(path.basename(loc));
+		}
 	}
-	return {};
+	return names;
+}
+
+async function registeredDirNames(): Promise<Set<string> | null> {
+	return registeredMarketplaceNames(await readKnownMarketplacesOrNull());
 }
 
 /**
@@ -321,6 +377,19 @@ export async function scanLocalMarketplaces(): Promise<
 > {
 	const marketplaces = new Map<string, LocalMarketplace>();
 
+	// A directory is not a marketplace; a REGISTRY ENTRY is. Null means the
+	// registry could not be read, and then every directory is kept — see
+	// `registeredDirNames`.
+	//
+	// Claude Code refreshes a marketplace by delete-then-clone and leaves
+	// `<name>.bak` behind. An unfiltered scan treated that backup as a real
+	// marketplace, which cost the reporter twice: `magus.bak` shadowed the real
+	// `magus` in `getAllMarketplaces()` (deduped by repo, first-come) so the real
+	// one vanished from the plugin list entirely, and later it became the target
+	// of a nonsense label — `kanban@magus … moved → magus.bak`. `claude plugin
+	// marketplace list` never showed it, because Claude Code reads the registry.
+	const registered = await registeredDirNames();
+
 	// 1. Scan marketplaces from the standard directory
 	if (await fs.pathExists(CLAUDE_PLUGINS_DIR)) {
 		try {
@@ -330,6 +399,7 @@ export async function scanLocalMarketplaces(): Promise<
 
 			for (const entry of entries) {
 				if (!entry.isDirectory()) continue;
+				if (registered && !registered.has(entry.name)) continue;
 
 				const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, entry.name);
 				const marketplace = await scanSingleMarketplace(