@underactive/pi-topping 0.8.0 → 0.8.1

package/README.md

@@ -100,17 +100,20 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ║    [ ] Star Trek                                     OFF      ║
 ║    [ ] Star Wars                                     OFF      ║
 ║                                                               ║
+║    [■] Include default/random “Working” text          ON      ║
+║                                                               ║
 ╟─ Options ─────────────────────────────────────────────────────╢
 ║    [■] Use NerdFont icons                             ON      ║
+║    [ ] Response model footer                         OFF      ║
 ╟───────────────────────────────────────────────────────────────╢
 ║  ↑↓ move  PgUp/PgDn page  ←→ select                           ║
 ║  ␣ toggle  ⏎ apply  esc cancel                                ║
-╚═══════════════════════════════════════════════════════[ 9/54 ]╝
+╚═══════════════════════════════════════════════════════[ 9/56 ]╝
 ```
 
 ### Word packs
 
-Base activity words are always available. All word packs, including the shipped **Doctor Who**, **Firefly**, **Hitchhiker's Guide**, **The Lord of the Rings**, **The Matrix**, **Portal**, **SimCity**, **Star Trek**, and **Star Wars** packs and custom packs, are disabled by default. Enable packs in `/topping-settings` to add their entries to the same uniformly selected pool. When Randomize “Worked” text is on, the completion marker uses the selected entry’s matching past tense; otherwise it uses `Worked`.
+Base activity words are included by default. All word packs, including the shipped **Doctor Who**, **Firefly**, **Hitchhiker's Guide**, **The Lord of the Rings**, **The Matrix**, **Portal**, **SimCity**, **Star Trek**, and **Star Wars** packs and custom packs, are disabled by default. Enable packs in `/topping-settings` to add their entries to the same uniformly selected pool. With at least one pack enabled, turn off **Include default/random “Working” text** to draw only from enabled packs; with none enabled the option is locked on. When Randomize “Worked” text is on, the completion marker uses the selected entry’s matching past tense; otherwise it uses `Worked`.
 
 Bundled packs live in [`wordpacks/`](wordpacks/). Copy `wordpacks/doctor-who.json`, `wordpacks/firefly.json`, `wordpacks/hitchhikers-guide.json`, `wordpacks/lord-of-the-rings.json`, `wordpacks/matrix.json`, `wordpacks/portal.json`, `wordpacks/simcity.json`, `wordpacks/star-trek.json`, or `wordpacks/star-wars.json` to `~/.pi/agent/pi-topping/word-packs.json`, then change the pack `id` (the bundled `doctor-who`, `firefly`, `hitchhikers-guide`, `lord-of-the-rings`, `matrix`, `portal`, `simcity`, `star-trek`, and `star-wars` IDs are reserved), name, and words:
 
@@ -141,7 +144,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. 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.
+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. While pi-topping-statusline embeds the loader in its status bar, the model slides out tail first from behind its separator over 0.3 seconds when it first appears in a run, like that bar's embedded status; elsewhere it appears at once, and a different model replacing it always swaps in place. Equivalent local paths and decorated filenames are suppressed. Its loader display can be hidden, recolored, permanently dimmed, or reordered. The independent **Response model footer** option is disabled by default; when enabled, the final model appears under the editor after settlement, remains visible for 3 seconds, fades through five theme-aware shades over 0.5 seconds, then clears. New work cancels the pending fade. When the active provider is `switchyard`, the loader and footer hold/fade use NVIDIA green (`#84c51a`, matching pi-topping-statusline) regardless of the configured Response model color; the dim setting still applies.
 
 ## Requirements
 
@@ -157,7 +160,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 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.
+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, loading, and default-text selection, response-model loader and footer behavior, the `menu.ts` component, the settings menu wiring end to end, and the `/topping-setup` command's install and uninstall flows.
 
 ## Limitations
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@underactive/pi-topping",
-  "version": "0.8.0",
+  "version": "0.8.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",
@@ -12,7 +12,7 @@
   "bugs": {
     "url": "https://github.com/underactive/pi-topping/issues"
   },
-  "homepage": "https://github.com/underactive/pi-topping#readme",
+  "homepage": "https://esison.dev/pi-topping",
   "type": "module",
   "engines": {
     "node": ">=22.19.0"

package/src/format.ts

@@ -1,5 +1,5 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { ThinkingLevelColor, ThinkingLevelSettingColor } from "./settings.ts";
+import type { ThinkingLevelColor } from "./settings.ts";
 
 /** Pi's default working-indicator frames (same braille spinner as pi-tui's Loader). */
 export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -21,7 +21,7 @@ export function isThinkingLevel(value: unknown): value is ThinkingLevel {
 /** Build a colorizer for a configured color, including Pi's active thinking-level color. */
 export function getThinkingLevelColorizer(
 	theme: Pick<Theme, "fg" | "getThinkingBorderColor">,
-	color: ThinkingLevelColor | ThinkingLevelSettingColor,
+	color: ThinkingLevelColor,
 	thinkingLevel: ThinkingLevel | undefined,
 ): (text: string) => string {
 	return color === "thinking-level"
@@ -105,6 +105,25 @@ 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;
 
+/** Milliseconds over which a newly shown response model slides out of the working loader. */
+export const RESPONSE_MODEL_SLIDE_MS = 300;
+
+/** Milliseconds between working-loader repaints while the response model slides out. */
+export const RESPONSE_MODEL_SLIDE_FRAME_MS = 30;
+
+/**
+ * The part of a sliding response model visible `elapsedMs` after it appeared. It emerges
+ * tail first from behind the separator before it, as pi-topping-statusline slides an
+ * embedded status out, and shows whole once RESPONSE_MODEL_SLIDE_MS has passed.
+ */
+export function slideOutTail(text: string, elapsedMs: number): string {
+	if (elapsedMs >= RESPONSE_MODEL_SLIDE_MS) return text;
+	const chars = [...text];
+	const progress = Math.max(0, elapsedMs) / RESPONSE_MODEL_SLIDE_MS;
+	const shown = Math.round(chars.length * 0.5 * (1 - Math.cos(Math.PI * progress)));
+	return chars.slice(chars.length - shown).join("");
+}
+
 /** Render one fade shade by blending the colorizer's color toward the active theme's dim color. */
 export function fadeThemeColorString(
 	text: string,

package/src/loader-message.ts

@@ -0,0 +1,58 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { buildWorkingMessage, DEFAULT_WORKING_WORD, dimAttribute, fadeThemeColorString, formatElapsed, formatTokens, getThinkingLevelColorizer, isFullyDefaultAppearance, shimmerString, SPINNER_FRAME_MS, SPINNER_FRAMES, TOKEN_RATE_PLACEHOLDER, type LoaderElement, type ThinkingLevel } from "./format.ts";
+import { getResponseModelColorizer } from "./nvidia-green.ts";
+import type { DecoratorSettings } from "./settings.ts";
+
+type Features = Pick<DecoratorSettings["features"], "substituteDefaultMessage" | "elapsedTime" | "outputTokens" | "tokenRate" | "responseModel">;
+type Decorations = Pick<DecoratorSettings["decorations"], "shimmer" | "shimmerInverted" | "shimmerDirection" | "shimmerSpeed" | "tokenActivityMonitor" | "meterColor" | "meterDimmed" | "tokenRateColor" | "tokenRateDimmed" | "responseModelColor" | "responseModelDimmed" | "spinnerColor">;
+interface LoaderParts {
+	spinnerAtMs?: number;
+	word: string;
+	shimmerAtMs?: number;
+	renderMeter?: (colorizer: (text: string) => string, dimmed: boolean) => string;
+	elapsedMs?: number;
+	outputTokens?: number;
+	tokenRateText?: string;
+	tokenRateShade?: number;
+	responseModel?: string;
+}
+
+/** Assemble the live and preview loaders with identical styling and ordering. */
+export function buildLoaderMessage(
+	theme: Theme,
+	thinkingLevel: ThinkingLevel | undefined,
+	provider: string | undefined,
+	features: Features,
+	decorations: Decorations,
+	loaderOrder: readonly LoaderElement[],
+	parts: LoaderParts,
+): string {
+	const spinner = parts.spinnerAtMs === undefined ? "" : getThinkingLevelColorizer(theme, decorations.spinnerColor, thinkingLevel)(SPINNER_FRAMES[Math.floor(parts.spinnerAtMs / SPINNER_FRAME_MS) % SPINNER_FRAMES.length]!);
+	const responseModelColored = parts.responseModel ? getResponseModelColorizer(theme, decorations.responseModelColor, thinkingLevel, provider)(parts.responseModel) : "";
+	const responseModel = responseModelColored && decorations.responseModelDimmed ? dimAttribute(responseModelColored) : responseModelColored;
+	if (isFullyDefaultAppearance(features, decorations)) {
+		return buildWorkingMessage(theme, { spinner, text: theme.fg("dim", DEFAULT_WORKING_WORD), responseModel }, loaderOrder);
+	}
+	const word = features.substituteDefaultMessage ? parts.word : DEFAULT_WORKING_WORD;
+	const text = decorations.shimmer && parts.shimmerAtMs !== undefined
+		? shimmerString(word, parts.shimmerAtMs, theme, decorations.shimmerDirection, decorations.shimmerSpeed, decorations.shimmerInverted)
+		: theme.fg("text", word);
+	const meter = decorations.tokenActivityMonitor && parts.renderMeter
+		? parts.renderMeter(getThinkingLevelColorizer(theme, decorations.meterColor, thinkingLevel), decorations.meterDimmed)
+		: "";
+	let tokenRate = "";
+	if (features.tokenRate) {
+		if (!parts.tokenRateText) tokenRate = theme.fg("dim", TOKEN_RATE_PLACEHOLDER);
+		else {
+			const colorizer = getThinkingLevelColorizer(theme, decorations.tokenRateColor, thinkingLevel);
+			tokenRate = parts.tokenRateShade === undefined ? colorizer(parts.tokenRateText) : fadeThemeColorString(parts.tokenRateText, parts.tokenRateShade, theme, colorizer);
+		}
+		if (tokenRate && decorations.tokenRateDimmed) tokenRate = dimAttribute(tokenRate);
+	}
+	return buildWorkingMessage(theme, {
+		spinner, text, meter,
+		elapsed: features.elapsedTime && parts.elapsedMs !== undefined ? formatElapsed(parts.elapsedMs) : "",
+		tokens: features.outputTokens && parts.outputTokens !== undefined ? `↓ ${formatTokens(parts.outputTokens)} tokens` : "",
+		tokenRate, responseModel,
+	}, loaderOrder);
+}

package/src/menu.ts

@@ -26,6 +26,10 @@ export interface MenuItem {
 	id: string;
 	label: string;
 	value: MenuValue;
+	/** Render a blank, non-selectable row immediately before this item. */
+	spacerBefore?: boolean;
+	/** IDs for which at least one value must be true before this item can be toggled. */
+	disabledUnlessAnyOf?: readonly string[];
 	/** Values cycled with left/right arrows. Omit for a boolean space-toggle. */
 	cycleValues?: readonly string[];
 	/** Optional display labels for cycle values; the keys remain the published values. */
@@ -215,6 +219,7 @@ export class MenuComponent implements Component {
 			[Key.right]: () => this.cycleCurrentValue(1),
 			[Key.space]: () => {
 				const item = this.flat[this.cursor]!.item;
+				if (this.isDisabled(item)) return;
 				if (item.cycleValues && item.cycleEnabledBy) {
 					this.values[item.cycleEnabledBy] = !this.values[item.cycleEnabledBy] as boolean;
 					if (!this.values[item.cycleEnabledBy] && item.cycleDisabledValue !== undefined) this.values[item.id] = item.cycleDisabledValue;
@@ -286,9 +291,14 @@ export class MenuComponent implements Component {
 		return Math.max(1, rows - 6);
 	}
 
+	private isDisabled(item: MenuItem): boolean {
+		const requiredIds = item.disabledUnlessAnyOf;
+		return requiredIds !== undefined && !requiredIds.some(id => this.values[id] === true);
+	}
+
 	private cycleCurrentValue(delta: number): void {
 		const item = this.flat[this.cursor]!.item;
-		if (!item.cycleValues?.length || (item.cycleEnabledBy && !this.values[item.cycleEnabledBy])) return;
+		if (this.isDisabled(item) || !item.cycleValues?.length || (item.cycleEnabledBy && !this.values[item.cycleEnabledBy])) return;
 		const current = item.cycleValues.indexOf(this.values[item.id] as string);
 		const index = (current + delta + item.cycleValues.length) % item.cycleValues.length;
 		this.values[item.id] = item.cycleValues[index]!;
@@ -338,6 +348,7 @@ export class MenuComponent implements Component {
 				lines.push(this.renderSectionDivider(this.sections[flat.sectionIndex]!.title, innerWidth));
 				currentSection = flat.sectionIndex;
 			}
+			if (flat.item.spacerBefore) lines.push(this.renderBlankRow(innerWidth));
 			lines.push(this.renderItemRow(flat.item, index === this.cursor, innerWidth));
 		}
 		if (lines.length) lines.push(this.renderBlankRow(innerWidth));
@@ -363,6 +374,7 @@ export class MenuComponent implements Component {
 				if (maxRows - lines.length >= 2) lines.push(this.renderSectionDivider(this.sections[flat.sectionIndex]!.title, innerWidth));
 				currentSection = flat.sectionIndex;
 			}
+			if (flat.item.spacerBefore && maxRows - lines.length >= 2) lines.push(this.renderBlankRow(innerWidth));
 			if (lines.length >= maxRows) break;
 			lines.push(this.renderItemRow(flat.item, index === this.cursor, innerWidth));
 			end = index;
@@ -388,18 +400,20 @@ export class MenuComponent implements Component {
 
 		// Walk backward from cursor to find the lowest scrollStart that fits in contentRows.
 		{
-			let rowsUsed = 2; // 1 for cursor item + 1 for first-section divider
+			let rowsUsed = 2 + (this.flat[this.cursor]!.item.spacerBefore ? 1 : 0); // cursor item + first-section divider + optional spacer
 			let section = this.flat[this.cursor]!.sectionIndex;
 			this.scrollStart = this.cursor;
 			for (let i = this.cursor - 1; i >= 0; i--) {
-				const sec = this.flat[i]!.sectionIndex;
+				const previous = this.flat[i]!;
+				const sec = previous.sectionIndex;
+				const itemRows = 1 + (previous.item.spacerBefore ? 1 : 0);
 				if (sec !== section) {
-					if (rowsUsed + 3 > contentRows) break;
-					rowsUsed += 3;
+					if (rowsUsed + itemRows + 2 > contentRows) break;
+					rowsUsed += itemRows + 2;
 					section = sec;
 				} else {
-					if (rowsUsed + 1 > contentRows) break;
-					rowsUsed += 1;
+					if (rowsUsed + itemRows > contentRows) break;
+					rowsUsed += itemRows;
 				}
 				this.scrollStart = i;
 			}
@@ -438,7 +452,8 @@ export class MenuComponent implements Component {
 		const header = [this.renderTopBorder(innerWidth), ...this.buildPreviewBlock(previewLines, innerWidth)];
 		const footer = this.buildFooter(innerWidth);
 		const sectionsWithItems = new Set(this.flat.map(f => f.sectionIndex)).size;
-		const naturalBodyLength = this.flat.length + 2 * sectionsWithItems;
+		const spacerRows = this.flat.filter(flat => flat.item.spacerBefore).length;
+		const naturalBodyLength = this.flat.length + spacerRows + 2 * sectionsWithItems;
 		if (maxRows === undefined || header.length + naturalBodyLength + footer.length <= maxRows) {
 			const naturalBody = this.buildToggleSections(innerWidth);
 			this.pageItemCount = Math.max(1, this.flat.length);
@@ -542,7 +557,7 @@ export class MenuComponent implements Component {
 		}
 
 		if (item.cycleValues) {
-			const enabled = item.cycleEnabledBy ? this.values[item.cycleEnabledBy] as boolean : true;
+			const enabled = !this.isDisabled(item) && (item.cycleEnabledBy ? this.values[item.cycleEnabledBy] as boolean : true);
 			const rawValue = typeof value === "string" ? value : String(value);
 			const displayValue = item.cycleValueLabels?.[rawValue] ?? rawValue;
 			const stateWord = `‹ ${displayValue} ›`;
@@ -554,7 +569,8 @@ export class MenuComponent implements Component {
 			return this.wrap("\u2551", selected ? th.bg("selectedBg", content) : content, "\u2551");
 		}
 
-		const enabled = value as boolean;
+		const disabled = this.isDisabled(item);
+		const enabled = disabled || value as boolean;
 		const box = enabled ? "\u25a0" : " ";
 		const stateWord = enabled ? "ON" : "OFF";
 		const rightPlain = `${stateWord}  `;
@@ -562,7 +578,9 @@ export class MenuComponent implements Component {
 		const label = visibleWidth(item.label) > maxLabelLen ? truncateToWidth(item.label, maxLabelLen) : item.label;
 		const leftPlain = `  ${marker} [${box}] ${label}`;
 		const gap = Math.max(1, innerWidth - visibleWidth(leftPlain) - visibleWidth(rightPlain));
-		const content = `  ${markerColored} [${enabled ? th.fg("success", box) : th.fg("muted", box)}] ${th.fg("text", label)}${" ".repeat(gap)}${enabled ? th.fg("success", stateWord) : th.fg("muted", stateWord)}  `;
+		const labelColor = disabled ? "muted" : "text";
+		const stateColor = disabled ? "muted" : enabled ? "success" : "muted";
+		const content = `  ${markerColored} [${th.fg(stateColor, box)}] ${th.fg(labelColor, label)}${" ".repeat(gap)}${th.fg(stateColor, stateWord)}  `;
 		return this.wrap("\u2551", selected ? th.bg("selectedBg", content) : content, "\u2551");
 	}
 }

package/src/nvidia-green.ts

@@ -1,6 +1,6 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { getThinkingLevelColorizer, type ThinkingLevel } from "./format.ts";
-import type { ThinkingLevelColor, ThinkingLevelSettingColor } from "./settings.ts";
+import type { ThinkingLevelColor } from "./settings.ts";
 
 /** Provider id whose working-loader response model uses NVIDIA green. */
 export const SWITCHYARD_PROVIDER = "switchyard";
@@ -27,7 +27,7 @@ export function colorizeNvidiaGreen(text: string): string {
  */
 export function getResponseModelColorizer(
 	theme: Pick<Theme, "fg" | "getThinkingBorderColor">,
-	color: ThinkingLevelColor | ThinkingLevelSettingColor,
+	color: ThinkingLevelColor,
 	thinkingLevel: ThinkingLevel | undefined,
 	provider: string | undefined,
 ): (text: string) => string {

package/src/preview.ts

@@ -1,11 +1,12 @@
 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 { DEFAULT_WORKING_WORD, dimAttribute, ELAPSED_INTERVAL_MS, formatTokenRate, getThinkingLevelColorizer, METER_INTERVAL_MS, SHIMMER_INTERVAL_MS, SPINNER_FRAME_MS } from "./format.ts";
+import { buildLoaderMessage } from "./loader-message.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";
+import { isWordPackEnabled, selectWorkingTextSelection, WORD_PACK_MENU_PREFIX, wordPacksPath, type WordPack } from "./word-packs.ts";
 // Simulated load for the menu preview: a 2.4s cosine wave peaking at 46 tps for the meter,
 // flat 28 tps for the token readouts.
 const METER_PERIOD_MS = 2400, METER_PEAK_RATE = 46, TOKEN_RATE_PER_SEC = 28;
@@ -31,7 +32,13 @@ export class PreviewRenderer {
 		if (PROMPT_IDS.has(activeItemId ?? "")) return this.promptPreview(values, width);
 		if (MARKER_IDS.has(activeItemId ?? "")) return this.markerPreview(values, width);
 		if (activeItemId === "useNerdFont") return { lines: ["", `Icon preview: ${values.useNerdFont ? "" : "π"}`, ""] };
-		if (activeItemId?.startsWith("pack:")) return this.packPreview(activeItemId.slice("pack:".length), values);
+		if (activeItemId === "showResponseModelFooter") {
+			if (values.showResponseModelFooter !== true) return { lines: ["", "Response model footer is disabled.", ""] };
+			const color = isThinkingLevelColor(values.responseModelColor) ? values.responseModelColor : DEFAULT_SETTINGS.decorations.responseModelColor;
+			const colored = getResponseModelColorizer(this.#ctx.ui.theme, color, this.#ctx.thinkingLevel, this.#ctx.model?.provider)("test-model");
+			return { lines: ["", values.responseModelDimmed === true ? dimAttribute(colored) : colored, ""] };
+		}
+		if (activeItemId?.startsWith(WORD_PACK_MENU_PREFIX)) return this.packPreview(activeItemId.slice(WORD_PACK_MENU_PREFIX.length), values);
 		let nextRefreshInMs: number | undefined;
 		if (values.shimmer !== false) {
 			nextRefreshInMs = SHIMMER_INTERVAL_MS;
@@ -51,88 +58,47 @@ export class PreviewRenderer {
 			this.#lastMeterUpdate = elapsedMs;
 		}
 		const features = { substituteDefaultMessage: values.substituteDefaultMessage !== false, elapsedTime: values.elapsedTime !== false, outputTokens: values.outputTokens !== false, tokenRate: values.showTokenRate !== false, responseModel: values.showResponseModel !== false };
-		const decorations = { shimmer: values.shimmer !== false, shimmerInverted: values.shimmerInverted === true, tokenActivityMonitor: values.tokenActivityMonitor !== false };
-		let spinnerColor = DEFAULT_SETTINGS.decorations.spinnerColor;
-		if (isSpinnerColor(values.spinnerColor)) {
-			spinnerColor = values.spinnerColor;
-		}
-		let spinner = "";
-		if (values.animatedSpinner !== false) {
-			spinner = getThinkingLevelColorizer(this.#ctx.ui.theme, spinnerColor, this.#ctx.thinkingLevel)(SPINNER_FRAMES[Math.floor(elapsedMs / SPINNER_FRAME_MS) % SPINNER_FRAMES.length]!);
-		}
-		const order = parseLoaderOrder(values[LOADER_ORDER_ID]);
-		let responseModelColor = DEFAULT_SETTINGS.decorations.responseModelColor;
-		if (isThinkingLevelColor(values.responseModelColor)) responseModelColor = values.responseModelColor;
-		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)) {
-			return buildWorkingMessage(this.#ctx.ui.theme, { spinner, text: this.#ctx.ui.theme.fg("dim", DEFAULT_WORKING_WORD), responseModel }, order);
-		}
+		const decorations = {
+			shimmer: values.shimmer !== false,
+			shimmerInverted: values.shimmerInverted === true,
+			shimmerDirection: fromCycleDirection(values.shimmerDirection),
+			shimmerSpeed: fromCycleSpeed(values.shimmerSpeed),
+			tokenActivityMonitor: values.tokenActivityMonitor !== false,
+			meterColor: isThinkingLevelColor(values.meterColor) ? values.meterColor : DEFAULT_SETTINGS.decorations.meterColor,
+			meterDimmed: values.meterDimmed === true,
+			tokenRateColor: isThinkingLevelColor(values.tokenRateColor) ? values.tokenRateColor : DEFAULT_SETTINGS.decorations.tokenRateColor,
+			tokenRateDimmed: values.tokenRateDimmed === true,
+			responseModelColor: isThinkingLevelColor(values.responseModelColor) ? values.responseModelColor : DEFAULT_SETTINGS.decorations.responseModelColor,
+			responseModelDimmed: values.responseModelDimmed === true,
+			spinnerColor: isSpinnerColor(values.spinnerColor) ? values.spinnerColor : DEFAULT_SETTINGS.decorations.spinnerColor,
+		};
 		let word = DEFAULT_WORKING_WORD;
 		if (features.substituteDefaultMessage) {
 			const packValues = this.packValues(values);
-			const signature = JSON.stringify(Object.keys(packValues).sort().map(k => `${k}=${packValues[k]}`));
+			const includeDefaultWorkingText = values.includeDefaultWorkingText !== false;
+			const signature = JSON.stringify([packValues, includeDefaultWorkingText]);
 			if (signature !== this.#cachedPackSignature) {
-				this.#cachedPackWord = selectWorkingTextSelection(packValues, this.#packs, this.#poolFraction).text;
+				this.#cachedPackWord = selectWorkingTextSelection(packValues, this.#packs, this.#poolFraction, includeDefaultWorkingText).text;
 				this.#cachedPackSignature = signature;
 			}
 			word = this.#cachedPackWord;
 		}
-		let styledWord: string;
-		if (decorations.shimmer) {
-			styledWord = shimmerString(word, elapsedMs, this.#ctx.ui.theme, fromCycleDirection(values.shimmerDirection), fromCycleSpeed(values.shimmerSpeed), decorations.shimmerInverted);
-		} else {
-			styledWord = this.#ctx.ui.theme.fg("text", word);
-		}
-		let meterColor = DEFAULT_SETTINGS.decorations.meterColor;
-		if (isThinkingLevelColor(values.meterColor)) {
-			meterColor = values.meterColor;
-		}
-		let meter = "";
-		if (decorations.tokenActivityMonitor) {
-			const meterColorizer = getThinkingLevelColorizer(this.#ctx.ui.theme, meterColor, this.#ctx.thinkingLevel);
-			meter = this.#meter.render((level, char) => ActivityMeter.colorizeCell(level, char, this.#ctx.ui.theme, meterColorizer, values.meterDimmed === true));
-		}
-		let tokenRateText = "";
-		if (features.tokenRate) {
-			tokenRateText = formatTokenRate(TOKEN_RATE_PER_SEC);
-		}
-		let tokenRateColor = DEFAULT_SETTINGS.decorations.tokenRateColor;
-		if (isThinkingLevelColor(values.tokenRateColor)) {
-			tokenRateColor = values.tokenRateColor;
-		}
-		let tokenRateColored = "";
-		if (tokenRateText) {
-			const tokenRateColorizer = getThinkingLevelColorizer(this.#ctx.ui.theme, tokenRateColor, this.#ctx.thinkingLevel);
-			tokenRateColored = tokenRateColorizer(tokenRateText);
-		}
-		let tokenRate = tokenRateColored;
-		if (tokenRateColored && values.tokenRateDimmed === true) {
-			tokenRate = dimAttribute(tokenRateColored);
-		}
-		let elapsed = "";
-		if (features.elapsedTime) {
-			elapsed = formatElapsed(elapsedMs);
-		}
-		let tokens = "";
-		if (features.outputTokens) {
-			tokens = `↓ ${formatTokens(Math.max(0, Math.floor(elapsedMs / 1000 * TOKEN_RATE_PER_SEC)))} tokens`;
-		}
-		return buildWorkingMessage(this.#ctx.ui.theme, {
-			spinner,
-			text: styledWord,
-			meter,
-			elapsed,
-			tokens,
-			tokenRate,
-			responseModel,
-		}, order);
+		const theme = this.#ctx.ui.theme;
+		return buildLoaderMessage(theme, this.#ctx.thinkingLevel, this.#ctx.model?.provider, features, decorations, parseLoaderOrder(values[LOADER_ORDER_ID]), {
+			spinnerAtMs: values.animatedSpinner !== false ? elapsedMs : undefined,
+			word,
+			shimmerAtMs: elapsedMs,
+			renderMeter: (colorizer, dimmed) => this.#meter.render((level, char) => ActivityMeter.colorizeCell(level, char, theme, colorizer, dimmed)),
+			elapsedMs,
+			outputTokens: Math.max(0, Math.floor(elapsedMs / 1000 * TOKEN_RATE_PER_SEC)),
+			tokenRateText: formatTokenRate(TOKEN_RATE_PER_SEC),
+			responseModel: features.responseModel ? "test-model" : undefined,
+		});
 	}
 	private packValues(values: Record<string, boolean | string>): Record<string, boolean> {
 		const enabled: Record<string, boolean> = {};
 		for (const pack of this.#packs) {
-			const value = values[`pack:${pack.id}`];
+			const value = values[`${WORD_PACK_MENU_PREFIX}${pack.id}`];
 			if (typeof value === "boolean") enabled[pack.id] = value;
 		}
 		return enabled;

package/src/session.ts

@@ -15,8 +15,6 @@ import type {
 import { Text, type Component } from "@earendil-works/pi-tui";
 import { ActivityMeter, rateToLevel, TokRateTracker } from "./activity-meter.ts";
 import {
-	buildWorkingMessage,
-	DEFAULT_WORKING_WORD,
 	dimAttribute,
 	getThinkingLevelColorizer,
 	isThinkingLevel,
@@ -29,19 +27,22 @@ import {
 	METER_INTERVAL_MS,
 	RESPONSE_MODEL_FADE_MS,
 	RESPONSE_MODEL_HOLD_MS,
+	RESPONSE_MODEL_SLIDE_FRAME_MS,
+	RESPONSE_MODEL_SLIDE_MS,
 	SHIMMER_INTERVAL_MS,
-	shimmerString,
+	slideOutTail,
 	SPINNER_FRAME_MS,
 	SPINNER_FRAMES,
 	TOKEN_RATE_FADE_SHADE_COUNT,
-	TOKEN_RATE_PLACEHOLDER,
 	StreamingWordCounter,
 	type ThinkingLevel,
 } from "./format.ts";
+import { buildLoaderMessage } from "./loader-message.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 { announcesEmbedded, STATUSLINE_EMBED_CHANNEL } from "./statusline-embed.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";
@@ -96,6 +97,9 @@ interface SessionState {
 	responseModelHoldTimer: ReturnType<typeof setTimeout> | null;
 	responseModelFadeTimer: ReturnType<typeof setInterval> | null;
 	responseModelFadeGeneration: number;
+	/** When the response model appeared in the loader and began sliding out; 0 if it never slid. */
+	responseModelShownAt: number;
+	responseModelSlideTimer: ReturnType<typeof setInterval> | null;
 	tokenRateText: string;
 	tokenRateFadeStartsAt: number;
 	timer: ReturnType<typeof setInterval> | null;
@@ -134,6 +138,8 @@ function makeFreshState(): SessionState {
 		responseModelHoldTimer: null,
 		responseModelFadeTimer: null,
 		responseModelFadeGeneration: 0,
+		responseModelShownAt: 0,
+		responseModelSlideTimer: null,
 		tokenRateText: "",
 		tokenRateFadeStartsAt: 0,
 		timer: null,
@@ -162,6 +168,8 @@ export class SessionManager {
 	#bundledPacks = loadBundledWordPacks();
 	#allPacks: WordPack[] = [...this.#bundledPacks];
 	#currentCtx: ExtensionContext | null = null;
+	/** Whether pi-topping-statusline last announced that its status bar hosts the loader; kept across sessions. */
+	#loaderInStatusline = false;
 	readonly #pi: ExtensionAPI;
 
 	constructor(pi: ExtensionAPI) {
@@ -171,6 +179,7 @@ export class SessionManager {
 	#onSessionStart = async (_e: SessionStartEvent, ctx: ExtensionContext): Promise<void> => {
 		this.#currentCtx = ctx;
 		this.stopTimer();
+		this.stopResponseModelSlide();
 		this.cancelResponseModelFade(ctx);
 		this.#counter.reset();
 		this.#state = makeFreshState();
@@ -308,7 +317,7 @@ export class SessionManager {
 
 		const hadPrompt = !!this.#state.startTime;
 		const elapsedMs = hadPrompt ? Date.now() - this.#state.startTime : 0;
-		const responseModel = this.#settings.features.responseModel ? this.#state.responseModel : "";
+		const responseModel = this.#settings.features.responseModelFooter ? this.#state.responseModel : "";
 		const responseModelColor = this.#settings.decorations.responseModelColor;
 		const responseModelDimmed = this.#settings.decorations.responseModelDimmed;
 		this.#state.busy = false;
@@ -316,6 +325,7 @@ export class SessionManager {
 		this.#state.startTime = 0;
 		this.#counter.reset();
 		this.stopTimer();
+		this.stopResponseModelSlide();
 		this.applyIndicator(ctx);
 		ctx.ui.setWorkingMessage();
 		if (responseModel) this.startResponseModelFade(ctx, responseModel, responseModelColor, responseModelDimmed);
@@ -339,6 +349,7 @@ export class SessionManager {
 		this.#state.waiting = null;
 		this.cancelResponseModelFade(ctx);
 		this.stopTimer();
+		this.stopResponseModelSlide();
 	};
 
 	#renderDoneEntry(entry: CustomEntry<DoneEntryData>, theme: Theme): Component | undefined {
@@ -393,6 +404,9 @@ export class SessionManager {
 		this.#pi.on("ui_prompt_start", this.#onUIPromptStart);
 		this.#pi.on("ui_prompt_end", this.#onUIPromptEnd);
 		this.#pi.on("session_shutdown", this.#onSessionShutdown);
+		this.#pi.events.on(STATUSLINE_EMBED_CHANNEL, (data) => {
+			this.#loaderInStatusline = announcesEmbedded(data);
+		});
 		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);
@@ -469,16 +483,47 @@ export class SessionManager {
 		if (responseModel && modelsResemble(selectedModel, responseModel)) {
 			if (this.#state.responseModel) {
 				this.#state.responseModel = "";
+				this.stopResponseModelSlide();
 				this.tick();
 			}
 			return;
 		}
 		if (responseModel && responseModel !== this.#state.responseModel) {
+			// A model replacing one already shown swaps in place; only an appearing one slides out.
+			if (!this.#state.responseModel) this.startResponseModelSlide();
 			this.#state.responseModel = responseModel;
 			this.tick();
 		}
 	}
 
+	/**
+	 * Slide a newly shown response model out of the loader while pi-topping-statusline
+	 * embeds it, matching that status bar's own slides; anywhere else it shows at once.
+	 * The loader's own timer runs at 50ms or slower, so the slide repaints on its own
+	 * faster timer until it is done.
+	 */
+	private startResponseModelSlide(): void {
+		this.stopResponseModelSlide();
+		const state = this.#state;
+		if (!this.#settings.features.responseModel || !this.#loaderInStatusline) {
+			state.responseModelShownAt = 0;
+			return;
+		}
+		state.responseModelShownAt = Date.now();
+		state.responseModelSlideTimer = setInterval(() => {
+			this.tick();
+			if (Date.now() - state.responseModelShownAt >= RESPONSE_MODEL_SLIDE_MS) this.stopResponseModelSlide();
+		}, RESPONSE_MODEL_SLIDE_FRAME_MS);
+	}
+
+	private stopResponseModelSlide(): void {
+		const state = this.#state;
+		if (state.responseModelSlideTimer) {
+			clearInterval(state.responseModelSlideTimer);
+			state.responseModelSlideTimer = null;
+		}
+	}
+
 	private cancelResponseModelFade(ctx?: ExtensionContext | null): void {
 		const state = this.#state;
 		state.responseModelFadeGeneration++;
@@ -543,11 +588,12 @@ export class SessionManager {
 	}
 
 	private pickWorkingWord(): WorkingTextSelection {
-		return pickWorkingTextSelection(this.#settings.wordPacks, this.#allPacks);
+		return pickWorkingTextSelection(this.#settings.wordPacks, this.#allPacks, this.#settings.features.includeDefaultWorkingText);
 	}
 
 	private resetTurn(now: number): void {
 		this.cancelResponseModelFade();
+		this.stopResponseModelSlide();
 		const state = this.#state;
 		state.startTime = now;
 		state.shimmerOrigin = now;
@@ -589,36 +635,9 @@ export class SessionManager {
 			if (decorations.tokenActivityMonitor) state.activityMeter.push(rateToLevel(tokenRate));
 			state.lastTokenRateSampledAt = now;
 		}
-		const spinner = this.spinnerInMessage()
-			? 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
-			? getResponseModelColorizer(ctx.ui.theme, decorations.responseModelColor, ctx.thinkingLevel, ctx.model?.provider)(state.responseModel)
+		const responseModelShown = features.responseModel && state.responseModel
+			? slideOutTail(state.responseModel, now - state.responseModelShownAt)
 			: "";
-		const responseModel = responseModelColored && decorations.responseModelDimmed ? dimAttribute(responseModelColored) : responseModelColored;
-		if (isFullyDefaultAppearance(features, decorations)) {
-			const msg = spinner || responseModel
-				? buildWorkingMessage(ctx.ui.theme, { spinner, text: ctx.ui.theme.fg("dim", DEFAULT_WORKING_WORD), responseModel }, this.#settings.loaderOrder)
-				: undefined;
-			if (msg !== state.lastMessage) {
-				state.lastMessage = msg;
-				ctx.ui.setWorkingMessage(msg);
-			}
-			return;
-		}
-
-		const word = features.substituteDefaultMessage ? state.workingText.text : DEFAULT_WORKING_WORD;
-		const styled = decorations.shimmer
-			? shimmerString(word, now - state.shimmerOrigin, ctx.ui.theme, decorations.shimmerDirection, decorations.shimmerSpeed, decorations.shimmerInverted)
-			: ctx.ui.theme.fg("text", word);
-		let meter = "";
-		if (decorations.tokenActivityMonitor) {
-			const meterColorizer = getThinkingLevelColorizer(ctx.ui.theme, decorations.meterColor, ctx.thinkingLevel);
-			meter = state.activityMeter.render((level, char) =>
-				ActivityMeter.colorizeCell(level, char, ctx.ui.theme, meterColorizer, decorations.meterDimmed),
-			);
-		}
-		let tokenRateText = "";
 		if (features.tokenRate) {
 			const latestTokenRate = formatTokenRate(state.rateTracker.tokenRate);
 			if (latestTokenRate && hasNewTokenCount) {
@@ -627,38 +646,33 @@ export class SessionManager {
 			} else if (now >= state.tokenRateFadeStartsAt + TOKEN_RATE_FADE_MS) {
 				state.tokenRateText = "";
 			}
-			tokenRateText = state.tokenRateText;
-		}
-		let tokenRateSegment = "";
-		if (features.tokenRate) {
-			if (!tokenRateText) {
-				tokenRateSegment = ctx.ui.theme.fg("dim", TOKEN_RATE_PLACEHOLDER);
-			} else {
-				const tokenRateColorizer = getThinkingLevelColorizer(ctx.ui.theme, decorations.tokenRateColor, ctx.thinkingLevel);
-				tokenRateSegment = now < state.tokenRateFadeStartsAt
-					? tokenRateColorizer(tokenRateText)
-					: fadeThemeColorString(
-						tokenRateText,
-						Math.floor((now - state.tokenRateFadeStartsAt) / (TOKEN_RATE_FADE_MS / TOKEN_RATE_FADE_SHADE_COUNT)),
-						ctx.ui.theme,
-						tokenRateColorizer,
-					);
-			}
 		}
-		const tokenRateStyled = tokenRateSegment && decorations.tokenRateDimmed ? dimAttribute(tokenRateSegment) : tokenRateSegment;
-		const msg = buildWorkingMessage(
-			ctx.ui.theme,
-			{
-				spinner,
-				text: styled,
-				meter,
-				elapsed: features.elapsedTime ? formatElapsed(now - state.startTime) : "",
-				tokens: features.outputTokens ? `↓ ${formatTokens(total)} tokens` : "",
-				tokenRate: tokenRateStyled,
-				responseModel,
-			},
-			this.#settings.loaderOrder,
-		);
+		const showSpinner = this.spinnerInMessage();
+		const msg = isFullyDefaultAppearance(features, decorations) && !showSpinner && !responseModelShown
+			? undefined
+			: buildLoaderMessage(
+				ctx.ui.theme,
+				ctx.thinkingLevel,
+				ctx.model?.provider,
+				features,
+				decorations,
+				this.#settings.loaderOrder,
+				{
+					spinnerAtMs: showSpinner ? now : undefined,
+					word: state.workingText.text,
+					shimmerAtMs: now - state.shimmerOrigin,
+					renderMeter: (colorizer, dimmed) => state.activityMeter.render((level, char) =>
+						ActivityMeter.colorizeCell(level, char, ctx.ui.theme, colorizer, dimmed),
+					),
+					elapsedMs: now - state.startTime,
+					outputTokens: total,
+					tokenRateText: state.tokenRateText,
+					tokenRateShade: now < state.tokenRateFadeStartsAt
+						? undefined
+						: Math.floor((now - state.tokenRateFadeStartsAt) / (TOKEN_RATE_FADE_MS / TOKEN_RATE_FADE_SHADE_COUNT)),
+					responseModel: responseModelShown,
+				},
+			);
 		if (msg !== state.lastMessage) {
 			state.lastMessage = msg;
 			ctx.ui.setWorkingMessage(msg);

package/src/settings.ts

@@ -3,7 +3,7 @@ import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "
 import { dirname, join } from "node:path";
 import { DEFAULT_LOADER_ORDER, type LoaderElement } from "./format.ts";
 import type { MenuSection } from "./menu.ts";
-import { isWordPackEnabled, isWordPackId, type WordPack } from "./word-packs.ts";
+import { isWordPackEnabled, isWordPackId, WORD_PACK_MENU_PREFIX, type WordPack } from "./word-packs.ts";
 import { isPlainObject } from "./util.ts";
 
 export const SETTING_COLOR_VALUES = ["accent", "border", "borderAccent", "success", "error", "warning"] as const;
@@ -20,7 +20,8 @@ export const DONE_MARKER_BORDER_COLOR_VALUES = THINKING_LEVEL_SETTING_COLOR_VALU
 export type DoneMarkerBorderColor = ThinkingLevelSettingColor;
 const THINKING_LEVEL_COLOR_MIGRATION_VERSION = 2;
 const DONE_MARKER_BORDER_COLOR_MIGRATION_VERSION = 3;
-export const SETTINGS_SCHEMA_VERSION = 3;
+const RESPONSE_MODEL_FOOTER_MIGRATION_VERSION = 4;
+export const SETTINGS_SCHEMA_VERSION = 4;
 
 export const BORDER_STYLE_VALUES = ["double", "single", "rounded", "heavy"] as const;
 export type BorderStyle = (typeof BORDER_STYLE_VALUES)[number];
@@ -96,12 +97,14 @@ export interface DecoratorSettings {
 		outputTokens: boolean;
 		tokenRate: boolean;
 		responseModel: boolean;
+		responseModelFooter: boolean;
 		doneMarker: boolean;
 		doneMarkerIcon: boolean;
 		randomizeDoneMarker: boolean;
 		doneMarkerTokens: boolean;
 		doneMarkerInputs: boolean;
 		doneMarkerModel: boolean;
+		includeDefaultWorkingText: boolean;
 	};
 	loaderOrder: LoaderElement[];
 	wordPacks: Record<string, boolean>;
@@ -109,7 +112,7 @@ export interface DecoratorSettings {
 
 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", 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 },
+	features: { substituteDefaultMessage: true, elapsedTime: true, outputTokens: true, tokenRate: true, responseModel: true, responseModelFooter: false, doneMarker: true, doneMarkerIcon: true, randomizeDoneMarker: true, doneMarkerTokens: true, doneMarkerInputs: true, doneMarkerModel: true, includeDefaultWorkingText: true },
 	loaderOrder: [...DEFAULT_LOADER_ORDER],
 	wordPacks: {},
 };
@@ -148,20 +151,7 @@ function mergeGroup<T extends Record<string, boolean | string>>(defaults: T, par
 	if (!isPlainObject(parsed)) return merged;
 	for (const [key, value] of Object.entries(parsed)) {
 		if (!Object.hasOwn(merged, key)) continue;
-		let valid: boolean | string | undefined;
-		if (typeof merged[key] === "boolean" && typeof value === "boolean") valid = value;
-		else if ((key === "meterDirection" || key === "shimmerDirection") && (value === "ltr" || value === "rtl")) valid = value;
-		else if (key === "shimmerSpeed" && (value === "slow" || value === "normal" || value === "fast")) valid = value;
-		else if (key === "spinnerColor" && value === "default") valid = "thinking-level";
-		else if (key === "spinnerColor" && isSpinnerColor(value)) valid = value;
-		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" || 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;
-		if (valid !== undefined) (merged as Record<string, boolean | string>)[key] = valid;
+		if (typeof merged[key] === "boolean" && typeof value === "boolean") (merged as Record<string, boolean | string>)[key] = value;
 	}
 	return merged;
 }
@@ -176,7 +166,7 @@ export function fromCycleSpeed(value: unknown): "slow" | "normal" | "fast" {
 	return value === "slow" || value === "fast" ? value : "normal";
 }
 
-type MenuSectionName = "User Prompt" | "“Working” Loader" | "Completion Marker" | "Options";
+type MenuSectionName = "User Prompt" | "“Working” Loader" | "Completion Marker" | "Word Packs" | "Options";
 type DecorationSettings = DecoratorSettings["decorations"];
 type FeatureSettings = DecoratorSettings["features"];
 type DecorationBooleanKey = { [Key in keyof DecorationSettings]: DecorationSettings[Key] extends boolean ? Key : never }[keyof DecorationSettings];
@@ -228,6 +218,8 @@ export const MENU_ENTRIES: readonly MenuEntry[] = [
 	{ 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" },
+	{ id: "showResponseModelFooter", label: "Response model footer", section: "Options", group: "features", key: "responseModelFooter" },
+	{ id: "includeDefaultWorkingText", label: "Include default/random “Working” text", section: "Word Packs", group: "features", key: "includeDefaultWorkingText" },
 ];
 
 function menuItem(entry: MenuEntry, settings: DecoratorSettings): MenuSection["items"][number] {
@@ -245,10 +237,9 @@ function isDecorationBooleanKey(key: keyof DecorationSettings): key is Decoratio
 function setDecorationCycleValue(decorations: DecorationSettings, key: keyof DecorationSettings, value: string): void {
 	switch (key) {
 		case "borderColor":
-			if (isPromptBorderColor(value)) decorations[key] = value;
-			return;
 		case "spinnerColor":
-			if (isSpinnerColor(value)) decorations[key] = value;
+		case "doneMarkerBorderColor":
+			if (isThinkingLevelSettingColor(value)) decorations[key] = value;
 			return;
 		case "meterColor":
 		case "tokenRateColor":
@@ -256,9 +247,6 @@ function setDecorationCycleValue(decorations: DecorationSettings, key: keyof Dec
 		case "doneMarkerModelColor":
 			if (isThinkingLevelColor(value)) decorations[key] = value;
 			return;
-		case "doneMarkerBorderColor":
-			if (isDoneMarkerBorderColor(value)) decorations[key] = value;
-			return;
 		case "borderStyle":
 			if (isBorderStyle(value)) decorations[key] = value;
 			return;
@@ -287,12 +275,20 @@ function buildSection(title: MenuSectionName, settings: DecoratorSettings): Menu
 
 export function buildMenuSections(settings: DecoratorSettings, bundledPacks: readonly WordPack[], userPacks: readonly WordPack[] = []): MenuSection[] {
 	const packs = [...bundledPacks, ...userPacks];
+	const packItems = packs.map((pack) => ({ id: `${WORD_PACK_MENU_PREFIX}${pack.id}`, label: pack.name, value: isWordPackEnabled(pack.id, settings.wordPacks) }));
+	const packIds = packItems.map(item => item.id);
 	return [
 		buildSection("User Prompt", settings),
 		buildSection("“Working” Loader", settings),
 		{ title: "Elements Order", items: parseLoaderOrder(settings.loaderOrder).map(id => ({ id, label: LOADER_ELEMENT_LABELS[id], value: false, reorderGroup: LOADER_ORDER_ID })) },
 		buildSection("Completion Marker", settings),
-		{ title: "Word Packs", items: packs.map((pack) => ({ id: `pack:${pack.id}`, label: pack.name, value: isWordPackEnabled(pack.id, settings.wordPacks) })) },
+		{
+			title: "Word Packs",
+			items: [
+				...packItems,
+				...buildSection("Word Packs", settings).items.map((item, index) => ({ ...item, spacerBefore: index === 0, disabledUnlessAnyOf: packIds })),
+			],
+		},
 		buildSection("Options", settings),
 	];
 }
@@ -312,8 +308,8 @@ export function applyMenuResult(settings: DecoratorSettings, values: Record<stri
 		}
 	}
 	for (const [id, value] of Object.entries(values)) {
-		if (!id.startsWith("pack:") || typeof value !== "boolean") continue;
-		const packId = id.slice("pack:".length);
+		if (!id.startsWith(WORD_PACK_MENU_PREFIX) || typeof value !== "boolean") continue;
+		const packId = id.slice(WORD_PACK_MENU_PREFIX.length);
 		if (isWordPackId(packId)) next.wordPacks[packId] = value;
 	}
 	if (typeof values[LOADER_ORDER_ID] === "string") next.loaderOrder = parseLoaderOrder(values[LOADER_ORDER_ID]);
@@ -327,7 +323,8 @@ export function applyMenuResult(settings: DecoratorSettings, values: Record<stri
  * 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
+ * border color is reset. Below 4, the response-model footer inherits the response-model
+ * setting. A legacy `features.simCityWorkingText: true` enables the
  * `simcity` pack when no explicit preference is stored.
  */
 export function loadSettings(): DecoratorSettings {
@@ -344,6 +341,15 @@ export function loadSettings(): DecoratorSettings {
 			wordPacks.simcity = true;
 		}
 		const settings = { decorations: mergeGroup(DEFAULT_SETTINGS.decorations, parsed.decorations), features: mergeGroup(DEFAULT_SETTINGS.features, parsed.features), loaderOrder: parseLoaderOrder(parsed.loaderOrder), wordPacks };
+		if (isPlainObject(parsed.decorations)) {
+			for (const [key, value] of Object.entries(parsed.decorations)) {
+				if (!Object.hasOwn(DEFAULT_SETTINGS.decorations, key) || typeof value !== "string") continue;
+				const k = key as keyof DecorationSettings;
+				if (isDecorationBooleanKey(k)) continue;
+				setDecorationCycleValue(settings.decorations, k,
+					value === "default" && (k === "spinnerColor" || k === "doneMarkerBorderColor") ? "thinking-level" : value);
+			}
+		}
 		const schemaVersion = typeof parsed.schemaVersion === "number" ? parsed.schemaVersion : 1;
 		if (schemaVersion < THINKING_LEVEL_COLOR_MIGRATION_VERSION) {
 			settings.decorations.spinnerColor = "thinking-level";
@@ -352,6 +358,9 @@ export function loadSettings(): DecoratorSettings {
 		if (schemaVersion < DONE_MARKER_BORDER_COLOR_MIGRATION_VERSION) {
 			settings.decorations.doneMarkerBorderColor = "thinking-level";
 		}
+		if (schemaVersion < RESPONSE_MODEL_FOOTER_MIGRATION_VERSION) {
+			settings.features.responseModelFooter = settings.features.responseModel;
+		}
 		for (const entry of MENU_ENTRIES) {
 			if (entry.group === "decorations" && entry.cycleEnabledBy && entry.cycleDisabledValue !== undefined && !settings.decorations[entry.cycleEnabledBy]) {
 				setDecorationCycleValue(settings.decorations, entry.key, entry.cycleDisabledValue);

package/src/statusline-embed.ts

@@ -0,0 +1,12 @@
+import { isPlainObject } from "./util.ts";
+
+/**
+ * Event-bus channel on which pi-topping-statusline announces, as `{ embedded: boolean }`,
+ * whether its status bar hosts Pi's working loader. Shared with pi-topping-statusline.
+ */
+export const STATUSLINE_EMBED_CHANNEL = "pi-topping-statusline:working-status-embedded";
+
+/** Whether an announcement on STATUSLINE_EMBED_CHANNEL says the status bar hosts the loader. */
+export function announcesEmbedded(data: unknown): boolean {
+	return isPlainObject(data) && data.embedded === true;
+}

package/src/word-packs.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { isPlainObject, stripControlChars } from "./util.ts";
 import { WORDS, type WordEntry } from "./words.ts";
 
+export const WORD_PACK_MENU_PREFIX = "pack:";
 const PACK_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
 const RESERVED_BUNDLED_PACK_IDS = new Set(["doctor-who", "firefly", "hitchhikers-guide", "lord-of-the-rings", "matrix", "portal", "simcity", "star-trek", "star-wars"]);
 
@@ -107,14 +108,22 @@ export function isWordPackEnabled(id: string, enabled: Record<string, boolean>):
 	return enabled[id] === true;
 }
 
-export function selectWorkingTextSelection(enabled: Record<string, boolean>, packs: readonly WordPack[], fraction: number): WorkingTextSelection {
-	const enabledWords = packs.filter((pack) => isWordPackEnabled(pack.id, enabled)).flatMap((pack) => pack.words);
-	const total = WORDS.length + enabledWords.length;
-	const idx = Math.min(total - 1, Math.floor(fraction * total));
-	const entry = idx < WORDS.length ? WORDS[idx] : enabledWords[idx - WORDS.length];
-	return { text: entry.present_tense, pastTense: entry.past_tense };
+export function selectWorkingTextSelection(enabled: Record<string, boolean>, packs: readonly WordPack[], fraction: number, includeDefaultWorkingText: boolean): WorkingTextSelection {
+	const enabledPacks = packs.filter((pack) => isWordPackEnabled(pack.id, enabled));
+	const packWordCount = enabledPacks.reduce((sum, pack) => sum + pack.words.length, 0);
+	const baseWords: readonly WordEntry[] = includeDefaultWorkingText || packWordCount === 0 ? WORDS : [];
+	const total = baseWords.length + packWordCount;
+	let idx = Math.min(total - 1, Math.floor(fraction * total));
+	let entry: WordEntry | undefined = baseWords[idx];
+	idx -= baseWords.length;
+	for (const pack of enabledPacks) {
+		if (entry) break;
+		entry = pack.words[idx];
+		idx -= pack.words.length;
+	}
+	return { text: entry!.present_tense, pastTense: entry!.past_tense };
 }
 
-export function pickWorkingTextSelection(enabled: Record<string, boolean>, packs: readonly WordPack[]): WorkingTextSelection {
-	return selectWorkingTextSelection(enabled, packs, Math.random());
+export function pickWorkingTextSelection(enabled: Record<string, boolean>, packs: readonly WordPack[], includeDefaultWorkingText: boolean): WorkingTextSelection {
+	return selectWorkingTextSelection(enabled, packs, Math.random(), includeDefaultWorkingText);
 }