@underactive/pi-topping 0.7.0 → 0.7.2

package/README.md

@@ -2,7 +2,7 @@
 
 We garnish our pies. It seemed rude not to extend Pi the same courtesy. This is a [Pi](https://github.com/earendil-works/pi-coding-agent) extension that adds some quality of life improvements to Pi's UX, while looking good in the process:
 
-**User Prompt** — high-vis bordered prompt box with configurable border color and style, pi icon toggle, timestamp, and provider/model label. Prompts submitted while Pi is working (steer / `Alt+Enter` follow-up) are left undecorated so Pi's native `Steering:` / `Follow-up:` queue rows still render.
+**User Prompt** — high-vis bordered prompt box with configurable border color and style, pi icon toggle, timestamp, and provider/model label. The box, timestamp, and provider/model label are display-only; Pi sends your prompt text unchanged to the model, so they do not affect LLM prompt caching. Prompts submitted while Pi is working (steer / `Alt+Enter` follow-up) are left undecorated so Pi's native `Steering:` / `Follow-up:` queue rows still render.
 
 ![Example of pi-topping's decorated user prompt](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo_user_prompt.png)
 
@@ -10,7 +10,7 @@ We garnish our pies. It seemed rude not to extend Pi the same courtesy. This is
 
 ![Demo of pi-topping's shimmering activity word, scrolling activity meter, elapsed timer, token count, and token rate](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo.gif)
 
-**Completion Marker** — end-of-turn marker with icon, randomized verb (or `Worked`; matching past tense when Randomize "Worked" text is on), token consumption display, and optional marker-style, border-style, and border-color decorations spanning the full terminal width. The default `elite` style trails the summary with tapering dashes; `bookend` fills the remaining width to a closing corner glyph. Hooks into Pi's `agent_settled` event.
+**Completion Marker** — end-of-turn marker with icon, randomized verb (or `Worked`; matching past tense when Randomize "Worked" text is on), token consumption display, and optional marker-style, border-style, and border-color decorations spanning the full terminal width. It can append the response model when it differs from the selected model, with its own color option. The default `elite` style trails the summary with tapering dashes; `bookend` fills the remaining width to a closing corner glyph. Hooks into Pi's `agent_settled` event.
 
 ![Example of pi-topping's completion marker](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo_completion_marker.png)
 
@@ -22,6 +22,10 @@ pi install npm:@underactive/pi-topping
 
 Restart Pi (or run `/reload`) to pick it up.
 
+### Sibling toppings
+
+The sibling-topping setup flow currently ships behind the `PI_TOPPING_SIBLING_SETUP=1` environment flag. When enabled, run `/topping-setup` in TUI mode to selectively install missing Pi Topping sibling extensions or uninstall sibling packages recorded in Pi's user settings. Installation rows are selected by default; removal rows are unchecked by default. Restart Pi after applying package changes. Use `/topping-setup disable-side-toppings-check` to suppress missing-topping notices, or `enable-side-toppings-check` to restore them.
+
 ## Settings
 
 Run `/topping-settings` (TUI only) to customize your toppings. Settings persist to
@@ -61,7 +65,7 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ║    [■] Token rate dimmed                             OFF      ║
 ║    [■] Response model                                 ON      ║
 ║    [■] Response model color                     ‹ accent ›    ║
-║    [■] Response model dimmed                        OFF       ║
+║    [■] Response model dimmed                         OFF      ║
 ║                                                               ║
 ╟─ Elements Order ──────────────────────────────────────────────╢
 ║    [ ] Animated spinner                                       ║
@@ -81,6 +85,9 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ║    [■] Randomize “Worked” text                        ON      ║
 ║    [■] Tokens spent                                   ON      ║
 ║    [■] Mid-turn inputs                                ON      ║
+║    [■] Response model                                 ON      ║
+║    [■] Response model color                      ‹ muted ›    ║
+║    [■] Response model dimmed                         OFF      ║
 ║                                                               ║
 ╟─ Word Packs ──────────────────────────────────────────────────╢
 ║    [ ] Doctor Who                                    OFF      ║
@@ -98,7 +105,7 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ╟───────────────────────────────────────────────────────────────╢
 ║  ↑↓ move  PgUp/PgDn page  ←→ select                           ║
 ║  ␣ toggle  ⏎ apply  esc cancel                                ║
-╚═══════════════════════════════════════════════════════[ 9/50 ]╝
+╚═══════════════════════════════════════════════════════[ 9/54 ]╝
 ```
 
 ### Word packs
@@ -112,14 +119,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
@@ -133,7 +141,7 @@ full brightness for 1.5 seconds, then fades through five theme-aware shades to t
 the next 0.25 seconds before returning to the placeholder; a new count restores full brightness and
 restarts the cycle.
 
-The response model is captured from assistant responses, displayed as its sanitized value with no label only when it meaningfully differs from the selected model, and defaults to the final loader detail after output tokens. Equivalent local paths and decorated filenames are suppressed. It can be hidden, recolored, permanently dimmed, or reordered. After the agent settles, its final value remains visible for 3 seconds, fades through five theme-aware shades over 0.5 seconds, then clears; new work cancels the pending fade.
+The response model is captured from assistant responses, displayed as its sanitized value with no label only when it meaningfully differs from the selected model, and defaults to the final loader detail after output tokens. Equivalent local paths and decorated filenames are suppressed. It can be hidden, recolored, permanently dimmed, or reordered. When the active provider is `switchyard`, the loader and its post-settlement hold/fade use NVIDIA green (`#84c51a`, matching pi-topping-statusline) regardless of the configured Response model color; the dim setting still applies. After the agent settles, its final value remains visible for 3 seconds, fades through five theme-aware shades over 0.5 seconds, then clears; new work cancels the pending fade.
 
 ## Requirements
 
@@ -149,7 +157,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.2",
   "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",
@@ -30,8 +30,8 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.4",
-    "@earendil-works/pi-tui": "0.84.4",
+    "@earendil-works/pi-coding-agent": "0.86.0",
+    "@earendil-works/pi-tui": "0.86.0",
     "@types/node": "^24.0.0",
     "typescript": "^5.9.3"
   },

package/src/format.ts

@@ -44,8 +44,13 @@ export type LoaderElement = "spinner" | "text" | "meter" | "elapsed" | "tokens"
 /** Default first-use working-indicator element order. */
 export const DEFAULT_LOADER_ORDER: readonly LoaderElement[] = ["spinner", "text", "meter", "tokenRate", "elapsed", "tokens", "responseModel"];
 
-/** Elements share a detail group; separators are dimmed and non-rate details use muted. */
-const DETAIL_ELEMENTS: ReadonlySet<LoaderElement> = new Set(["elapsed", "tokens", "tokenRate", "responseModel"]);
+/** Elements share a detail group; "raw" details arrive pre-colored and must not be dimmed. */
+const DETAIL_STYLES = new Map<LoaderElement, "muted" | "raw">([
+	["elapsed", "muted"],
+	["tokens", "muted"],
+	["tokenRate", "raw"],
+	["responseModel", "raw"],
+]);
 
 const TOKEN_UNITS = [
 	{ threshold: 10_000, divisor: 1_000, decimals: 1, suffix: "k" },
@@ -91,7 +96,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 +105,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,
@@ -169,9 +174,9 @@ export function buildWorkingMessage(
 	for (const element of order) {
 		const value = parts[element];
 		if (!value) continue;
-		if (DETAIL_ELEMENTS.has(element)) {
-			// tokenRate and responseModel arrive pre-colored; dimming them here would replace their configured colors.
-			details.push(element === "tokenRate" || element === "responseModel" ? value : theme.fg("muted", value));
+		const style = DETAIL_STYLES.get(element);
+		if (style) {
+			details.push(style === "raw" ? value : theme.fg("muted", value));
 			continue;
 		}
 		flushDetails();

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/nvidia-green.ts

@@ -0,0 +1,37 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { getThinkingLevelColorizer, type ThinkingLevel } from "./format.ts";
+import type { ThinkingLevelColor, ThinkingLevelSettingColor } from "./settings.ts";
+
+/** Provider id whose working-loader response model uses NVIDIA green. */
+export const SWITCHYARD_PROVIDER = "switchyard";
+
+/** Bright NVIDIA green shared with pi-topping-statusline's Switchyard border. */
+export const NVIDIA_GREEN_HEX = "#84c51a";
+
+const NVIDIA_GREEN_RGB = [1, 3, 5].map((offset) => Number.parseInt(NVIDIA_GREEN_HEX.slice(offset, offset + 2), 16));
+const NVIDIA_GREEN_ANSI = `\x1b[38;2;${NVIDIA_GREEN_RGB.join(";")}m`;
+
+export function isSwitchyardProvider(provider: string | undefined): boolean {
+	return provider?.trim().toLowerCase() === SWITCHYARD_PROVIDER;
+}
+
+export function colorizeNvidiaGreen(text: string): string {
+	return `${NVIDIA_GREEN_ANSI}${text}\x1b[39m`;
+}
+
+/**
+ * Build the working-loader response-model colorizer.
+ *
+ * Switchyard always uses NVIDIA green; other providers retain the configured
+ * theme/thinking-level color.
+ */
+export function getResponseModelColorizer(
+	theme: Pick<Theme, "fg" | "getThinkingBorderColor">,
+	color: ThinkingLevelColor | ThinkingLevelSettingColor,
+	thinkingLevel: ThinkingLevel | undefined,
+	provider: string | undefined,
+): (text: string) => string {
+	return isSwitchyardProvider(provider)
+		? colorizeNvidiaGreen
+		: getThinkingLevelColorizer(theme, color, thinkingLevel);
+}

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/preview.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_PREVIEW_WIDTH, type PreviewResult } from "./menu.ts";
 import { ActivityMeter, rateToLevel } from "./activity-meter.ts";
 import { buildWorkingMessage, DEFAULT_WORKING_WORD, dimAttribute, ELAPSED_INTERVAL_MS, formatElapsed, formatTokenRate, formatTokens, getThinkingLevelColorizer, isFullyDefaultAppearance, METER_INTERVAL_MS, SHIMMER_INTERVAL_MS, shimmerString, SPINNER_FRAME_MS, SPINNER_FRAMES } from "./format.ts";
+import { getResponseModelColorizer } from "./nvidia-green.ts";
 import { buildCompletionMarkerContent, buildCompletionMarkerLine, buildPromptBoxLines } from "./prompt-decorator.ts";
 import { DEFAULT_SETTINGS, fromCycleDirection, fromCycleSpeed, isBorderStyle, isDoneMarkerBorderColor, isDoneMarkerBorderStyle, isDoneMarkerStyle, isPromptBorderColor, isSpinnerColor, isThinkingLevelColor, LOADER_ORDER_ID, MENU_ENTRIES, parseLoaderOrder } from "./settings.ts";
 import { isWordPackEnabled, selectWorkingTextSelection, wordPacksPath, type WordPack } from "./word-packs.ts";
@@ -62,7 +63,7 @@ export class PreviewRenderer {
 		const order = parseLoaderOrder(values[LOADER_ORDER_ID]);
 		let responseModelColor = DEFAULT_SETTINGS.decorations.responseModelColor;
 		if (isThinkingLevelColor(values.responseModelColor)) responseModelColor = values.responseModelColor;
-		const responseModelColorizer = getThinkingLevelColorizer(this.#ctx.ui.theme, responseModelColor, this.#ctx.thinkingLevel);
+		const responseModelColorizer = getResponseModelColorizer(this.#ctx.ui.theme, responseModelColor, this.#ctx.thinkingLevel, this.#ctx.model?.provider);
 		const responseModelColored = features.responseModel ? responseModelColorizer("test-model") : "";
 		const responseModel = responseModelColored && values.responseModelDimmed === true ? dimAttribute(responseModelColored) : responseModelColored;
 		if (isFullyDefaultAppearance(features, decorations)) {
@@ -173,7 +174,13 @@ export class PreviewRenderer {
 		const details: string[] = [];
 		if (values.doneMarkerTokens === true) details.push("↓ 949 tokens");
 		if (values.doneMarkerInputs === true) details.push("2 mid-turn inputs");
-		const content = buildCompletionMarkerContent(theme, icon, word, "2m 52s", details);
+		let model = "";
+		if (values.doneMarkerModel === true) {
+			const color = isThinkingLevelColor(values.doneMarkerModelColor) ? values.doneMarkerModelColor : DEFAULT_SETTINGS.decorations.doneMarkerModelColor;
+			const modelColored = getThinkingLevelColorizer(theme, color, this.#ctx.thinkingLevel)("test-model");
+			model = values.doneMarkerModelDimmed === true ? dimAttribute(modelColored) : modelColored;
+		}
+		const content = buildCompletionMarkerContent(theme, icon, word, "2m 52s", details, model);
 		const borderStyle = isDoneMarkerBorderStyle(values.doneMarkerBorderStyle) ? values.doneMarkerBorderStyle : "none";
 		const borderColor = isDoneMarkerBorderColor(values.doneMarkerBorderColor) ? values.doneMarkerBorderColor : DEFAULT_SETTINGS.decorations.doneMarkerBorderColor;
 		const markerStyle = isDoneMarkerStyle(values.doneMarkerStyle) ? values.doneMarkerStyle : DEFAULT_SETTINGS.decorations.doneMarkerStyle;

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;
@@ -38,16 +41,18 @@ type PromptTheme = {
 
 const COMPLETION_MARKER_TRAIL_RUNS = [6, 4, 2, 1] as const;
 
-/** Assemble the completion-marker content: an optional icon, then the dim `word for elapsed (details)` summary. */
+/** Assemble the completion-marker content: an optional icon, then the dim `word for elapsed (details)` summary, then an optional pre-styled model suffix. */
 export function buildCompletionMarkerContent(
 	theme: PromptTheme,
 	icon: string,
 	word: string,
 	elapsed: string,
 	details: string[],
+	model = "",
 ): string {
 	const tail = details.length ? ` (${details.join(" · ")})` : "";
-	return `${icon}${theme.fg("dim", `${icon ? " " : ""}${word} for ${elapsed}${tail}`)}`;
+	const summary = theme.fg("dim", `${icon ? " " : ""}${word} for ${elapsed}${tail}`);
+	return `${icon}${summary}${model ? `${theme.fg("dim", " · ")}${model}` : ""}`;
 }
 
 /** Build one decorated completion-marker line, clipped to the available width. */

package/src/session.ts

@@ -40,12 +40,13 @@ import {
 } from "./format.ts";
 import { isSiblingSetupEnabled } from "./flags.ts";
 import { showMenu } from "./menu.ts";
+import { getResponseModelColorizer } from "./nvidia-green.ts";
 import { registerSetupCommand } from "./setup-command.ts";
 import { applyMenuResult, buildMenuSections, loadSettings, saveSettings, type ThinkingLevelColor } from "./settings.ts";
-import { notifyMissingToppingsOnce } from "./toppings.ts";
+import { announceMissingToppingsOnce, type MissingToppingsEntryData, renderMissingToppingsEntry, SETUP_ENTRY_TYPE } from "./toppings.ts";
 import { PreviewRenderer } from "./preview.ts";
 import { buildCompletionMarkerContent, buildCompletionMarkerLine, PROMPT_BOX_TYPE, promptBoxRenderer, type PromptBoxDetails } from "./prompt-decorator.ts";
-import { modelsResemble, stripControlChars } from "./util.ts";
+import { isPlainObject, modelsResemble, stripControlChars } from "./util.ts";
 import { loadBundledWordPacks, loadUserWordPacks, pickWorkingTextSelection, type WorkingTextSelection, type WordPack } from "./word-packs.ts";
 
 type MessageStartEvent = Extract<ExtensionEvent, { type: "message_start" }>;
@@ -77,6 +78,7 @@ interface DoneEntryData {
 	tokens?: number;
 	midTurnInputs?: number;
 	thinkingLevel?: ThinkingLevel;
+	model?: string;
 }
 
 interface SessionState {
@@ -148,6 +150,10 @@ function waitingLabel(waiting: NonNullable<SessionState["waiting"]>): string {
 	return title ? `Waiting: ${title}` : WAITING_LABELS[waiting.kind];
 }
 
+function responseModelOf(message: unknown): unknown {
+	return isPlainObject(message) ? message.responseModel : undefined;
+}
+
 /** Owns mutable extension state and Pi lifecycle registrations. */
 export class SessionManager {
 	#counter = new StreamingWordCounter();
@@ -175,7 +181,7 @@ export class SessionManager {
 		this.#state.activityMeter.setDirection(this.#settings.decorations.meterDirection);
 		if (this.usable(ctx)) {
 			this.applyIndicator(ctx);
-			if (isSiblingSetupEnabled()) notifyMissingToppingsOnce(this.#pi, ctx.ui);
+			if (isSiblingSetupEnabled()) announceMissingToppingsOnce(this.#pi);
 		}
 	};
 
@@ -232,7 +238,7 @@ export class SessionManager {
 		if (this.usable(ctx) && event.message.role === "assistant") {
 			this.#state.liveTokens = 0;
 			this.#counter.reset();
-			this.updateResponseModel((event.message as { responseModel?: unknown }).responseModel);
+			this.updateResponseModel(responseModelOf(event.message));
 		}
 	};
 
@@ -247,7 +253,7 @@ export class SessionManager {
 			this.#state.liveTokens += this.#counter.count(assistantEvent.delta, assistantEvent.type);
 		}
 		const rawResponseModel = (assistantEvent as { partial?: { responseModel?: unknown } } | undefined)?.partial?.responseModel
-			?? (event.message as { responseModel?: unknown } | undefined)?.responseModel;
+			?? responseModelOf(event.message);
 		this.updateResponseModel(rawResponseModel);
 	};
 
@@ -268,7 +274,7 @@ export class SessionManager {
 		}
 		this.#state.liveTokens = 0;
 		this.#counter.reset();
-		this.updateResponseModel((event.message as { responseModel?: unknown }).responseModel);
+		this.updateResponseModel(responseModelOf(event.message));
 	};
 
 	#onToolExecutionStart = async (_e: ToolExecutionStartEvent, ctx: ExtensionContext): Promise<void> => {
@@ -324,6 +330,7 @@ export class SessionManager {
 				tokens: this.#state.confirmTokens,
 				midTurnInputs: this.#state.midTurnInputs,
 				thinkingLevel: ctx.thinkingLevel,
+				model: this.#state.responseModel || undefined,
 			});
 		}
 		this.#currentCtx = null;
@@ -346,11 +353,16 @@ export class SessionManager {
 			details.push(`${entry.data.midTurnInputs} mid-turn input${entry.data.midTurnInputs === 1 ? "" : "s"}`);
 		}
 		const icon = features.doneMarkerIcon ? theme.fg("text", this.#settings.decorations.useNerdFont ? "" : "π") : "";
-		const markerContent = buildCompletionMarkerContent(theme, icon, word, formatElapsed(elapsedMs), details);
+		const thinkingLevel = isThinkingLevel(entry.data.thinkingLevel) ? entry.data.thinkingLevel : undefined;
+		const rawModel = typeof entry.data.model === "string" ? stripControlChars(entry.data.model).trim() : "";
+		const modelColored = features.doneMarkerModel && rawModel
+			? getThinkingLevelColorizer(theme, this.#settings.decorations.doneMarkerModelColor, thinkingLevel)(rawModel)
+			: "";
+		const model = modelColored && this.#settings.decorations.doneMarkerModelDimmed ? dimAttribute(modelColored) : modelColored;
+		const markerContent = buildCompletionMarkerContent(theme, icon, word, formatElapsed(elapsedMs), details, model);
 		const borderStyle = this.#settings.decorations.doneMarkerBorderStyle;
 		const borderColor = this.#settings.decorations.doneMarkerBorderColor;
 		const markerStyle = this.#settings.decorations.doneMarkerStyle;
-		const thinkingLevel = isThinkingLevel(entry.data.thinkingLevel) ? entry.data.thinkingLevel : undefined;
 		if (borderStyle === "none") return new Text(markerContent);
 
 		let cachedWidth: number | undefined;
@@ -383,6 +395,7 @@ export class SessionManager {
 		this.#pi.on("ui_prompt_end", this.#onUIPromptEnd);
 		this.#pi.on("session_shutdown", this.#onSessionShutdown);
 		this.#pi.registerEntryRenderer<DoneEntryData>(DONE_ENTRY_TYPE, (entry, _o, theme) => this.#renderDoneEntry(entry, theme));
+		if (isSiblingSetupEnabled()) this.#pi.registerEntryRenderer<MissingToppingsEntryData>(SETUP_ENTRY_TYPE, (entry, _o, theme) => renderMissingToppingsEntry(entry, theme));
 		this.#pi.registerMessageRenderer<PromptBoxDetails>(PROMPT_BOX_TYPE, promptBoxRenderer);
 		this.#pi.registerCommand("topping-settings", {
 			description: "Configure prompt decoration, working-loader features/order, and completion-marker settings.",
@@ -487,7 +500,7 @@ export class SessionManager {
 	private startResponseModelFade(ctx: ExtensionContext, model: string, color: ThinkingLevelColor, dimmed: boolean): void {
 		this.cancelResponseModelFade(ctx);
 		const generation = this.#state.responseModelFadeGeneration;
-		const colorizer = getThinkingLevelColorizer(ctx.ui.theme, color, ctx.thinkingLevel);
+		const colorizer = getResponseModelColorizer(ctx.ui.theme, color, ctx.thinkingLevel, ctx.model?.provider);
 		const render = (shade?: number): void => {
 			const colored = shade === undefined
 				? colorizer(model)
@@ -581,7 +594,7 @@ export class SessionManager {
 			? getThinkingLevelColorizer(ctx.ui.theme, decorations.spinnerColor, ctx.thinkingLevel)(SPINNER_FRAMES[Math.floor(now / SPINNER_FRAME_MS) % SPINNER_FRAMES.length]!)
 			: "";
 		const responseModelColored = features.responseModel && state.responseModel
-			? getThinkingLevelColorizer(ctx.ui.theme, decorations.responseModelColor, ctx.thinkingLevel)(state.responseModel)
+			? getResponseModelColorizer(ctx.ui.theme, decorations.responseModelColor, ctx.thinkingLevel, ctx.model?.provider)(state.responseModel)
 			: "";
 		const responseModel = responseModelColored && decorations.responseModelDimmed ? dimAttribute(responseModelColored) : responseModelColored;
 		if (isFullyDefaultAppearance(features, decorations)) {

package/src/settings.ts

@@ -73,6 +73,8 @@ export interface DecoratorSettings {
 		doneMarkerBorderStyle: DoneMarkerBorderStyle;
 		doneMarkerBorderColor: DoneMarkerBorderColor;
 		doneMarkerStyle: DoneMarkerStyle;
+		doneMarkerModelColor: ThinkingLevelColor;
+		doneMarkerModelDimmed: boolean;
 		spinnerColor: SpinnerColor;
 		spinnerColorEnabled: boolean;
 		meterColor: ThinkingLevelColor;
@@ -99,14 +101,15 @@ export interface DecoratorSettings {
 		randomizeDoneMarker: boolean;
 		doneMarkerTokens: boolean;
 		doneMarkerInputs: boolean;
+		doneMarkerModel: boolean;
 	};
 	loaderOrder: LoaderElement[];
 	wordPacks: Record<string, boolean>;
 }
 
 export const DEFAULT_SETTINGS: DecoratorSettings = {
-	decorations: { animatedSpinner: true, shimmer: true, shimmerInverted: false, shimmerDirection: "ltr", shimmerDirectionEnabled: true, shimmerSpeed: "normal", shimmerSpeedEnabled: true, tokenActivityMonitor: true, meterDirection: "rtl", meterDirectionEnabled: true, decorateUserPrompt: true, borderColor: "thinking-level", borderColorEnabled: true, borderStyle: "double", borderStyleEnabled: true, doneMarkerBorderStyle: "none", doneMarkerBorderColor: "thinking-level", doneMarkerStyle: "elite", spinnerColor: "thinking-level", spinnerColorEnabled: true, meterColor: "accent", meterColorEnabled: true, meterDimmed: false, tokenRateColor: "warning", tokenRateDimmed: false, responseModelColor: "accent", responseModelDimmed: false, promptIcon: true, promptTimestamp: true, promptProvider: true, promptModel: true, useNerdFont: true },
-	features: { substituteDefaultMessage: true, elapsedTime: true, outputTokens: true, tokenRate: true, responseModel: true, doneMarker: true, doneMarkerIcon: true, randomizeDoneMarker: true, doneMarkerTokens: true, doneMarkerInputs: true },
+	decorations: { animatedSpinner: true, shimmer: true, shimmerInverted: false, shimmerDirection: "ltr", shimmerDirectionEnabled: true, shimmerSpeed: "normal", shimmerSpeedEnabled: true, tokenActivityMonitor: true, meterDirection: "rtl", meterDirectionEnabled: true, decorateUserPrompt: true, borderColor: "thinking-level", borderColorEnabled: true, borderStyle: "double", borderStyleEnabled: true, doneMarkerBorderStyle: "none", doneMarkerBorderColor: "thinking-level", doneMarkerStyle: "elite", doneMarkerModelColor: "muted", doneMarkerModelDimmed: false, spinnerColor: "thinking-level", spinnerColorEnabled: true, meterColor: "accent", meterColorEnabled: true, meterDimmed: false, tokenRateColor: "warning", tokenRateDimmed: false, responseModelColor: "accent", responseModelDimmed: false, promptIcon: true, promptTimestamp: true, promptProvider: true, promptModel: true, useNerdFont: true },
+	features: { substituteDefaultMessage: true, elapsedTime: true, outputTokens: true, tokenRate: true, responseModel: true, doneMarker: true, doneMarkerIcon: true, randomizeDoneMarker: true, doneMarkerTokens: true, doneMarkerInputs: true, doneMarkerModel: true },
 	loaderOrder: [...DEFAULT_LOADER_ORDER],
 	wordPacks: {},
 };
@@ -154,7 +157,7 @@ function mergeGroup<T extends Record<string, boolean | string>>(defaults: T, par
 		else if (key === "borderColor" && isPromptBorderColor(value)) valid = value;
 		else if (key === "doneMarkerBorderColor" && value === "default") valid = "thinking-level";
 		else if (key === "doneMarkerBorderColor" && isDoneMarkerBorderColor(value)) valid = value;
-		else if ((key === "meterColor" || key === "tokenRateColor" || key === "responseModelColor") && isThinkingLevelColor(value)) valid = value;
+		else if ((key === "meterColor" || key === "tokenRateColor" || key === "responseModelColor" || key === "doneMarkerModelColor") && isThinkingLevelColor(value)) valid = value;
 		else if (key === "borderStyle" && isBorderStyle(value)) valid = value;
 		else if (key === "doneMarkerBorderStyle" && isDoneMarkerBorderStyle(value)) valid = value;
 		else if (key === "doneMarkerStyle" && isDoneMarkerStyle(value)) valid = value;
@@ -221,6 +224,9 @@ export const MENU_ENTRIES: readonly MenuEntry[] = [
 	{ id: "randomizeDoneMarker", label: "Randomize “Worked” text", section: "Completion Marker", group: "features", key: "randomizeDoneMarker" },
 	{ id: "doneMarkerTokens", label: "Tokens spent", section: "Completion Marker", group: "features", key: "doneMarkerTokens" },
 	{ id: "doneMarkerInputs", label: "Mid-turn inputs", section: "Completion Marker", group: "features", key: "doneMarkerInputs" },
+	{ id: "doneMarkerModel", label: "Response model", section: "Completion Marker", group: "features", key: "doneMarkerModel" },
+	{ id: "doneMarkerModelColor", label: "Response model color", section: "Completion Marker", group: "decorations", key: "doneMarkerModelColor", cycleValues: THINKING_LEVEL_COLOR_VALUES, cycleValueLabels: THINKING_LEVEL_CYCLE_LABELS },
+	{ id: "doneMarkerModelDimmed", label: "Response model dimmed", section: "Completion Marker", group: "decorations", key: "doneMarkerModelDimmed" },
 	{ id: "useNerdFont", label: "Use NerdFont icons", section: "Options", group: "decorations", key: "useNerdFont" },
 ];
 
@@ -247,6 +253,7 @@ function setDecorationCycleValue(decorations: DecorationSettings, key: keyof Dec
 		case "meterColor":
 		case "tokenRateColor":
 		case "responseModelColor":
+		case "doneMarkerModelColor":
 			if (isThinkingLevelColor(value)) decorations[key] = value;
 			return;
 		case "doneMarkerBorderColor":
@@ -318,6 +325,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 CustomEntry, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, type Component } 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,16 +60,39 @@ interface PiSettings {
 
 interface SettingsToppingState {
 	packageInstalled: boolean;
+	packageSource?: string;
 	extensionPresent: boolean;
 	extensionActive: boolean;
 }
 
+export const SETUP_ENTRY_TYPE = "pi-topping-setup";
+
+export interface MissingToppingsEntryData {
+	readonly toppings: ReadonlyArray<Pick<Topping, "pkg" | "provides">>;
+}
+
 let setupNoticeHandled = false;
 
 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 +110,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 +123,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 +151,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 +159,60 @@ 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}`),
+function renderMissingToppings(
+	toppings: MissingToppingsEntryData["toppings"],
+	theme: Pick<Theme, "fg">,
+	width: number,
+): string[] {
+	const safeWidth = Math.max(0, width);
+	const text = (value: string): string => theme.fg("text", value);
+	const accent = (value: string): string => theme.fg("accent", value);
+	const fit = (line: string): string => truncateToWidth(line, safeWidth, "");
+	const rule = theme.fg("warning", "─".repeat(safeWidth));
+	return [
+		rule,
+		fit(text(`pi-topping: ${toppings.length} topping extension${toppings.length === 1 ? "" : "s"} missing`)),
+		"",
+		...toppings.map(({ pkg, provides }) => fit(`${text("• ")}${accent(pkg)}${text(` — ${provides}`)}`)),
 		"",
-		"Run `/topping-setup` to selectively install them",
-		"Run `/topping-setup disable-side-toppings-check` to suppress this message",
+		fit(`${text("Run ")}${accent("/topping-setup")}${text(" to selectively install them")}`),
+		fit(`${text("Run ")}${accent("/topping-setup disable-side-toppings-check")}${text(" to suppress this message")}`),
+		rule,
 	];
-	const width = Math.max(title.length + 6, ...body.map((line) => line.length + 4));
-	const blankRow = `│${" ".repeat(width - 2)}│`;
-	return [
-		`╭─ ${title} ${"─".repeat(width - title.length - 5)}╮`,
-		blankRow,
-		...body.map((line) => `│ ${line.padEnd(width - 4)} │`),
-		blankRow,
-		`╰${"─".repeat(width - 2)}╯`,
-	].join("\n");
 }
 
-export function notifyMissingToppingsOnce(pi: ExtensionAPI, ui: Pick<ExtensionUIContext, "notify">): void {
+export function renderMissingToppingsEntry(
+	entry: CustomEntry<MissingToppingsEntryData>,
+	theme: Theme,
+): Component | undefined {
+	if (!entry.data || !Array.isArray(entry.data.toppings)) return undefined;
+	let cachedWidth: number | undefined;
+	let cachedLines: string[] | undefined;
+	return {
+		render(width: number): string[] {
+			if (cachedWidth !== width) {
+				cachedWidth = width;
+				cachedLines = renderMissingToppings(entry.data!.toppings, theme, width);
+			}
+			return cachedLines!;
+		},
+		invalidate(): void {
+			cachedWidth = undefined;
+			cachedLines = undefined;
+		},
+	};
+}
+
+export function announceMissingToppingsOnce(pi: ExtensionAPI): 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) {
+		pi.appendEntry<MissingToppingsEntryData>(SETUP_ENTRY_TYPE, {
+			toppings: missing.map(({ topping }) => ({ pkg: topping.pkg, provides: topping.provides })),
+		});
+	}
 }
 
 /** Test-only reset for the once-per-process session-start notice. */