magus-cli 7.0.0 → 7.2.0

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} `);
 }
 
 /**
@@ -505,6 +513,45 @@ export function badge(label: string, hex: string): string {
  */
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
 
+/**
+ * A bordered dialog: title in the top rule, body inside, one blank row of
+ * breathing space top and bottom.
+ *
+ * Built on `padEnd`, which measures visible cells, so a body line carrying
+ * colour still aligns — padding a coloured string by `String.length` counts the
+ * escape bytes and shears the right border by however many bytes the colour
+ * cost.
+ *
+ * The border and the rule are dim and the body is not: a frame that competes
+ * with its own contents is why a boxed message can read as louder but say less.
+ */
+export function dialog(
+	title: string,
+	lines: string[],
+	opts: { width?: number; color?: string } = {},
+): string[] {
+	const inner = Math.max(
+		opts.width ?? 0,
+		...lines.map((l) => width(l)),
+		width(title) + 4,
+	);
+	const accent = opts.color;
+	const paint = (s: string) => (accent ? fg(accent, s) : s);
+
+	// Every row must be `inner + 4` cells: corner, space, body, space, corner.
+	// The head spends 2 on "╭─" and `width(title) + 2` on the titled gap, so the
+	// rule takes the rest. Getting this off by one is invisible in source and
+	// obvious on screen — the right border jags one column in at the title row.
+	const head = `${paint("╭─")}${paint(` ${title} `)}${dim(
+		"─".repeat(Math.max(0, inner - width(title) - 1)),
+	)}${dim("╮")}`;
+	const foot = dim(`╰${"─".repeat(inner + 2)}╯`);
+	const row = (text: string) =>
+		`${dim("│")} ${padEnd(text, inner)} ${dim("│")}`;
+
+	return [head, row(""), ...lines.map(row), row(""), foot];
+}
+
 export function spinner(tick: number): string {
 	return SPINNER[Math.abs(Math.trunc(tick)) % SPINNER.length];
 }

package/src/cli/bootstrap.ts

@@ -8,17 +8,74 @@
  * stands, then the original command proceeds against it normally.
  */
 
+import path from "node:path";
 import {
 	getManifestPath,
 	readManifest,
 	writeManifest,
 } from "../services/manifest.js";
+import {
+	applyProfileChoice,
+	materializeAndActivate,
+	reportDisplaced,
+} from "../services/profile-activate.js";
 import {
 	type AdoptResult,
 	adoptCurrentProject,
 } from "../services/profile-adopt.js";
+import {
+	buildProfileOptions,
+	defaultOptionIndex,
+	describeNeed,
+	detectProfileStartupNeed,
+	needsNothing,
+	parseProfileChoice,
+} from "../services/profile-startup.js";
 import type { ProfileManifest } from "../types/index.js";
+import { dim } from "./ansi.js";
 import { confirm } from "./prompt.js";
+import { selectDialog } from "./tui-prompt.js";
+import { fail as failLine, note as noteLine } from "./update-view.js";
+
+/**
+ * Write the adopted manifest, then put the project ON the profile it describes.
+ *
+ * Both halves or neither. Writing alone is what made migrating feel like a
+ * no-op: `activeProfile()` is derived from the symlink, so a manifest nothing
+ * links to changes no behaviour, and the run that just migrated still has to
+ * ask which profile to use.
+ *
+ * Activation is reported in full, including anything it moved aside, because it
+ * replaces files the user wrote by hand. A migration is allowed to change the
+ * working tree; it is not allowed to do it quietly.
+ */
+async function writeAndActivate(
+	result: AdoptResult,
+	projectPath: string,
+): Promise<void> {
+	// Relative to the project throughout. These are all project paths, and an
+	// absolute one wraps over two terminal lines — several wrapped lines in a row
+	// is where a reader stops reading, and this notice is the one that says where
+	// their hand-written files went.
+	const rel = (p: string) => path.relative(projectPath, p);
+
+	await writeManifest(result.manifest, projectPath);
+	console.log(`✓ Wrote ${rel(getManifestPath(projectPath))}`);
+
+	// Each move is printed as it happens, not from the returned list afterwards.
+	// Activation touches up to four artifacts in sequence, so a throw on the
+	// third would discard the record of the first two — and the first of those
+	// is the user's `.claude/settings.json`, now absent from where they left it.
+	// Printing first means a failed activation still says where everything went.
+	await materializeAndActivate(
+		result.manifest,
+		result.profileId,
+		projectPath,
+		reportDisplaced(projectPath),
+	);
+	console.log(`✓ Active profile: ${result.profileId}`);
+	console.log();
+}
 
 /** Print what adoption would capture, so the user can judge it before writing. */
 function printAdoptionPlan(result: AdoptResult): void {
@@ -64,6 +121,16 @@ function printAdoptionPlan(result: AdoptResult): void {
 	console.log(
 		"\nCommit the file to share this setup with the team; edit it to pin versions.",
 	);
+	// Said before the question, not after it: adopting also SWITCHES the project
+	// onto the profile, which replaces two files that are in the working tree
+	// right now. The prompt below is the only place to decline.
+	console.log(
+		"The project then runs this profile: .claude/settings.json, .mcp.json and",
+	);
+	console.log(
+		".claude/skills become links into it, and your current copies are kept where",
+	);
+	console.log("the run reports.");
 }
 
 export interface EnsureManifestOptions {
@@ -123,12 +190,111 @@ export async function ensureManifest(
 			"\nRefusing to create .claude/profiles.json without a human: run `magus profile init` to create it deliberately.",
 		);
 		return null;
-	} else if (!(await confirm("\nCreate .claude/profiles.json?"))) {
+	} else if (!(await confirm("\nCreate it and switch to it?"))) {
 		console.log("Aborted — nothing written.");
 		return null;
 	}
 
-	await writeManifest(result.manifest, projectPath);
-	console.log(`✓ Wrote ${getManifestPath(projectPath)}\n`);
+	await writeAndActivate(result, projectPath);
 	return result.manifest;
 }
+
+/**
+ * Require an active profile, or stop the command.
+ *
+ * magus manages a project THROUGH its active profile: that is where plugin
+ * state is read from and where updates are written. With none there is nothing
+ * to read and nowhere to write, so there is no useful work to do — and the
+ * previous version of this offered exactly that anyway. It asked only when the
+ * manifest had drifted, let the user decline, and `update` then carried on with
+ * a profile "for this run only", resolving against a manifest the project was
+ * not running. Two worlds live at once, which is the confusion being removed.
+ *
+ * So this asks whenever no profile is active, and the only answers are migrate,
+ * activate, or stop. Returns the manifest to carry on with, or null when the
+ * command must exit non-zero — by which point it has printed why.
+ *
+ * Nothing is compared. An earlier version weighed the manifest against
+ * `enabledPlugins`; see the header of `services/profile-startup.ts` for why
+ * that reads a profiled project's own generated output and cannot be acted on.
+ */
+export async function requireActiveProfile(
+	projectPath: string,
+	manifest: ProfileManifest,
+	opts: EnsureManifestOptions = {},
+): Promise<ProfileManifest | null> {
+	const need = await detectProfileStartupNeed(projectPath);
+	if (needsNothing(need)) return manifest;
+
+	// The repo declares which profile it wants and there is nothing of the
+	// user's to replace — a fresh clone. Activate it and carry on, even under
+	// `--check` and with no TTY: this is the committed answer being applied, not
+	// a decision being made, and it is exactly the case CI hits.
+	if (need.autoActivate && need.declaredDefault !== null && !opts.check) {
+		const { profileId } = await applyProfileChoice(
+			{ kind: "activate", id: need.declaredDefault },
+			need.manifest,
+			projectPath,
+			reportDisplaced(projectPath),
+		);
+		console.log(
+			`✓ Active profile: ${profileId} ${dim("(declared by this project)")}`,
+		);
+		console.log("");
+		return readManifest(projectPath);
+	}
+
+	const { title } = describeNeed(need);
+
+	// `--check` is a read-only CI gate, and "this project is not on a profile"
+	// is a legitimate thing for it to fail on rather than quietly repair.
+	if (opts.check) {
+		console.error(failLine(title));
+		console.error(noteLine("Run `magus update` at a terminal to resolve it."));
+		return null;
+	}
+
+	// CI has nobody to ask. Exiting beats hanging on an answer that cannot come.
+	if (!process.stdin.isTTY) {
+		console.error(failLine(title));
+		console.error(
+			noteLine(
+				need.state === "unmigrated"
+					? "Run `magus profile init` to create one deliberately."
+					: `Run \`magus profile switch <${need.activate
+							.map((p) => p.id)
+							.join("|")}>\` first.`,
+			),
+		);
+		return null;
+	}
+
+	console.log("");
+	const chosen = await selectDialog({
+		title,
+		message: describeNeed(need).message,
+		options: buildProfileOptions(need),
+		defaultIndex: defaultOptionIndex(need),
+	});
+
+	// Esc, Ctrl+C and the "Quit magus" row all land here, and there is no third
+	// outcome: the command stops rather than proceed without a profile.
+	const choice = chosen === null ? null : parseProfileChoice(chosen, need);
+	if (!choice) {
+		console.error(failLine("No active profile — stopping."));
+		return null;
+	}
+
+	const { profileId } = await applyProfileChoice(
+		choice,
+		need.manifest,
+		projectPath,
+		reportDisplaced(projectPath),
+	);
+	console.log(`✓ Active profile: ${profileId}`);
+	console.log("");
+
+	// Re-read rather than return `need.manifest`: adopting wrote a new profile
+	// into the file, and the caller resolves against whatever comes back.
+	return readManifest(projectPath);
+}

package/src/cli/install.ts

@@ -27,6 +27,7 @@ import {
 } from "../services/install-plan.js";
 import { validateManifest } from "../services/manifest.js";
 import { registerClosureMarketplaces } from "../services/marketplace-sync.js";
+import { reportDisplaced } from "../services/profile-activate.js";
 import { materializeProfile } from "../services/profile-materializer.js";
 import { detectProfileDrift } from "../services/profile-sync.js";
 import { resolveAllProfiles, resolveProfile } from "../services/resolver.js";
@@ -355,7 +356,10 @@ export async function runInstallCommand(
 	const activeId =
 		flags.profile ?? (await pickActiveProfile(profileIds, flags.yes));
 	if (activeId) {
-		await activateProfile(activeId, projectPath);
+		// The reporter is not optional here. The first `install` in a project that
+		// had a hand-written .claude/settings.json moves it aside, and without
+		// this the move is invisible — the file is simply not where it was.
+		await activateProfile(activeId, projectPath, reportDisplaced(projectPath));
 		console.log(`\n✓ Active profile: ${activeId}`);
 		// Skills route through the now-active .claude/skills symlink.
 		const activeClosure = await resolveProfile(manifest, activeId);

package/src/cli/profile.ts

@@ -13,6 +13,7 @@ import { ensureGitignoreEntries } from "../services/conventions-manager.js";
 import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
 import { summarizeClosure } from "../services/install-plan.js";
 import { getManifestPath, readManifest } from "../services/manifest.js";
+import { reportDisplaced } from "../services/profile-activate.js";
 import { syncProfile } from "../services/profile-sync.js";
 import { resolveProfile } from "../services/resolver.js";
 import {
@@ -147,7 +148,10 @@ export async function switchProfile(
 		"# magus: generated profile build output + active-profile symlinks",
 	);
 
-	await activateProfile(name, projectPath);
+	// Switching between two already-active profiles displaces nothing — the paths
+	// are links magus owns. The FIRST switch in an unmanaged project displaces
+	// real files, and that is the run that must say so.
+	await activateProfile(name, projectPath, reportDisplaced(projectPath));
 	console.log(`✓ Switched to profile: ${name}`);
 
 	// Verify the profile's binary deps are actually usable — the switch itself

package/src/cli/prompt.ts

@@ -8,25 +8,57 @@
 
 import { createInterface } from "node:readline/promises";
 
-/** Y/n prompt. Empty input means yes. */
-export async function confirm(question: string): Promise<boolean> {
-	const rl = createInterface({ input: process.stdin, output: process.stdout });
-	try {
-		const answer = (await rl.question(`${question} [Y/n] `))
-			.trim()
-			.toLowerCase();
-		return answer === "" || answer === "y" || answer === "yes";
-	} finally {
-		rl.close();
+/**
+ * Ctrl+C at a prompt.
+ *
+ * `readline/promises` rejects `question()` with an `AbortError` carrying
+ * `code: "ABORT_ERR"`. That is a Node internal, and letting it escape printed
+ * nine frames of `internal:repl/node-errors` under "Error starting magus:" —
+ * a stack trace for the one input every terminal user knows how to give.
+ *
+ * It is converted here rather than at each call site so no future prompt can
+ * forget, and it stays a throw rather than a sentinel return so a caller that
+ * ignores it aborts instead of proceeding with a missing answer.
+ */
+export class PromptAborted extends Error {
+	constructor() {
+		super("Aborted with Ctrl+C");
+		this.name = "PromptAborted";
 	}
 }
 
-/** Free-text prompt, trimmed. */
-export async function promptValue(question: string): Promise<string> {
+/** True for a Ctrl+C at a prompt, ours or readline's own. */
+export function isPromptAborted(error: unknown): boolean {
+	if (error instanceof PromptAborted) return true;
+	// Belt and braces: an abort raised somewhere that does not route through
+	// `ask` still reads as a cancellation rather than a crash.
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		(error as { code?: unknown }).code === "ABORT_ERR"
+	);
+}
+
+/** One readline question, with Ctrl+C normalised. */
+async function ask(question: string): Promise<string> {
 	const rl = createInterface({ input: process.stdin, output: process.stdout });
 	try {
 		return (await rl.question(question)).trim();
+	} catch (error) {
+		if (isPromptAborted(error)) throw new PromptAborted();
+		throw error;
 	} finally {
 		rl.close();
 	}
 }
+
+/** Y/n prompt. Empty input means yes. */
+export async function confirm(question: string): Promise<boolean> {
+	const answer = (await ask(`${question} [Y/n] `)).toLowerCase();
+	return answer === "" || answer === "y" || answer === "yes";
+}
+
+/** Free-text prompt, trimmed. */
+export async function promptValue(question: string): Promise<string> {
+	return ask(question);
+}

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));