@underactive/pi-topping 0.7.1 → 0.8.0

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
+
+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
@@ -134,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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@underactive/pi-topping",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "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" },
@@ -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/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/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

@@ -41,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

@@ -38,14 +38,14 @@ import {
 	StreamingWordCounter,
 	type ThinkingLevel,
 } 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 +77,7 @@ interface DoneEntryData {
 	tokens?: number;
 	midTurnInputs?: number;
 	thinkingLevel?: ThinkingLevel;
+	model?: string;
 }
 
 interface SessionState {
@@ -148,6 +149,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 +180,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);
+			announceMissingToppingsOnce(this.#pi);
 		}
 	};
 
@@ -232,7 +237,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 +252,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 +273,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 +329,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 +352,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,12 +394,13 @@ 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));
+		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.",
 			handler: async (_a, ctx) => this.showSettings(ctx),
 		});
-		if (isSiblingSetupEnabled()) registerSetupCommand(this.#pi);
+		registerSetupCommand(this.#pi);
 	}
 
 	private usable(ctx: ExtensionContext): boolean {
@@ -487,7 +499,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 +593,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":

package/src/toppings.ts

@@ -1,5 +1,5 @@
-import { getAgentDir, type ExtensionAPI, type ExtensionUIContext, type Theme } from "@earendil-works/pi-coding-agent";
-import { visibleWidth } from "@earendil-works/pi-tui";
+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";
@@ -65,6 +65,12 @@ interface SettingsToppingState {
 	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[] {
@@ -153,52 +159,60 @@ export function findMissingToppings(pi: ExtensionAPI): ToppingStatus[] {
 	return detectToppings(pi).filter((status) => !status.active);
 }
 
-interface BannerLine {
-	readonly plain: string;
-	readonly styled: string;
-}
-
-function renderMissingBanner(missing: readonly ToppingStatus[], theme: Pick<Theme, "fg">): string {
+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 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")}`,
+	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}`)}`)),
+		"",
+		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,
+	];
+}
+
+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!;
 		},
-		{
-			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")}`,
+		invalidate(): void {
+			cachedWidth = undefined;
+			cachedLines = undefined;
 		},
-	];
-	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 [
-		`${warning("╭─")} ${title.styled} ${warning("─".repeat(width - titleWidth - 5))}${warning("╮")}`,
-		blankRow,
-		...body.map((line) => `${warning("│")} ${line.styled}${" ".repeat(width - visibleWidth(line.plain) - 4)} ${warning("│")}`),
-		blankRow,
-		`${warning("╰")}${warning("─".repeat(width - 2))}${warning("╯")}`,
-	].join("\n");
+	};
 }
 
-export function notifyMissingToppingsOnce(pi: ExtensionAPI, ui: Pick<ExtensionUIContext, "notify" | "theme">): void {
+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, ui.theme)}`, "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. */

package/src/flags.ts

@@ -1,19 +0,0 @@
-/**
- * Feature gates for unreleased functionality.
- *
- * Sibling-topping detection and the `/topping-setup` command ship dark: the
- * default below stays `false` until the flow is ready for the public. Setting
- * `PI_TOPPING_SIBLING_SETUP` to any value other than `0`, `false`, `off`, or
- * `no` (case-insensitive) opts a session in without touching code.
- */
-
-const SIBLING_SETUP_DEFAULT = false;
-
-const FALSEY_FLAG_VALUES = new Set(["0", "false", "off", "no"]);
-
-/** Whether the sibling-topping setup flow is registered and advertised. */
-export function isSiblingSetupEnabled(): boolean {
-	const value = process.env.PI_TOPPING_SIBLING_SETUP?.trim().toLowerCase();
-	if (value === undefined || value === "") return SIBLING_SETUP_DEFAULT;
-	return !FALSEY_FLAG_VALUES.has(value);
-}