@underactive/pi-topping 0.7.0 → 0.7.1

package/README.md

@@ -112,14 +112,15 @@ Bundled packs live in [`wordpacks/`](wordpacks/). Copy `wordpacks/doctor-who.jso
   "packs": [{
     "id": "cooking",
     "name": "Cooking",
+    "description": "Kitchen operations.",
     "words": [{ "present_tense": "Sautéing onions", "past_tense": "Sautéed" }]
   }]
 }
 ```
 
-Pack IDs must start with a lowercase letter and contain only lowercase letters, digits, and `-`. Each pack needs a non-empty `name` and at least one word with non-empty `present_tense` and `past_tense` strings. Invalid entries are ignored. Packs reload when a session starts and whenever `/topping-settings` opens, not while a turn is running. Preferences for missing packs are retained so they apply when the pack returns.
+Pack IDs must start with a lowercase letter, contain only lowercase letters, digits, and `-`, and be at most 64 characters. Each pack needs a non-empty `name` and at least one word with non-empty `present_tense` and `past_tense` strings. An optional `description` appears in the settings preview when the pack row is selected, and an optional `attribution` records the source. Invalid entries are ignored. Packs reload when a session starts and whenever `/topping-settings` opens, not while a turn is running. Preferences for missing packs are retained so they apply when the pack returns.
 
-The `default` animated spinner and completion marker border colors defer to Pi's thinking-level color. The `thinking-level` prompt border color follows the level captured when the prompt is submitted. The `thinkingLevel` color option for the token activity monitor, token rate, and response model follows Pi's active thinking-level color.
+Every color setting offers `thinking-level` (shown as `thinkingLevel` in `/topping-settings`); it is the default for the animated spinner, the prompt border, and the completion marker border. The spinner, token activity monitor, token rate, and response model follow Pi's current thinking level. The prompt border uses the level captured when the prompt was submitted, and the completion marker uses the level captured when the turn settled, so earlier entries keep their color after you change level. When hand-editing `settings.json`, write `thinking-level`; the legacy `default` spelling is only recognised for `spinnerColor` and `doneMarkerBorderColor`.
 
 Under **Elements Order**, press `␣` to grab a row, then `↑`/`↓` to slide that element
 left or right within the loader. Elapsed time, output tokens, token rate, and response model are joined with
@@ -149,7 +150,7 @@ npm test
 npm run typecheck
 ```
 
-Tests cover the word/shimmer rendering, prompt box and completion marker rendering, activity meter behavior, timer resets, settings persistence, the `menu.ts` component, and the settings menu wiring end to end.
+Tests cover the word/shimmer rendering, prompt box and completion marker rendering, activity meter behavior, timer resets, settings persistence and schema migrations, word-pack parsing and loading, the `menu.ts` component, the settings menu wiring end to end, and the flag-gated `/topping-setup` command's install and uninstall flows.
 
 ## Limitations
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@underactive/pi-topping",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "A Pi extension that adds quality of life improvements to Pi's UX: a high-vis user prompt, a shimmering working loader with token activity meter and elapsed timer, and an end-of-turn completion marker",
   "keywords": ["pi-package", "pi-extension"],
   "license": "MIT",

package/src/format.ts

@@ -91,7 +91,7 @@ export function dimAttribute(text: string): string {
 	return `\x1b[2m${text}\x1b[22m`;
 }
 
-/** Number of discrete, eased warning-to-dim shades used for the token-rate fade. */
+/** Number of discrete, eased shades used by the token-rate and response-model fades. */
 export const TOKEN_RATE_FADE_SHADE_COUNT = 5;
 
 /** Milliseconds a settled response model remains fully visible before fading. */
@@ -100,7 +100,7 @@ export const RESPONSE_MODEL_HOLD_MS = 3_000;
 /** Milliseconds over which a settled response model fades through the theme shades. */
 export const RESPONSE_MODEL_FADE_MS = 500;
 
-/** Render one token-rate fade shade by blending the selected color toward the active theme's dim color. */
+/** Render one fade shade by blending the colorizer's color toward the active theme's dim color. */
 export function fadeThemeColorString(
 	text: string,
 	shade: number,

package/src/menu.ts

@@ -4,7 +4,7 @@
  * contract and `ctx.ui.custom()` overlay API.
  *
  * Renders a titled box containing one or more sections of boolean toggle,
- * multi-value cycle, or drag-to-reorder items, plus an optional live-updating
+ * multi-value cycle, or keyboard-reorderable items, plus an optional live-updating
  * preview section driven by a caller-supplied render callback.
  *
  * Intended to be reused by any extension that needs a simple modal toggle
@@ -57,11 +57,12 @@ export interface MenuConfig {
 	/**
 	 * Optional preview renderer, shown in its own "Preview" section above the
 	 * toggle sections. Called on every render with the menu's current (possibly
-	 * toggled but not-yet-applied) values and the number of milliseconds elapsed
-	 * since the menu opened. Lines may contain ANSI styling and are truncated/
-	 * padded to fit automatically.
+	 * toggled but not-yet-applied) values, the milliseconds elapsed since the menu
+	 * opened, the id of the item under the cursor (undefined for an empty menu),
+	 * and the width available to each line. Lines may contain ANSI styling and
+	 * are truncated/padded to fit automatically.
 	 *
-	 * Omitting `nextRefreshInMs` from a `PreviewResult` makes the preview static.
+	 * Omitting `nextRefreshInMs` (or returning a value <= 0) makes the preview static.
 	 */
 	preview?: (values: Record<string, MenuValue>, elapsedMs: number, activeItemId: string | undefined, width: number) => PreviewResult;
 	/** Optional heading for the preview block. Defaults to `Preview`. */

package/src/pi-installer.ts

@@ -9,17 +9,16 @@ export interface PiInstallResult {
 const SIGKILL_GRACE_MS = 5_000;
 const EXIT_TIMEOUT = 124;
 
-/** Run `pi install <spec>` without relying on Pi's shell-less exec wrapper on Windows. */
-export function spawnPiInstall(spec: string, timeoutMs: number): Promise<PiInstallResult> {
+function spawnPiPackageCommand(command: "install" | "remove", spec: string, timeoutMs: number): Promise<PiInstallResult> {
 	if (!/^npm:@?[\w.-]+(\/[\w.-]+)?$/.test(spec)) {
 		return Promise.resolve({ code: 1, stdout: "", stderr: `invalid spec: ${spec}` });
 	}
 	return new Promise((resolve) => {
 		const isWindows = process.platform === "win32";
-		const [command, args, options] = isWindows
-			? (["cmd.exe", ["/c", "pi", "install", spec], { windowsHide: true }] as const)
-			: (["pi", ["install", spec], {}] as const);
-		const processHandle = spawn(command, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
+		const [executable, args, options] = isWindows
+			? (["cmd.exe", ["/c", "pi", command, spec], { windowsHide: true }] as const)
+			: (["pi", [command, spec], {}] as const);
+		const processHandle = spawn(executable, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
 		let stdout = "";
 		let stderr = "";
 		let settled = false;
@@ -61,3 +60,13 @@ export function spawnPiInstall(spec: string, timeoutMs: number): Promise<PiInsta
 		});
 	});
 }
+
+/** Run `pi install <spec>` without relying on Pi's shell-less exec wrapper on Windows. */
+export function spawnPiInstall(spec: string, timeoutMs: number): Promise<PiInstallResult> {
+	return spawnPiPackageCommand("install", spec, timeoutMs);
+}
+
+/** Run `pi remove <spec>` without relying on Pi's shell-less exec wrapper on Windows. */
+export function spawnPiRemove(spec: string, timeoutMs: number): Promise<PiInstallResult> {
+	return spawnPiPackageCommand("remove", spec, timeoutMs);
+}

package/src/prompt-decorator.ts

@@ -15,7 +15,10 @@ const BORDER_GLYPHS: Record<BorderStyle, { tl: string; tr: string; bl: string; b
 
 /**
  * False visibility options hide each corresponding part; present provider and
- * model values join with `/` in the bottom border.
+ * model values join with `/` in the bottom border. `thinkingLevel` is the level
+ * captured at submission and is only used when `borderColor` is `thinking-level`.
+ * Unrecognised `borderStyle` / `borderColor` values fall back to `double` and the
+ * default border color.
  */
 export interface PromptBoxDetails {
 	submittedAt?: number;

package/src/settings.ts

@@ -318,6 +318,10 @@ export function applyMenuResult(settings: DecoratorSettings, values: Record<stri
  * to defaults on any read/parse error. When a cycle setting's enabled flag is
  * off, its stored value resets to the menu's disabled default so stale choices
  * don't resurface on re-enable.
+ * Files with `schemaVersion` below 2 get spinner color reset to `thinking-level` and
+ * `borderAccent` prompt borders moved to `thinking-level`; below 3, the completion-marker
+ * border color is reset. A legacy `features.simCityWorkingText: true` enables the
+ * `simcity` pack when no explicit preference is stored.
  */
 export function loadSettings(): DecoratorSettings {
 	try {

package/src/setup-command.ts

@@ -1,74 +1,99 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { hyperlink } from "@earendil-works/pi-tui";
-import { showMenu } from "./menu.ts";
-import { type PiInstallResult, spawnPiInstall } from "./pi-installer.ts";
-import { stripControlChars } from "./util.ts";
+import { type MenuValue, showMenu } from "./menu.ts";
+import { type PiInstallResult, spawnPiInstall, spawnPiRemove } from "./pi-installer.ts";
 import { setSetupCheckDisabled } from "./setup-check.ts";
-import { findMissingToppings, type ToppingStatus } from "./toppings.ts";
+import { detectToppings, type ToppingStatus } from "./toppings.ts";
+import { stripControlChars } from "./util.ts";
 
-const INSTALL_TIMEOUT_MS = 120_000;
+const PI_COMMAND_TIMEOUT_MS = 120_000;
 const STDERR_SNIPPET_CHARS = 300;
 
-type ToppingInstaller = (spec: string, timeoutMs: number) => Promise<PiInstallResult>;
+type PackageAction = "install" | "remove";
+type PiPackageRunner = (spec: string, timeoutMs: number) => Promise<PiInstallResult>;
+type FailedAction = { action: PackageAction; spec: string; error: string };
+type SetupRow = { status: ToppingStatus; action: PackageAction };
 
-type FailedInstall = { spec: string; error: string };
-
-function selectedToppings(missing: readonly ToppingStatus[], values: Record<string, boolean>): ToppingStatus[] {
-	return missing.filter(({ topping }) => values[topping.pkg] === true);
+function selectedRows(
+	rows: ReadonlyMap<string, SetupRow>,
+	values: Record<string, boolean>,
+	action: PackageAction,
+): ToppingStatus[] {
+	return [...rows.entries()]
+		.filter(([id, row]) => row.action === action && values[id] === true)
+		.map(([, row]) => row.status);
 }
 
-function renderDescription(missing: readonly ToppingStatus[], activeItemId: string | undefined): string[] {
-	const active = missing.find(({ topping }) => topping.pkg === activeItemId);
+function renderDescription(
+	rows: ReadonlyMap<string, SetupRow>,
+	activeItemId: string | undefined,
+	values: Record<string, MenuValue>,
+): string[] {
+	if (activeItemId === undefined) return ["Select a topping to see what it does."];
+	const active = rows.get(activeItemId);
 	if (!active) return ["Select a topping to see what it does."];
-	const url = `https://pi.dev/packages/${active.topping.pkg}`;
-	return [active.topping.provides, "", hyperlink(url, url)];
+	const url = `https://pi.dev/packages/${active.status.topping.pkg}`;
+	const action = values[activeItemId] === true
+		? `Checked: will ${active.action === "install" ? "install" : "uninstall"}`
+		: "Unchecked: no change";
+	return [active.status.topping.provides, "", hyperlink(url, url), "", action];
 }
 
 function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
 
-function buildReport(succeeded: string[], failed: FailedInstall[]): string {
+function snippet(text: string): string {
+	return stripControlChars(text.trim()).slice(0, STDERR_SNIPPET_CHARS);
+}
+
+function buildReport(installed: string[], removed: string[], failed: FailedAction[]): string {
 	const lines: string[] = [];
-	if (succeeded.length > 0) lines.push(`✓ Installed: ${succeeded.join(", ")}`);
+	if (installed.length > 0) lines.push(`✓ Installed: ${installed.join(", ")}`);
+	if (removed.length > 0) lines.push(`✓ Removed: ${removed.join(", ")}`);
 	if (failed.length > 0) {
 		lines.push("✗ Failed:");
-		for (const failure of failed) lines.push(`  ${failure.spec}: ${failure.error}`);
+		for (const failure of failed) lines.push(`  ${failure.action} ${failure.spec}: ${failure.error}`);
 	}
-	if (succeeded.length > 0) {
+	if (installed.length > 0 || removed.length > 0) {
 		lines.push("");
-		lines.push("Restart Pi afterwards to activate them.");
+		lines.push("Restart Pi afterwards to apply the changes.");
 	}
 	return lines.join("\n");
 }
 
-async function installSelected(
+async function runPackageCommands(
 	ctx: ExtensionCommandContext,
 	selected: readonly ToppingStatus[],
-	install: ToppingInstaller,
-): Promise<{ succeeded: string[]; failed: FailedInstall[] }> {
+	runner: PiPackageRunner,
+	action: PackageAction,
+): Promise<{ succeeded: string[]; failed: FailedAction[] }> {
 	const succeeded: string[] = [];
-	const failed: FailedInstall[] = [];
+	const failed: FailedAction[] = [];
 	for (const { topping } of selected) {
 		const spec = `npm:${topping.pkg}`;
-		ctx.ui.notify(`Installing ${spec}…`, "info");
+		ctx.ui.notify(`${action === "install" ? "Installing" : "Removing"} ${spec}…`, "info");
 		try {
-			const result = await install(spec, INSTALL_TIMEOUT_MS);
+			const result = await runner(spec, PI_COMMAND_TIMEOUT_MS);
 			if (result.code === 0) {
 				succeeded.push(spec);
 			} else {
-				failed.push({ spec, error: stripControlChars((result.stderr || result.stdout || `exit ${result.code}`).trim()).slice(0, STDERR_SNIPPET_CHARS) });
+				failed.push({ action, spec, error: snippet(result.stderr || result.stdout || `exit ${result.code}`) });
 			}
 		} catch (error) {
-			failed.push({ spec, error: stripControlChars(errorMessage(error)).slice(0, STDERR_SNIPPET_CHARS) });
+			failed.push({ action, spec, error: snippet(errorMessage(error)) });
 		}
 	}
 	return { succeeded, failed };
 }
 
-export function registerSetupCommand(pi: ExtensionAPI, install: ToppingInstaller = spawnPiInstall): void {
+export function registerSetupCommand(
+	pi: ExtensionAPI,
+	install: PiPackageRunner = spawnPiInstall,
+	remove: PiPackageRunner = spawnPiRemove,
+): void {
 	pi.registerCommand("topping-setup", {
-		description: "Install missing Pi Topping sibling extensions or manage the missing-extension notice.",
+		description: "Install or uninstall Pi Topping sibling extensions or manage the missing-extension notice.",
 		handler: async (args, ctx) => {
 			const action = args.trim();
 			if (action === "disable-side-toppings-check" || action === "enable-side-toppings-check") {
@@ -96,41 +121,62 @@ export function registerSetupCommand(pi: ExtensionAPI, install: ToppingInstaller
 				return;
 			}
 
-			const missing = findMissingToppings(pi);
-			if (missing.length === 0) {
+			const statuses = detectToppings(pi);
+			const removable = statuses.filter((status) => status.packageSource !== undefined);
+			const missing = statuses.filter((status) => !status.active && status.packageSource === undefined);
+			if (missing.length === 0 && removable.length === 0) {
 				ctx.ui.notify("All Pi Topping extensions are already active in this session.", "info");
 				return;
 			}
 
+			const rows = new Map<string, SetupRow>();
+			for (const status of missing) rows.set(`install:${status.topping.pkg}`, { status, action: "install" });
+			for (const status of removable) rows.set(`remove:${status.topping.pkg}`, { status, action: "remove" });
+			const sections = [];
+			if (missing.length > 0) {
+				sections.push({
+					title: "Missing Toppings",
+					items: missing.map(({ topping, onDisk }) => ({
+						id: `install:${topping.pkg}`,
+						label: `${topping.pkg}${onDisk ? " (on disk, not active)" : ""}`,
+						value: true,
+					})),
+				});
+			}
+			if (removable.length > 0) {
+				sections.push({
+					title: "Installed Toppings",
+					items: removable.map(({ topping, active }) => ({
+						id: `remove:${topping.pkg}`,
+						label: `${topping.pkg}${active ? " (active)" : " (installed, not active)"}`,
+						value: false,
+					})),
+				});
+			}
+
 			const result = await showMenu<Record<string, boolean>>(ctx, {
 				title: "Pi Topping: Setup",
-				sections: [
-					{
-						title: "Missing Toppings",
-						items: missing.map(({ topping, onDisk }) => ({
-							id: topping.pkg,
-							label: `${topping.pkg}${onDisk ? " (on disk, not active)" : ""}`,
-							value: true,
-						})),
-					},
-				],
-				hints: ["↑↓ move", "PgUp/PgDn page", "␣ toggle", "⏎ install", "esc cancel"],
+				sections,
+				hints: ["↑↓ move", "PgUp/PgDn page", "␣ toggle", "⏎ apply", "esc cancel"],
 				previewTitle: "Description",
-				preview: (_values, _elapsedMs, activeItemId) => ({ lines: renderDescription(missing, activeItemId) }),
+				preview: (values, _elapsedMs, activeItemId) => ({ lines: renderDescription(rows, activeItemId, values) }),
 			});
 			if (!result.applied) {
 				ctx.ui.notify("Pi Topping setup cancelled.", "info");
 				return;
 			}
 
-			const selected = selectedToppings(missing, result.values);
-			if (selected.length === 0) {
-				ctx.ui.notify("No Pi Topping extensions selected.", "info");
+			const removals = selectedRows(rows, result.values, "remove");
+			const installs = selectedRows(rows, result.values, "install");
+			if (removals.length === 0 && installs.length === 0) {
+				ctx.ui.notify("No Pi Topping changes selected.", "info");
 				return;
 			}
 
-			const { succeeded, failed } = await installSelected(ctx, selected, install);
-			ctx.ui.notify(buildReport(succeeded, failed), failed.length > 0 ? "warning" : "info");
+			const removalResult = await runPackageCommands(ctx, removals, remove, "remove");
+			const installResult = await runPackageCommands(ctx, installs, install, "install");
+			const failed = [...removalResult.failed, ...installResult.failed];
+			ctx.ui.notify(buildReport(installResult.succeeded, removalResult.succeeded, failed), failed.length > 0 ? "warning" : "info");
 		},
 	});
 }

package/src/toppings.ts

@@ -1,4 +1,5 @@
-import { getAgentDir, type ExtensionAPI, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, type ExtensionAPI, type ExtensionUIContext, type Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { isSetupCheckDisabled } from "./setup-check.ts";
@@ -15,6 +16,8 @@ export interface ToppingStatus {
 	readonly topping: Topping;
 	readonly active: boolean;
 	readonly onDisk: boolean;
+	/** Exact npm source recorded in Pi's user settings for this topping. */
+	readonly packageSource: string | undefined;
 }
 
 export const TOPPINGS: readonly Topping[] = [
@@ -42,6 +45,12 @@ export const TOPPINGS: readonly Topping[] = [
 		dir: "pi-topping-web-tools",
 		provides: "web research and browser automation",
 	},
+	{
+		pkg: "@underactive/pi-topping-moa-fusion",
+		matches: /pi-topping-moa-fusion/i,
+		dir: "pi-topping-moa-fusion",
+		provides: "Mixture-of-Agents Fusion plan mode",
+	},
 ];
 
 interface PiSettings {
@@ -51,6 +60,7 @@ interface PiSettings {
 
 interface SettingsToppingState {
 	packageInstalled: boolean;
+	packageSource?: string;
 	extensionPresent: boolean;
 	extensionActive: boolean;
 }
@@ -61,6 +71,22 @@ function stringEntries(value: unknown): string[] {
 	return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
 }
 
+function sourceEntries(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry) => {
+		if (typeof entry === "string") return [entry];
+		return isPlainObject(entry) && typeof entry.source === "string" ? [entry.source] : [];
+	});
+}
+
+function npmPackageName(source: string): string | undefined {
+	const value = source.trim();
+	if (!value.startsWith("npm:")) return undefined;
+	const spec = value.slice("npm:".length);
+	const versionIndex = spec.lastIndexOf("@");
+	return versionIndex > 0 ? spec.slice(0, versionIndex) : spec;
+}
+
 function readPiSettings(): PiSettings | undefined {
 	try {
 		const parsed: unknown = JSON.parse(readFileSync(join(getAgentDir(), "settings.json"), "utf8"));
@@ -78,10 +104,12 @@ function extensionEntry(entry: string): { value: string; disabled: boolean } {
 
 function settingsState(settings: PiSettings | undefined, topping: Topping): SettingsToppingState {
 	let packageInstalled = false;
+	let packageSource: string | undefined;
 	let extensionPresent = false;
 	let extensionActive = false;
-	for (const entry of stringEntries(settings?.packages)) {
+	for (const entry of sourceEntries(settings?.packages)) {
 		if (topping.matches.test(entry)) packageInstalled = true;
+		if (npmPackageName(entry) === topping.pkg) packageSource = entry;
 	}
 	for (const entry of stringEntries(settings?.extensions)) {
 		const normalized = extensionEntry(entry);
@@ -89,7 +117,7 @@ function settingsState(settings: PiSettings | undefined, topping: Topping): Sett
 		extensionPresent = true;
 		if (!normalized.disabled) extensionActive = true;
 	}
-	return { packageInstalled, extensionPresent, extensionActive };
+	return { packageInstalled, packageSource, extensionPresent, extensionActive };
 }
 
 function runtimeActiveToppings(pi: ExtensionAPI): Array<true | undefined> | undefined {
@@ -117,7 +145,7 @@ export function detectToppings(pi: ExtensionAPI): ToppingStatus[] {
 		const checkoutPresent = existsSync(join(extensionsDir, topping.dir));
 		const onDisk = configured.packageInstalled || configured.extensionPresent || checkoutPresent;
 		const fallbackActive = configured.packageInstalled || configured.extensionActive || checkoutPresent;
-		return { topping, active: runtime?.[index] ?? fallbackActive, onDisk };
+		return { topping, active: runtime?.[index] ?? fallbackActive, onDisk, packageSource: configured.packageSource };
 	});
 }
 
@@ -125,31 +153,52 @@ export function findMissingToppings(pi: ExtensionAPI): ToppingStatus[] {
 	return detectToppings(pi).filter((status) => !status.active);
 }
 
-function renderMissingBanner(missing: readonly ToppingStatus[]): string {
-	const title = `pi-topping: ${missing.length} topping extensions missing`;
-	const body = [
-		...missing.map(({ topping }) => `• ${topping.pkg} — ${topping.provides}`),
-		"",
-		"Run `/topping-setup` to selectively install them",
-		"Run `/topping-setup disable-side-toppings-check` to suppress this message",
+interface BannerLine {
+	readonly plain: string;
+	readonly styled: string;
+}
+
+function renderMissingBanner(missing: readonly ToppingStatus[], theme: Pick<Theme, "fg">): string {
+	const text = (value: string): string => theme.fg("text", value);
+	const accent = (value: string): string => theme.fg("accent", value);
+	const warning = (value: string): string => theme.fg("warning", value);
+	const title: BannerLine = {
+		plain: `pi-topping: ${missing.length} topping extensions missing`,
+		styled: text(`pi-topping: ${missing.length} topping extensions missing`),
+	};
+	const body: BannerLine[] = [
+		...missing.map(({ topping }) => ({
+			plain: `• ${topping.pkg} — ${topping.provides}`,
+			styled: `${text("• ")}${accent(topping.pkg)}${text(` — ${topping.provides}`)}`,
+		})),
+		{ plain: "", styled: "" },
+		{
+			plain: "Run /topping-setup to selectively install them",
+			styled: `${text("Run ")}${accent("/topping-setup")}${text(" to selectively install them")}`,
+		},
+		{
+			plain: "Run /topping-setup disable-side-toppings-check to suppress this message",
+			styled: `${text("Run ")}${accent("/topping-setup disable-side-toppings-check")}${text(" to suppress this message")}`,
+		},
 	];
-	const width = Math.max(title.length + 6, ...body.map((line) => line.length + 4));
-	const blankRow = `│${" ".repeat(width - 2)}│`;
+	const titleWidth = visibleWidth(title.plain);
+	const width = Math.max(titleWidth + 6, ...body.map((line) => visibleWidth(line.plain) + 4));
+	const blankRow = `${warning("│")}${" ".repeat(width - 2)}${warning("│")}`;
 	return [
-		`╭─ ${title} ${"─".repeat(width - title.length - 5)}╮`,
+		`${warning("╭─")} ${title.styled} ${warning("─".repeat(width - titleWidth - 5))}${warning("╮")}`,
 		blankRow,
-		...body.map((line) => `│ ${line.padEnd(width - 4)} │`),
+		...body.map((line) => `${warning("│")} ${line.styled}${" ".repeat(width - visibleWidth(line.plain) - 4)} ${warning("│")}`),
 		blankRow,
-		`╰${"─".repeat(width - 2)}╯`,
+		`${warning("╰")}${warning("─".repeat(width - 2))}${warning("╯")}`,
 	].join("\n");
 }
 
-export function notifyMissingToppingsOnce(pi: ExtensionAPI, ui: Pick<ExtensionUIContext, "notify">): void {
+export function notifyMissingToppingsOnce(pi: ExtensionAPI, ui: Pick<ExtensionUIContext, "notify" | "theme">): void {
 	if (setupNoticeHandled) return;
 	setupNoticeHandled = true;
 	if (isSetupCheckDisabled()) return;
 	const missing = findMissingToppings(pi);
-	if (missing.length > 0) ui.notify(`\n${renderMissingBanner(missing)}`, "warning");
+	if (missing.length > 0) ui.notify(`\n${renderMissingBanner(missing, ui.theme)}`, "warning");
 }
 
 /** Test-only reset for the once-per-process session-start notice. */