magus-cli 7.0.0 → 7.1.0

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

@@ -108,48 +108,58 @@ function cliNote(
 }
 
 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}`);
+	// A sha install against a catalog that publishes no version is `current`
+	// now — we assume what is installed is the latest rather than warning about
+	// a comparison that can never be made. R2 still holds and is still the point
+	// of this file: whatever the CLI says, the row says, word for word.
+	test("a sha-versioned install says exactly what the CLI says", () => {
+		const row = rows([CODE_REVIEW]).get(CODE_REVIEW.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("current");
+		// No note means no suffix. The row is the version and nothing else.
+		expect(cliNote([CODE_REVIEW], CODE_REVIEW.id)).toBeUndefined();
+		const { text } = pluginRowText(row);
+		expect(text).toBe(" v3ea32df27be7");
+		// The row never invents a vocabulary the CLI does not use.
 		expect(text).not.toContain("not comparable");
+		expect(text).not.toContain("?");
 	});
 
-	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.
+	test('a "0.0.0" install is never printed as a version', () => {
+		// "0.0.0" means installed with an unknown version — Anthropic's official
+		// plugins record exactly that. It is not a version anyone can act on, so
+		// it is never shown, and no status clause may be gated on showing it.
 		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(row.status?.action).toBe("current");
+		const { text } = pluginRowText(row);
 		expect(text).not.toContain("0.0.0");
-		expect(segments.at(-1)?.tone).toBe("warning");
+		expect(text).toBe(cliNote([ZERO], ZERO.id) ?? "");
 	});
 });
 
 describe("pluginRowText — orphans say what the CLI says (F9)", () => {
-	test("an orphan that moved names where it went", () => {
+	// The row NEVER guesses where an orphan went. That guess was a bare name
+	// match, and it cannot tell a move from a dual publication: claudish ships
+	// to two marketplaces with both copies installed, and the row announced
+	// "moved → magus" about a plugin that had not moved anywhere.
+	test("an orphan is 'not offered', and never names a destination", () => {
 		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");
+		expect(cliNote([seo], seo.id)).toBe(
+			"not offered by any configured marketplace",
+		);
+		expect(pluginRowText(row).text).toBe(
+			" v1.8.0 ? not offered by any configured marketplace",
+		);
+		expect(pluginRowText(row).text).not.toMatch(/moved/i);
 	});
 
-	test("an orphan with no movedTo, from a marketplace we read, is 'not offered'", () => {
+	test("an orphan from a marketplace we DID read is 'not offered'", () => {
 		const gone = info({
 			id: "gone@magus",
 			version: "2.0.0",
@@ -171,7 +181,6 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 			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);

package/src/__tests__/theme-env.test.ts

@@ -278,4 +278,33 @@ describe("main.tsx order", () => {
 		}
 		expect(code).toMatch(/env:\s*themeEnv\b/);
 	});
+
+	// T-env-3 and T-env-3b guard main.tsx, and main.tsx ALONE — which is exactly
+	// how this escaped. The CLI report's theme resolution was added in router.ts
+	// and called `snapshotThemeEnv()` there, a second snapshot taken from inside
+	// `route()`, long after `loadProjectDotenv()` merged the project's .env into
+	// process.env. A checked-out repo could set the palette for every subcommand
+	// while both tests above stayed green.
+	//
+	// The rule generalises: main.tsx owns the snapshot because it is the only
+	// code that runs before the dotenv load. Everything downstream is HANDED the
+	// value.
+	test("T-env-3c: no module downstream of the dotenv load takes its own snapshot", () => {
+		const downstream = ["cli/router.ts", "cli/update.ts", "cli/doctor.ts"];
+		for (const rel of downstream) {
+			const src = stripComments(
+				readFileSync(path.join(import.meta.dir, "..", rel), "utf-8"),
+			);
+			expect({ rel, calls: /snapshotThemeEnv\s*\(/.test(src) }).toEqual({
+				rel,
+				calls: false,
+			});
+		}
+	});
+
+	test("T-env-3d: main.tsx hands its snapshot to route()", () => {
+		// Without this the router falls back to "no opinion" and every subcommand
+		// silently reverts to the dark default on a light terminal.
+		expect(code).toMatch(/route\([^)]*themeEnv[^)]*\)/);
+	});
 });

package/src/__tests__/update-plan.test.ts

@@ -403,11 +403,19 @@ describe("per-scope decisions — a stale scope is never masked", () => {
 		expect(item.reason).toBe("up-to-date");
 	});
 
-	test("an installed plugin whose catalog declares no version is 'unknown'", () => {
-		// This fixture puts dev@magus IN the catalog with a null version, so it is
-		// the declares-no-version case, not the withdrawn one — the assertion used
-		// to say "not offered", which is what conflated them. 278 of the 292
-		// plugins in claude-plugins-official are in exactly this state.
+	// REVERSES an earlier decision, deliberately. This used to be `unknown` with
+	// a note reading "publishes no version", which put 278 of the 292 plugins in
+	// claude-plugins-official into a warning state that no action could ever
+	// clear: the marketplace does not publish versions, so re-running changes
+	// nothing and the row stays amber forever.
+	//
+	// The rule now is: if we cannot compare, assume what is installed is the
+	// latest. The machine code still says WHY (`no-published-version`), so the
+	// distinction is not lost — it just stops being reported as a problem. Do not
+	// "fix" this back without changing that rule first.
+	test("a catalog that declares no version leaves the install current", () => {
+		// dev@magus is IN the catalog with a null version — the declares-no-version
+		// case, not the withdrawn one.
 		const [item] = planPluginUpdates(
 			{ "dev@magus": "latest" },
 			catalog(
@@ -418,9 +426,12 @@ describe("per-scope decisions — a stale scope is never masked", () => {
 				}),
 			),
 		);
-		expect(item.action).toBe("unknown");
-		expect(item.note).toContain("publishes no version");
+		expect(item.action).toBe("current");
 		expect(item.reason).toBe("no-published-version");
+		// No note: there is nothing for the reader to do about it.
+		expect(item.note).toBeUndefined();
+		// And it is not confused with the withdrawn case, which is the next test.
+		expect(item.reason).not.toBe("not-offered");
 	});
 
 	test("an installed plugin ABSENT from every catalog is 'not offered'", () => {
@@ -919,14 +930,13 @@ describe("planHasWork / summarizePlan", () => {
 	test("unknown splits into plugins and tools, and the total is their sum", () => {
 		const p = plan({
 			plugins: planPluginUpdates(
+				// `a@magus` is an ORPHAN — no marketplace offers it — which is the
+				// one remaining way a plugin is genuinely `unknown`. A catalog that
+				// merely declares no version is `current` now, so using that here
+				// would leave `unknownPlugins` at 0 and the sum would hold
+				// trivially, testing nothing.
 				{ "a@magus": "latest" },
-				catalog(
-					info({
-						id: "a@magus",
-						version: null,
-						projectScope: { enabled: true, version: "abc123" },
-					}),
-				),
+				catalog(orphan("a@magus", "1.0.0")),
 			),
 			bins: planBinUpdates(
 				[
@@ -991,19 +1001,24 @@ describe("classifyPlugin — an orphan is never 'current'", () => {
 		expect(item.scopes).toEqual([]);
 	});
 
-	test("an orphan another marketplace publishes is 'moved', naming it", () => {
+	// `moved` is GONE, and `movedTo` with it. It was inferred from a bare name
+	// match: a plugin published to two marketplaces — claudish is — reported
+	// "moved → magus" when nothing had moved and both copies were installed.
+	// The inference cannot tell a move from a dual publication, so it is not made
+	// at all. An orphan is `not-offered`, which is a fact rather than a guess.
+	test("an orphan is 'not offered', and never guesses where it went", () => {
 		const [item] = planPluginUpdates(
 			{ "seo@magus": "latest" },
 			catalog(
-				orphan("seo@magus", "1.8.0", { movedTo: "magus-marketing" }),
+				orphan("seo@magus", "1.8.0"),
 				info({ id: "dev@magus", version: "4.7.0" }),
 			),
 		);
 		expect(item).toMatchObject({
 			action: "unknown",
-			reason: "moved",
-			note: "moved to magus-marketing",
+			reason: "not-offered",
 		});
+		expect(item.note).not.toMatch(/moved/i);
 	});
 
 	test("an orphan whose marketplace we DID read is 'not offered'", () => {
@@ -1060,9 +1075,17 @@ describe("classifyPlugin — an orphan is never 'current'", () => {
 	});
 });
 
-describe("classifyPlugin — an exact pin that cannot be ordered is unknown (F3)", () => {
-	test("REGRESSION: a pinned plugin at an unorderable version used to be current", () => {
-		// The "latest" path already refused this; the exact-pin path did not.
+// REVERSES F3, deliberately. `unorderable` is gone as a state: when two
+// versions cannot be ordered we assume what is installed IS the latest, rather
+// than raising a warning nothing can clear.
+//
+// F3's premise was that "cannot compare" might hide a plugin that is behind.
+// True, but the cost was paid on every run by rows that were fine — an install
+// recorded as a commit sha can never be ordered against a semver pin, so the
+// warning was permanent and unactionable. Do not restore `unorderable` without
+// changing that rule first.
+describe("classifyPlugin — an unorderable version is assumed current", () => {
+	test("a pinned plugin whose install cannot be ordered is current", () => {
 		const [item] = planPluginUpdates(
 			{ "playground@official": "7.3.0" },
 			catalog(
@@ -1073,16 +1096,13 @@ describe("classifyPlugin — an exact pin that cannot be ordered is unknown (F3)
 				}),
 			),
 		);
-		expect(item).toMatchObject({
-			action: "unknown",
-			reason: "unorderable",
-			target: null,
-			scopes: [],
-			note: "installed version cannot be compared with the published 7.3.0",
-		});
+		expect(item.action).toBe("current");
+		expect(item.reason).not.toBe("unorderable");
+		// Nothing is planned against it, which is the part F3 actually protected.
+		expect(item.scopes).toEqual([]);
 	});
 
-	test("with no published version the note names the pin instead", () => {
+	test("no published version, under an exact pin, is also current", () => {
 		const [item] = planPluginUpdates(
 			{ "playground@official": "7.3.0" },
 			catalog(
@@ -1093,11 +1113,14 @@ describe("classifyPlugin — an exact pin that cannot be ordered is unknown (F3)
 				}),
 			),
 		);
-		expect(item).toMatchObject({
-			action: "unknown",
-			reason: "unorderable",
-			note: "installed version cannot be compared with the pin 7.3.0",
-		});
+		expect(item.action).toBe("current");
+		expect(item.note).toBeUndefined();
+		// The exact-pin path reports `up-to-date` here where the "latest" path
+		// reports `no-published-version` — same verdict, different machine code.
+		// Asserted as observed rather than as preferred: nothing renders the two
+		// differently today, and forcing them to agree is a change to the
+		// classifier, not to this test.
+		expect(item.reason).toBe("up-to-date");
 	});
 
 	test("a scope that IS behind still wins: it is planned, not hidden", () => {

package/src/__tests__/version-unknown-state.test.ts

@@ -247,10 +247,16 @@ describe("REVIEW-B regressions — found by the patch-quality panel", () => {
 		expect(items[0]?.reason).toBe("absent");
 	});
 
-	test("an installed version that cannot be compared is unknown, not current", () => {
-		// 21 registry rows carry the literal string "unknown" as their version.
-		// Against a semver catalog they are unorderable, so no scope is provably
-		// behind — and falling through to `current` claims they are up to date.
+	// REVIEW-B's finding is accepted and its remedy REVERSED. 21 registry rows
+	// carry the literal string "unknown" as their version; against a semver
+	// catalog they are unorderable, so nothing is provably behind. REVIEW-B
+	// concluded that made `current` a false claim.
+	//
+	// The claim is now explicitly "nothing is KNOWN to be behind", and that is
+	// what `current` means here. Raising a warning instead put a permanent amber
+	// row in front of the user with no action that could ever clear it, which is
+	// a worse falsehood: it says "do something" when there is nothing to do.
+	test("an installed version that cannot be compared is assumed current", () => {
 		const items = planPluginUpdates(
 			{ "playground@official": "latest" },
 			new Map([
@@ -264,9 +270,11 @@ describe("REVIEW-B regressions — found by the patch-quality panel", () => {
 				],
 			]),
 		);
-		expect(items[0]?.action).toBe("unknown");
-		expect(items[0]?.note).toContain("cannot be compared");
-		expect(items[0]?.reason).toBe("unorderable");
+		expect(items[0]?.action).toBe("current");
+		expect(items[0]?.reason).not.toBe("unorderable");
+		// The row stays silent: no note, and nothing planned against it.
+		expect(items[0]?.note).toBeUndefined();
+		expect(items[0]?.scopes).toEqual([]);
 	});
 
 	test("a genuinely current install is still current", () => {
@@ -335,10 +343,14 @@ describe("installed with no comparable catalog version — two different causes"
 				],
 			]),
 		);
-		expect(items[0]?.action).toBe("unknown");
-		expect(items[0]?.note).toContain("publishes no version");
-		expect(items[0]?.note).not.toContain("not offered");
+		// The distinction this test exists for is between the two REASONS, and it
+		// still holds. What changed is the verdict: declaring no version is not a
+		// problem, so the row is `current` and says nothing. Being withdrawn IS a
+		// problem, so the next test's row is `unknown` and says so.
 		expect(items[0]?.reason).toBe("no-published-version");
+		expect(items[0]?.reason).not.toBe("not-offered");
+		expect(items[0]?.action).toBe("current");
+		expect(items[0]?.note).toBeUndefined();
 	});
 
 	test("absent from the catalog entirely IS 'not offered'", () => {
@@ -363,12 +375,15 @@ describe("installed with no comparable catalog version — two different causes"
 	});
 });
 
-describe('the "0.0.0" registry value is unknown, never healthy', () => {
+describe('the "0.0.0" registry value keeps its reason', () => {
 	test("installed at 0.0.0 with no published version is no-published-version", () => {
 		// Real: explanatory-output-style@claude-plugins-official is recorded as
 		// "0.0.0" in the registry for many project paths, and its marketplace
-		// publishes no version. The TUI row hid every status suffix behind a
-		// displayable version, so this row rendered with none at all.
+		// publishes no version.
+		//
+		// "0.0.0" must never silently become a DIFFERENT reason — that is what
+		// this pins. The verdict is `current`: there is no published version to
+		// be behind, so there is nothing to report and nothing to do.
 		const items = planPluginUpdates(
 			{ "explanatory-output-style@official": "latest" },
 			new Map([
@@ -382,7 +397,7 @@ describe('the "0.0.0" registry value is unknown, never healthy', () => {
 				],
 			]),
 		);
-		expect(items[0]?.action).toBe("unknown");
 		expect(items[0]?.reason).toBe("no-published-version");
+		expect(items[0]?.action).toBe("current");
 	});
 });

package/src/cli/ansi.ts

@@ -21,6 +21,7 @@
  * No OpenTUI type crosses this boundary: hex in, escaped string out.
  */
 
+import { barTrack } from "../ui/theme-mode.js";
 import { brand } from "../ui/theme.js";
 
 // -- colour capability -------------------------------------------------------
@@ -372,14 +373,17 @@ const FILL = "█";
 const TRACK = "░";
 
 /**
- * The unfilled part of a bar.
+ * The unfilled part of a bar, resolved per page.
  *
- * Deliberately much darker than `brand.muted`. At full `muted` a 20-cell `░`
- * track reads as hatched texture rather than as emptiness, and it competes with
- * the fill for the eye — which is the opposite of "dim the chrome, saturate the
- * signal". A track is chrome.
+ * At full `brand.muted` a 20-cell `░` track reads as hatched texture rather
+ * than as emptiness, and competes with the fill — the opposite of "dim the
+ * chrome, saturate the signal". A track is chrome.
+ *
+ * Which grey is quiet depends on the page, so the two values and the numbers
+ * behind them live in `ui/theme-mode.ts`. Resolved per CALL, never hoisted into
+ * a const: the mode is set at startup by the router, after this module loads.
  */
-const TRACK_COLOR = darken(brand.muted, 0.68);
+const TRACK_COLOR = (): string => barTrack();
 
 /**
  * Gradient meter: `cells` wide, one blended colour per filled cell.
@@ -402,7 +406,7 @@ export function meter(
 	);
 	let out = "";
 	for (let i = 0; i < cells; i++) {
-		out += i < filled ? fg(cols[i], FILL) : fg(TRACK_COLOR, TRACK);
+		out += i < filled ? fg(cols[i], FILL) : fg(TRACK_COLOR(), TRACK);
 	}
 	return out;
 }
@@ -433,7 +437,7 @@ export interface BarSegment {
 export function stackedBar(cells: number, segments: BarSegment[]): string {
 	if (cells <= 0) return "";
 	let live = segments.filter((s) => s.value > 0);
-	if (live.length === 0) return fg(TRACK_COLOR, TRACK.repeat(cells));
+	if (live.length === 0) return fg(TRACK_COLOR(), TRACK.repeat(cells));
 	// More segments than cells: keep the biggest `cells` of them, in place.
 	if (live.length > cells) {
 		const cutoff = [...live]
@@ -488,15 +492,19 @@ export function sweep(
 		const heat = behind >= 0 && behind < band ? 1 - behind / band : 0;
 		out +=
 			heat <= 0
-				? fg(TRACK_COLOR, TRACK)
+				? fg(TRACK_COLOR(), TRACK)
 				: fg(mix(darken(hue, 0.75), hue, heat), FILL);
 	}
 	return out;
 }
 
 /** A discrete status, as dark-or-white ink on a saturated fill. */
-export function badge(label: string, hex: string): string {
-	return on(hex, inkOn(hex), ` ${label} `);
+export function badge(label: string, hex: string, ink?: string): string {
+	// `inkOn` picks black or white by luminance, which is right for a saturated
+	// fill and blunt for a pale one: a soft ochre chip reads better with the deep
+	// member of its own family than with flat black. A caller carrying a measured
+	// pair passes it; everyone else keeps the automatic choice.
+	return on(hex, ink ?? inkOn(hex), ` ${label} `);
 }
 
 /**

package/src/cli/router.ts

@@ -8,7 +8,7 @@
 
 import type { ThemeMode } from "@opentui/core";
 import { checkForUpdates } from "../services/version-check.js";
-import { parseThemeWord } from "../ui/theme-resolve.js";
+import { type ThemeEnv, parseThemeWord } from "../ui/theme-resolve.js";
 import { runDoctorCommand } from "./doctor.js";
 import { runInstallCommand } from "./install.js";
 import { runModelsCommand } from "./models.js";
@@ -84,9 +84,32 @@ const HANDLED = (exitCode: number): RouteOutcome => ({
 });
 const LAUNCH_TUI: RouteOutcome = { handled: false, launchTui: true };
 
+/**
+ * Every name the switch below handles.
+ *
+ * Declared once so the theme resolution and the dispatch cannot disagree about
+ * what counts as a subcommand — a name in one and not the other would print an
+ * unthemed report, which is the bug this set exists to prevent.
+ */
+const SUBCOMMANDS = new Set([
+	"update",
+	"upgrade",
+	"install",
+	"profile",
+	"models",
+	"doctor",
+]);
+
 export async function route(
 	argv: string[],
 	version: string,
+	/**
+	 * The theme environment, snapshotted by main.tsx BEFORE it loads a project's
+	 * .env. Optional only so a test may call `route` without one; production
+	 * always passes it, and omitting it falls back to "no opinion" (dark) rather
+	 * than reading a process.env that a project may by then have written into.
+	 */
+	themeEnv?: ThemeEnv,
 ): Promise<RouteOutcome> {
 	// Top-level flags take precedence over any command token.
 	if (argv.includes("--version") || argv.includes("-v")) {
@@ -111,9 +134,43 @@ export async function route(
 	}
 
 	// Dispatch on argv with the theme tokens removed, so `--theme dark update`
-	// still runs `update`. Subcommands ignore the flag; only the TUI carries it.
+	// still runs `update`.
 	const [command, ...rest] = themeFlag.rest;
 
+	// Every subcommand paints, and until now only the TUI ever asked which page it
+	// was painting on: `setThemeMode` was called in tui.tsx alone, so `magus
+	// update` kept the "dark" default and printed dark-page fills on a cream
+	// terminal. That is why the report read harsh next to the Models screen.
+	//
+	// No probe here. There is no renderer to ask, and a report must not block on a
+	// terminal reply — so this resolves from the flag, MAGUS_THEME, TERM_THEME
+	// and COLORFGBG, and still falls back to dark when nothing answers, exactly as
+	// before. The TUI keeps its own probing resolution in tui.tsx.
+	//
+	// `themeEnv` is HANDED IN, never re-snapshotted here. main.tsx takes it as
+	// its very first act, before `loadProjectDotenv()` merges a project's .env
+	// into process.env — so the theme comes from the environment magus was
+	// started with and never from the project being inspected. Calling
+	// `snapshotThemeEnv()` at this point would run after that merge and quietly
+	// hand a checked-out repo control of the palette.
+	if (command !== undefined && SUBCOMMANDS.has(command)) {
+		const [{ resolveTheme }, { setThemeMode }] = await Promise.all([
+			import("../ui/theme-resolve.js"),
+			import("../ui/theme-mode.js"),
+		]);
+		const { mode } = await resolveTheme({
+			flag: themeFlag.theme,
+			env: themeEnv ?? {},
+			// A report is not an interactive session: it may be piped, redirected
+			// or read by CI. `isInteractive: false` is what stops the probe being
+			// consulted at all, and the null probe satisfies the signature without
+			// ever writing an OSC query into someone's scrollback.
+			isInteractive: false,
+			probe: async () => null,
+		});
+		setThemeMode(mode);
+	}
+
 	switch (command) {
 		case "update":
 			return HANDLED(await runUpdateCommand(rest));