magus-cli 7.0.0 → 7.2.0

package/src/cli/tui-prompt.tsx

@@ -0,0 +1,143 @@
+/**
+ * One OpenTUI dialog, for a command that is otherwise not a TUI.
+ *
+ * `magus update` prints a report and exits; it is not the interactive app. But
+ * a question it must ask deserves the same dialog the TUI asks with, so this
+ * mounts the REAL `SelectModal` — the component tab 5 and tab 0 use — for the
+ * length of one question, then tears the renderer down and lets the command
+ * carry on printing. Nothing here re-draws a list, a border or a highlight: the
+ * component and the theme own all of that, and a second implementation is how
+ * the two surfaces drift apart.
+ *
+ * Every import of `@opentui/*` and `ui/` is DYNAMIC. `main.tsx` splits the TUI
+ * out precisely so `magus hook …`, which Claude Code runs on every matching
+ * tool call, never pays to load the renderer — a static import here would undo
+ * that for every command that imports this module's file, whether or not it
+ * ever asks a question.
+ *
+ * `screenMode: "main-screen"` keeps the dialog in the scrollback beside the
+ * report. The alternate screen would take the terminal over and then hand back
+ * a screen with no trace the question was ever asked.
+ */
+
+import type { SelectOption } from "../ui/state/types.js";
+
+export interface SelectDialogInput {
+	title: string;
+	message: string;
+	options: SelectOption[];
+	/** Row to start on. Defaults to the first. */
+	defaultIndex?: number;
+}
+
+/**
+ * Ask the user to pick one option. Resolves to the chosen value, or null when
+ * they cancel with Esc or Ctrl+C — the caller decides whether that is fatal.
+ *
+ * Falls back to `null` when stdin or stdout is not a TTY. A renderer needs both:
+ * `magus update > file` has a TTY stdin and a pipe for stdout, and mounting
+ * there writes escape sequences into the file.
+ */
+export async function selectDialog(
+	input: SelectDialogInput,
+): Promise<string | null> {
+	if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+		return null;
+	}
+
+	const [{ createCliRenderer }, { createRoot }, React, modals, dimensions] =
+		await Promise.all([
+			import("@opentui/core"),
+			import("@opentui/react"),
+			import("react"),
+			import("../ui/components/modals/index.js"),
+			import("../ui/state/DimensionsContext.js"),
+		]);
+
+	const renderer = await createCliRenderer({
+		screenMode: "main-screen",
+		// BOTH, so the renderer registers no handler of its own and teardown
+		// below is the only path. With either left at its default, a Ctrl+C
+		// destroys the renderer underneath this promise and it never settles.
+		exitSignals: [],
+		exitOnCtrlC: false,
+	});
+
+	const root = createRoot(renderer);
+
+	return await new Promise<string | null>((resolve) => {
+		// Clamped, not trusted: a caller computing an index from a list it built
+		// separately could hand over one that is out of range, and a cursor
+		// pointing past the end makes Enter resolve to null.
+		let index = Math.min(
+			Math.max(0, input.defaultIndex ?? 0),
+			Math.max(0, input.options.length - 1),
+		);
+		let done = false;
+
+		const finish = (value: string | null): void => {
+			if (done) return;
+			done = true;
+			renderer.keyInput.off("keypress", onKey);
+			root.unmount();
+			renderer.destroy();
+			resolve(value);
+		};
+
+		function onKey(key: {
+			name?: string;
+			ctrl?: boolean;
+			sequence?: string;
+		}): void {
+			if ((key.ctrl && key.name === "c") || key.name === "escape") {
+				finish(null);
+				return;
+			}
+			if (key.name === "return" || key.name === "enter") {
+				finish(input.options[index]?.value ?? null);
+				return;
+			}
+			if (key.name === "up" || key.name === "k") {
+				index = (index - 1 + input.options.length) % input.options.length;
+				draw();
+				return;
+			}
+			if (key.name === "down" || key.name === "j") {
+				index = (index + 1) % input.options.length;
+				draw();
+				return;
+			}
+			// The numbers stay live: the list is short, and the plain-text prompt
+			// this replaced numbered it, so the habit already exists.
+			const digit = Number(key.sequence);
+			if (
+				Number.isInteger(digit) &&
+				digit >= 1 &&
+				digit <= input.options.length
+			) {
+				index = digit - 1;
+				finish(input.options[index]?.value ?? null);
+			}
+		}
+
+		const draw = (): void => {
+			root.render(
+				React.createElement(
+					dimensions.DimensionsProvider,
+					null,
+					React.createElement(modals.SelectModal, {
+						title: input.title,
+						message: input.message,
+						options: input.options,
+						defaultIndex: index,
+						onSelect: finish,
+						onCancel: () => finish(null),
+					}),
+				),
+			);
+		};
+
+		renderer.keyInput.on("keypress", onKey);
+		draw();
+	});
+}

package/src/cli/update-view.ts

@@ -31,11 +31,13 @@ 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 {
 	badge,
 	bold,
+	dialog,
 	dim,
 	elapsed,
 	fg,
@@ -84,8 +86,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 +212,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 +241,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 +292,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 +318,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 +504,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 +512,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 +534,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 +687,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

@@ -70,8 +70,9 @@ import {
 } from "../services/update-plan.js";
 import { brand } from "../ui/theme.js";
 import { bold, dim, fg, width } from "./ansi.js";
-import { ensureManifest } from "./bootstrap.js";
+import { ensureManifest, requireActiveProfile } from "./bootstrap.js";
 import { LiveRegion, withPaused } from "./live.js";
+import { selectDialog } from "./tui-prompt.js";
 import {
 	type ApplyState,
 	type Step,
@@ -88,7 +89,6 @@ import {
 	stepRecord,
 	summaryLine,
 	uncheckedGateNotice,
-	unknownPluginsNotice,
 	unknownToolsNotice,
 	warn as warnLine,
 } from "./update-view.js";
@@ -191,8 +191,42 @@ export async function runUpdateCommand(
 		return 1;
 	}
 
-	const profileIds = Object.keys(manifest.profiles);
-	if (flags.profile && !manifest.profiles[flags.profile]) {
+	// No active profile, no update: that is where plugin state is read from and
+	// where changes are written. Asked before the profile is resolved, so what
+	// the user activates here is what this run uses.
+	//
+	// BOTH `--check` and `--dry-run` are read-only here. An earlier version let
+	// `--dry-run` activate, reasoning that a preview needs a real profile to
+	// report against — but activating writes symlinks and edits a TRACKED
+	// `.gitignore`, and `--dry-run` promises to write nothing and exit 0. A
+	// preview that mutates the repo is not a preview.
+	//
+	// So a read-only run refuses instead, and the two flags differ only in what
+	// that refusal MEANS: `--check` is a gate, so it fails; `--dry-run` is a
+	// preview, and "nothing to preview until a profile is active" is a legitimate
+	// preview result rather than an error.
+	//
+	// NAMING A PROFILE SKIPS THE GATE. `magus update lean` says which profile to
+	// update, and updating it needs the manifest, not the symlink — installs go
+	// to project scope either way. Gating it would refuse a question the user
+	// already answered on the command line, and would break `magus update lean`
+	// and `--check lean` in CI, both of which worked before this gate existed.
+	// ANY positional argument skips it, not just a valid one. A wrong name has to
+	// reach the "Profile not found. Available: …" check below, which says what
+	// the user got wrong; gating it first answers a different question — "no
+	// profile is selected" — which is true, unhelpful, and not the mistake.
+	const current =
+		flags.profile !== undefined
+			? manifest
+			: await requireActiveProfile(projectPath, manifest, {
+					check: flags.check || flags.dryRun,
+				});
+	// A refused dry run exits 0: it wrote nothing and previewed nothing, which is
+	// what it promised. A refused `--check` exits 1, because that is a gate.
+	if (!current) return flags.dryRun ? 0 : 1;
+
+	const profileIds = Object.keys(current.profiles);
+	if (flags.profile && !current.profiles[flags.profile]) {
 		console.error(
 			failLine(
 				`Profile "${flags.profile}" not found. Available: ${profileIds.join(", ")}`,
@@ -205,19 +239,27 @@ export async function runUpdateCommand(
 	// use. A single-profile manifest needs no activation to be unambiguous.
 	// Chosen through the same function the TUI uses, so both judge a plugin
 	// against the same pin.
-	const targetId = selectProfileId(
+	const resolvedId = selectProfileId(
 		profileIds,
 		flags.profile,
 		await activeProfile(projectPath),
 	);
-	if (!targetId) {
+
+	// `requireActiveProfile` above has already guaranteed one is active, so rule
+	// 2 of `selectProfileId` resolves and this is only unreachable-guard. There
+	// is deliberately no "pick one for this run" fallback any more: it used to
+	// ask here and then update a profile the project was not running, which is
+	// the two-worlds behaviour the gate exists to end. An explicit argument is
+	// still honoured — naming a profile is naming intent.
+	if (!resolvedId) {
 		console.error(
 			failLine(
-				`No active profile. Pass one: magus update <${profileIds.join("|")}>`,
+				`No active profile. Run \`magus profile switch <${profileIds.join("|")}>\`.`,
 			),
 		);
 		return 1;
 	}
+	const targetId = resolvedId;
 
 	for (const line of header(targetId)) console.log(line);
 
@@ -244,7 +286,7 @@ export async function runUpdateCommand(
 
 	const closure = await runStep(steps.profile, async (say) => {
 		say(`resolving "${targetId}"`);
-		const resolved = await resolveProfile(manifest, targetId);
+		const resolved = await resolveProfile(current, targetId);
 		steps.profile.detail = [
 			`${Object.keys(resolved.plugins).length} plugins`,
 			`${resolved.bins.length} tools`,
@@ -293,30 +335,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 +430,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);
 	}
@@ -104,7 +104,16 @@ async function main(): Promise<void> {
 	});
 }
 
-main().catch((error) => {
+main().catch(async (error) => {
+	// Ctrl+C at a prompt is an answer — "stop" — not a failure. 130 is the
+	// shell's own convention for SIGINT (128 + 2), so `magus update && next`
+	// stops rather than running `next`. The newline lands the shell prompt on
+	// its own line instead of against the half-finished question.
+	const { isPromptAborted } = await import("./cli/prompt.js");
+	if (isPromptAborted(error)) {
+		process.stderr.write("\n");
+		process.exit(130);
+	}
 	console.error("Error starting magus:", error);
 	process.exit(1);
 });