@underactive/pi-topping 0.9.1 → 0.11.0

package/README.md

@@ -6,14 +6,16 @@ We garnish our pies. It seemed rude not to extend Pi the same courtesy. This is
 
 ![Example of pi-topping's decorated user prompt](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo_user_prompt.png)
 
-**“Working” Loader** — animated spinner (with color choice), randomized activity word, optional word packs, shimmer, token activity monitor with an adjustable full-scale rate, elapsed timer, output token display, live output-token rate, and the response model when it meaningfully differs from the selected model — all arrangeable left to right. During a blocking extension prompt, the loader switches to a stable dim waiting line with a pulsing indicator, then resumes afterward.
+**“Working” Loader** — animated spinner (with color choice), randomized activity word, optional word packs, shimmer, token activity monitor with an adjustable full-scale rate, elapsed timer, output token display, live output-token rate, and the response model when it meaningfully differs from the selected model — all arrangeable left to right. For raw Responses-API stream events, it can also include Ramp Router's gateway backend as `<model> via <backend>`, or just `via <backend>` when the served model restates the selection (requires Pi ≥0.99.0). Under a Pi virtual model such as pi-topping-autorouter's `litellm-auto/auto`, the response model is the routed physical model. During a blocking extension prompt, the loader switches to a stable dim waiting line with a pulsing indicator, then resumes afterward.
 
 ![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. 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.
+**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. It can also append per-call service-tier counts (e.g. `flex tier ×3`), but only for calls whose provider reports a tier; this requires Pi ≥0.99.0. 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. On Pi ≥1.1.0, a cancelled run (for example, one stopped with Escape) shows `Interrupted` instead of the random verb, with the word and any border in the warning color; time, tokens, and other enabled details still appear. **Show completion marker** also controls this marker. Older Pi versions show the normal marker for cancelled runs.
 
 ![Example of pi-topping's completion marker](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo_completion_marker.png)
 
+**Output Styles** — choose prompt-instruction styles such as Explanatory or Simplified Technical English to guide how the model responds. Styles are instructions, not output formatters.
+
 ## Install
 
 ```bash
@@ -86,6 +88,7 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ║    [■] Randomize “Worked” text                        ON      ║
 ║    [■] Tokens spent                                   ON      ║
 ║    [■] Mid-turn inputs                                ON      ║
+║    [■] Service tier                                   ON      ║
 ║    [■] Response model                                 ON      ║
 ║    [■] Response model color                      ‹ muted ›    ║
 ║    [■] Response model dimmed                         OFF      ║
@@ -103,15 +106,30 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ║                                                               ║
 ║    [■] Include default/random “Working” text          ON      ║
 ║                                                               ║
+╟─ Output Style ────────────────────────────────────────────────╢
+║    [■] Style                                   ‹ Default ›    ║
+║                                                               ║
 ╟─ Options ─────────────────────────────────────────────────────╢
 ║    [■] Use NerdFont icons                             ON      ║
 ║    [ ] Response model footer                         OFF      ║
 ╟───────────────────────────────────────────────────────────────╢
 ║  ↑↓ move  PgUp/PgDn page  ←→ select                           ║
 ║  ␣ toggle  ⏎ apply  esc cancel                                ║
-╚═══════════════════════════════════════════════════════[ 9/57 ]╝
+╚═══════════════════════════════════════════════════════[ 9/59 ]╝
 ```
 
+### Output styles
+
+Choose an output style with `←`/`→` in the Output Style section of `/topping-settings`. The selected style changes the model's prompt instructions from your next message.
+- **Explanatory** requests brief Insight blocks before and after coding. This is a prompt instruction, not a formatter, so a turn may have no Insight.
+- **Simplified Technical English** instructs the model to write all English prose (not code or quoted text) using ASD-STE100 Simplified Technical English (controlled language rules, active voice, simple tenses, short sentences, and small noun clusters).
+
+While a non-default style is active, each prompt also carries a one-line hidden reminder of the style; the model receives it, but the transcript does not show it.
+
+Output styles also apply in print and RPC modes. Set `"outputStyle": "explanatory"` (or `"simplified"`) in `~/.pi/agent/pi-topping/settings.json`; if you edit the file while an interactive session is running, use `/reload` to load the change. Switching styles changes one system-prompt section. Pi appends that change to the conversation, so providers that support mid-conversation prompt updates keep their cached prefix; other providers may re-read the full prompt once.
+
+The Explanatory prompt is copied word for word from Claude Code's output styles, with two Pi clarifications: a lead-in that frames the instructions for Pi, and an exception allowing Insight blocks despite Pi's conciseness rule. The Simplified Technical English prompt adapts the ASD-STE100 writing rules but does not include the STE dictionary of approved words. A more specific instruction from you, your project instructions, a skill, or the file being edited takes precedence over it. When migrating from `pi-topping-insights`, its saved style is imported until you next save `/topping-settings`. Remove the old extension to avoid duplicate hidden reminders. `/insights` is gone; use `/topping-settings`.
+
 ### Word packs
 
 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`.
@@ -131,6 +149,8 @@ Bundled packs live in [`wordpacks/`](wordpacks/). Copy `wordpacks/doctor-who.jso
 
 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.
 
+### Colors and loader details
+
 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
@@ -147,11 +167,13 @@ restarts the cycle.
 
 The token activity monitor reaches full `⣿` at or above its configurable upper bound (80 tps by default), with lower levels scaled proportionally to that bound. In `/topping-settings`, `←`/`→` cycle through presets spanning 10–1000 tps, and `␣` (Space) lets you enter any whole number from 10–1000. Invalid typed entries show an inline error and keep the editor open without changing the current value; invalid hand-edited `meterUpperBoundTps` values in `settings.json` revert to 80 on load.
 
-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.
+The response model is captured from assistant responses and raw Responses-API stream events (Pi ≥0.99.0), 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. When Ramp Router reports a gateway backend in the raw event, the label can include it as `<model> via <backend>`, or `via <backend>` alone when the served model restates the selection. Under a Pi virtual model such as pi-topping-autorouter's `litellm-auto/auto`, it is the routed physical model: taken from the router's `pi-topping-autorouter:routed-model` announcement when present, which arrives before the first token (announcements for `direct` routes such as compaction are ignored), and otherwise from the assistant message's model. There only a failed route, which reports the virtual model itself, is hidden, and a bare routed id never displaces a provider-reported decorated form of itself such as a dated name. 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
 
 - [Pi](https://github.com/earendil-works/pi-coding-agent). Pi ≥0.84.4 is required for the waiting-for-input loader state; older Pi versions keep the animated loader.
+- Output styles need a Pi version that exposes structured system-prompt sections (tested on Pi 1.0.3 and 1.1.0); on older hosts the style setting has no effect.
+- Pi ≥1.1.0 shows `Interrupted` for cancelled runs; older versions show the normal completion marker.
 - On Pi ≥0.85.0, the working indicator is embedded in the default editor border and long loaders are truncated to the border width instead of wrapping; custom editors that do not opt in keep the standalone wrapping indicator.
 - Node.js ≥22.19.0
 
@@ -163,13 +185,15 @@ npm test
 npm run typecheck
 ```
 
-Tests cover the word/shimmer rendering, prompt box and completion marker rendering, activity meter behavior and its configurable upper bound, 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 and its typed number entry, the settings menu wiring end to end, and the `/topping-setup` command's install and uninstall flows.
+Tests cover the word/shimmer rendering, prompt box and completion marker rendering, activity meter behavior and its configurable upper bound, timer resets, settings persistence and schema migrations, word-pack parsing, loading, and default-text selection, output-style selection and prompt integration, response-model loader and footer behavior, served-model and service-tier extraction, the `menu.ts` component and its typed number entry, the settings menu wiring end to end, and the `/topping-setup` command's install and uninstall flows.
 
 ## Limitations
 
 - Token counts are a streaming word-count estimate, not an exact tokenizer count — they self-correct when each message finishes, so you'll see a small jump at that point.
 - Elapsed time normally starts when you submit a prompt; for auto-continuations without that event, it starts slightly later instead.
 - If another extension also customizes the working message, whichever one runs last wins.
+- Service-tier details and Responses-API served-model/backend labels depend on Pi's `provider_stream_event`; raw events require Pi ≥0.99.0 and are unavailable on older Pi hosts and SDK adapters that do not expose them.
+- Output styles have no effect on hosts without structured system-prompt sections (see Requirements).
 
 ## Author
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@underactive/pi-topping",
-  "version": "0.9.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",
+  "version": "0.11.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, an end-of-turn completion marker, and selectable output styles",
   "keywords": ["pi-package", "pi-extension"],
   "license": "MIT",
   "author": "Eric Sison",
@@ -30,8 +30,8 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.0.0",
-    "@earendil-works/pi-tui": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.0",
     "@types/node": "^24.0.0",
     "typescript": "^5.9.3"
   },

package/src/autorouter-feed.ts

@@ -0,0 +1,49 @@
+import { isPlainObject, sanitizedText } from "./util.ts";
+
+/**
+ * Event-bus channel on which pi-topping-autorouter announces the physical model it routed
+ * a request to, before Pi sends that request (so before `message_start`). Payload:
+ *
+ * ```json
+ * {
+ *   "version": 1,
+ *   "provider": "openai-codex",
+ *   "modelId": "gpt-5.6-sol",
+ *   "model": "openai-codex/gpt-5.6-sol",
+ *   "name": "GPT-5.6 Sol",
+ *   "thinkingLevel": "high",
+ *   "reason": "user",
+ *   "cause": "jev_classifier",
+ *   "tier": "COMPLEX",
+ *   "ts": 1790000000000
+ * }
+ * ```
+ *
+ * `reason` is Pi's route reason: `user`, `continuation`, `retry`, or `direct`. `direct` routes
+ * serve compaction summaries and other extensions' side requests, not the chat response.
+ * `tier` may be absent. Shared with pi-topping-autorouter.
+ */
+export const ROUTED_MODEL_CHANNEL = "pi-topping-autorouter:routed-model";
+
+const ROUTE_REASONS = ["user", "continuation", "retry", "direct"] as const;
+export type RouteReason = (typeof ROUTE_REASONS)[number];
+
+export interface RoutedModelAnnouncement {
+	provider: string;
+	modelId: string;
+	reason: RouteReason;
+}
+
+function isRouteReason(value: string): value is RouteReason {
+	return ROUTE_REASONS.some((reason) => reason === value);
+}
+
+/** The sanitized provider, model id, and route reason of a ROUTED_MODEL_CHANNEL announcement, or undefined if malformed. */
+export function routedModelAnnouncement(data: unknown): RoutedModelAnnouncement | undefined {
+	if (!isPlainObject(data) || data.version !== 1) return undefined;
+	const provider = sanitizedText(data.provider);
+	const modelId = sanitizedText(data.modelId);
+	const reason = sanitizedText(data.reason);
+	if (!provider || !modelId || !isRouteReason(reason)) return undefined;
+	return { provider, modelId, reason };
+}

package/src/loader-message.ts

@@ -3,7 +3,7 @@ import { buildWorkingMessage, DEFAULT_WORKING_WORD, dimAttribute, fadeThemeColor
 import { getResponseModelColorizer } from "./nvidia-green.ts";
 import type { DecoratorSettings } from "./settings.ts";
 
-type Features = Pick<DecoratorSettings["features"], "substituteDefaultMessage" | "elapsedTime" | "outputTokens" | "tokenRate" | "responseModel">;
+type Features = Pick<DecoratorSettings["features"], "substituteDefaultMessage" | "elapsedTime" | "outputTokens" | "tokenRate">;
 type Decorations = Pick<DecoratorSettings["decorations"], "shimmer" | "shimmerInverted" | "shimmerDirection" | "shimmerSpeed" | "tokenActivityMonitor" | "meterColor" | "meterDimmed" | "tokenRateColor" | "tokenRateDimmed" | "responseModelColor" | "responseModelDimmed" | "spinnerColor">;
 interface LoaderParts {
 	spinnerAtMs?: number;

package/src/output-style.ts

@@ -0,0 +1,172 @@
+import type { BeforeAgentStartEventResult } from "@earendil-works/pi-coding-agent";
+
+export const OUTPUT_STYLE_IDS = ["default", "explanatory", "simplified"] as const;
+export type OutputStyleId = (typeof OUTPUT_STYLE_IDS)[number];
+
+export interface OutputStyle {
+	label: string;
+	/** Settings-preview line; keep within 60 columns so the menu doesn't truncate it. */
+	description: string;
+	/** System-prompt section and hidden reminder; omitted for Default, which leaves Pi's prompt unchanged. */
+	prompt?: { section: string; reminder: string };
+}
+
+// Matches figures.star from Claude Code: a fallback glyph on Windows, and ★ elsewhere.
+export const INSIGHT_STAR = process.platform === "win32" ? "✶" : "★";
+
+// Ported verbatim from claude-code/src/constants/outputStyles.ts:30-39.
+export const EXPLANATORY_FEATURE_PROMPT = `
+## Insights
+In order to encourage learning, before and after writing code, always provide brief educational explanations about implementation choices using (with backticks):
+"\`${INSIGHT_STAR} Insight ─────────────────────────────────────\`
+[2-3 key educational points]
+\`─────────────────────────────────────────────────\`"
+
+These insights should be included in the conversation, not in the codebase. You should generally focus on interesting insights that are specific to the codebase or the code you just wrote, rather than general programming concepts.`;
+
+export const OUTPUT_STYLE_SECTION = "output_style";
+export const OUTPUT_STYLE_MESSAGE_TYPE = "pi-topping-output-style";
+
+export const EXPLANATORY_SECTION = `# Output Style: Explanatory
+Respond to the user according to this Output Style, which describes how you should respond to user queries.
+You are an interactive CLI tool that helps users with software engineering tasks. In addition to software engineering tasks, you should provide educational insights about the codebase along the way.
+
+You should be clear and educational, providing helpful explanations while remaining focused on the task. Balance educational content with task completion. When providing insights, you may exceed typical length constraints, but remain focused and relevant.
+Insight blocks are the one exception to the "Be concise in your responses" rule; keep everything outside them concise.
+
+# Explanatory Style Active
+${EXPLANATORY_FEATURE_PROMPT}`;
+
+export const EXPLANATORY_REMINDER = "<system-reminder>\nExplanatory output style is active. Remember to follow the specific guidelines for this style.\n</system-reminder>";
+
+export const SIMPLIFIED_TECHNICAL_ENGLISH_SECTION = `You are an interactive CLI tool that helps users with software engineering tasks.
+
+Write all English in ASD-STE100 Simplified Technical English. STE is a controlled
+language. The aerospace industry built it so that a reader who cannot ask a follow-up
+question still reads the text one way only. Its rules are countable, so check your
+prose against them as you write it.
+
+## Precedence
+
+These rules set the default shape of the English you write. Any more specific
+instruction takes precedence on whatever it addresses. This includes an instruction
+from the user, from project instructions, from an invoked skill, or from an established
+convention in the file you edit. Where the more specific instruction is silent, these
+rules apply.
+
+Follow the more specific instruction without comment. Do not cite this style as a
+reason to override it. Do not ask permission.
+
+This exception applies to an explicit instruction only. Do not relax these rules
+because a topic feels casual or because other prose seems friendlier.
+
+## Never apply these rules to
+
+- Code. This includes identifiers, syntax, and string literals.
+- Quoted material. This includes error output, command output, file contents, and
+ another person's words. To rewrite a quotation is falsification, not simplification.
+- Text where the exact wording carries the meaning. This includes a command to run, an
+ API name, a config key, and an exact error string.
+
+## Rules
+
+| Rule | Limit |
+| --- | --- |
+| Noun clusters | Maximum 3 words stacked as a modifier. Break a longer stack apart and name the relationship. |
+| Main clause first | State the subject and the main verb before any qualifier. Move a relative clause to after the main verb where you can. |
+| Sentence length | Maximum 20 words for an instruction or a procedure. Maximum 25 words for descriptive text. |
+| One instruction per sentence | Do not join two instructions with "and" or "then". |
+| Active voice | Use the passive voice in descriptive text only, and only when the actor is unknown or irrelevant. |
+| Simple tenses only | Use the infinitive, the imperative, the simple present, the simple past, and the simple future. Use a past participle as an adjective only. Do not use the present perfect, the past perfect, or a compound auxiliary. |
+| No \`-ing\` verb forms | Use an \`-ing\` word as a technical noun, or as part of one, only. |
+| No hedge stacking | Do not chain modal verbs, as in "may have been caused by". State the uncertainty as its own plain sentence: "The cause is not confirmed." |
+| One word, one meaning | Use one term for one concept and repeat it. Do not rotate synonyms for the same idea. |
+| Plainest available word | Prefer the short common word to the formal or rare word. |
+| Define domain terms | Define a term that is not common English at first use. Do not carry undefined shorthand forward. |
+| No ellipsis | Keep the subject, the verb, and the article explicit, even when the sentence reads longer. |
+| Paragraphs | One topic. Maximum 6 sentences. |
+| Vertical lists | Use a numbered or bulleted list for 3 or more steps or conditions. |
+
+## Project vocabulary
+
+STE permits a project to define its own approved vocabulary of technical nouns and
+verbs. A \`CONTEXT.md\` file at a repository root is that vocabulary.
+
+If the project has a \`CONTEXT.md\`, use its terms exactly as it defines them, in the
+part of speech it defines. Never substitute a synonym for a term it defines. Never use
+a word that its \`_Avoid_\` lines reject. Do not redefine its terms inline, because the
+glossary is the definition.
+
+If the project has no \`CONTEXT.md\`, do not invent one. Do not present any term as
+already established. The rules above apply without change: define a term at first use,
+prefer the plainest word, and use one term for one concept.
+
+## Length is not terseness
+
+The caps apply to each sentence, not to the response. Clarity is the goal, not
+concision. A long answer in short sentences is correct.
+
+Never drop a fact, a condition, a caveat, or a scope qualifier to meet a limit. Split
+the sentence instead.`;
+
+export const SIMPLIFIED_TECHNICAL_ENGLISH_REMINDER = "<system-reminder>\nSimplified Technical English output style is active. Remember to follow the specific guidelines for this style.\n</system-reminder>";
+
+export const OUTPUT_STYLES: Readonly<Record<OutputStyleId, OutputStyle>> = {
+	default: {
+		label: "Default",
+		description: "pi completes coding tasks efficiently and concisely",
+	},
+	explanatory: {
+		label: "Explanatory",
+		description: "pi explains its implementation choices and codebase patterns",
+		prompt: { section: EXPLANATORY_SECTION, reminder: EXPLANATORY_REMINDER },
+	},
+	simplified: {
+		label: "Simplified Technical English",
+		description: "pi writes simple prose in Simplified Technical English",
+		prompt: { section: SIMPLIFIED_TECHNICAL_ENGLISH_SECTION, reminder: SIMPLIFIED_TECHNICAL_ENGLISH_REMINDER },
+	},
+};
+
+export function isOutputStyleId(value: unknown): value is OutputStyleId {
+	return typeof value === "string" && OUTPUT_STYLE_IDS.some(id => id === value);
+}
+
+/** Map the old pi-topping-insights style spelling to the current lowercase id. */
+export function fromLegacyOutputStyle(value: unknown): OutputStyleId | undefined {
+	if (value === "default") return "default";
+	if (value === "Explanatory") return "explanatory";
+	return undefined;
+}
+
+/**
+ * Apply a style's prompt section and return its hidden reminder. Default removes the section only
+ * when it holds one of these styles' text, so another extension's section survives. Hosts without
+ * structured prompt sections get no change.
+ */
+export function applyOutputStyle(
+	sections: Record<string, string> | undefined,
+	id: OutputStyleId,
+): BeforeAgentStartEventResult | undefined {
+	if (!sections) return undefined;
+
+	const style = OUTPUT_STYLES[id];
+	if (!style.prompt) {
+		if (OUTPUT_STYLE_IDS.some(styleId => {
+			const ownedSection = OUTPUT_STYLES[styleId].prompt?.section;
+			return ownedSection !== undefined && ownedSection === sections[OUTPUT_STYLE_SECTION];
+		})) {
+			delete sections[OUTPUT_STYLE_SECTION];
+		}
+		return undefined;
+	}
+
+	sections[OUTPUT_STYLE_SECTION] = style.prompt.section;
+	return {
+		message: {
+			customType: OUTPUT_STYLE_MESSAGE_TYPE,
+			content: style.prompt.reminder,
+			display: false,
+		},
+	};
+}

package/src/preview.ts

@@ -4,8 +4,10 @@ import { ActivityMeter, METER_UPPER_BOUND_TPS_MAX, METER_UPPER_BOUND_TPS_MIN, ra
 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 { isOutputStyleId, OUTPUT_STYLES } from "./output-style.ts";
 import { buildCompletionMarkerContent, buildCompletionMarkerLine, buildPromptBoxLines } from "./prompt-decorator.ts";
-import { DEFAULT_SETTINGS, fromCycleDirection, fromCycleMeterUpperBound, fromCycleSpeed, isBorderStyle, isDoneMarkerBorderColor, isDoneMarkerBorderStyle, isDoneMarkerStyle, isPromptBorderColor, isSpinnerColor, isThinkingLevelColor, LOADER_ORDER_ID, MENU_ENTRIES, parseLoaderOrder } from "./settings.ts";
+import { formatServiceTierSummary } from "./service-tier.ts";
+import { DEFAULT_SETTINGS, fromCycleDirection, fromCycleMeterUpperBound, fromCycleSpeed, isBorderStyle, isDoneMarkerBorderColor, isDoneMarkerBorderStyle, isDoneMarkerStyle, isPromptBorderColor, isSpinnerColor, isThinkingLevelColor, LOADER_ORDER_ID, MENU_ENTRIES, OUTPUT_STYLE_ID, parseLoaderOrder } from "./settings.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.
@@ -32,6 +34,10 @@ 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 === OUTPUT_STYLE_ID) {
+			const id = isOutputStyleId(values[OUTPUT_STYLE_ID]) ? values[OUTPUT_STYLE_ID] : DEFAULT_SETTINGS.outputStyle;
+			return { lines: ["", OUTPUT_STYLES[id].description, this.#ctx.ui.theme.fg("dim", "Applies from your next message")] };
+		}
 		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;
@@ -143,6 +149,7 @@ export class PreviewRenderer {
 		const details: string[] = [];
 		if (values.doneMarkerTokens === true) details.push("↓ 949 tokens");
 		if (values.doneMarkerInputs === true) details.push("2 mid-turn inputs");
+		if (values.doneMarkerServiceTier === true) details.push(formatServiceTierSummary([{ tier: "flex", calls: 3 }]));
 		let model = "";
 		if (values.doneMarkerModel === true) {
 			const color = isThinkingLevelColor(values.doneMarkerModelColor) ? values.doneMarkerModelColor : DEFAULT_SETTINGS.decorations.doneMarkerModelColor;

package/src/prompt-decorator.ts

@@ -1,4 +1,4 @@
-import type { MessageRenderer } from "@earendil-works/pi-coding-agent";
+import type { MessageRenderer, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { getThinkingLevelColorizer, isThinkingLevel, type ThinkingLevel } from "./format.ts";
 import { DEFAULT_SETTINGS, isBorderStyle, isPromptBorderColor, type BorderStyle, type DoneMarkerBorderColor, type DoneMarkerBorderStyle, type DoneMarkerStyle, type PromptBorderColor } from "./settings.ts";
@@ -41,7 +41,7 @@ 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, then an optional pre-styled model suffix. */
+/** Assemble the completion summary with an optional word color and pre-styled model suffix. */
 export function buildCompletionMarkerContent(
 	theme: PromptTheme,
 	icon: string,
@@ -49,9 +49,12 @@ export function buildCompletionMarkerContent(
 	elapsed: string,
 	details: string[],
 	model = "",
+	wordColor: ThemeColor = "dim",
 ): string {
 	const tail = details.length ? ` (${details.join(" · ")})` : "";
-	const summary = theme.fg("dim", `${icon ? " " : ""}${word} for ${elapsed}${tail}`);
+	const summary = wordColor === "dim"
+		? theme.fg("dim", `${icon ? " " : ""}${word} for ${elapsed}${tail}`)
+		: `${icon ? theme.fg("dim", " ") : ""}${theme.fg(wordColor, word)}${theme.fg("dim", ` for ${elapsed}${tail}`)}`;
 	return `${icon}${summary}${model ? `${theme.fg("dim", " · ")}${model}` : ""}`;
 }
 
@@ -96,7 +99,6 @@ export function buildPromptBoxLines(
 	const thinkingLevel = isThinkingLevel(options.thinkingLevel) ? options.thinkingLevel : undefined;
 	const border = getThinkingLevelColorizer(theme, borderColor, thinkingLevel);
 	const iconColor = (text: string) => theme.fg("text", text);
-	const label = (text: string) => theme.fg("customMessageLabel", text);
 	const muted = (text: string) => theme.fg("dim", text);
 	const bodyText = (text: string) => theme.fg("customMessageText", text);
 	const time = options.showTimestamp === false || !submittedAt

package/src/served-model.ts

@@ -0,0 +1,19 @@
+import { isPlainObject, sanitizedText } from "./util.ts";
+
+export interface ServedModelReport {
+	model: string;
+	backend?: string;
+}
+
+/** Extract the served model and optional gateway backend from a raw Responses stream event. */
+export function servedModelOf(data: unknown): ServedModelReport | undefined {
+	try {
+		if (!isPlainObject(data) || !isPlainObject(data.response)) return undefined;
+		const model = sanitizedText(data.response.model) || undefined;
+		if (!model) return undefined;
+		const backend = sanitizedText(data.provider);
+		return { model, ...(backend ? { backend } : {}) };
+	} catch {
+		return undefined;
+	}
+}

package/src/service-tier.ts

@@ -0,0 +1,86 @@
+import { isPlainObject, sanitizedText } from "./util.ts";
+
+/** Provider calls that reported one service tier during a run. */
+export interface ServiceTierCount {
+	tier: string;
+	calls: number;
+}
+
+/** Sanitize a provider-supplied tier into a short, safe display label. */
+export function sanitizeServiceTier(raw: unknown): string | undefined {
+	let tier = sanitizedText(raw);
+	if (tier.length > 32) {
+		let end = 0;
+		let characters = 0;
+		for (const character of tier) {
+			if (characters === 32) break;
+			end += character.length;
+			characters++;
+		}
+		tier = tier.slice(0, end);
+	}
+	return tier || undefined;
+}
+
+/**
+ * Return the first sanitized tier reported in a raw provider stream event, without throwing.
+ * OpenAI chat-completions uses `service_tier`; Responses uses `response.service_tier`;
+ * Anthropic reports `message.usage.service_tier` at `message_start` and
+ * `usage.service_tier` at `message_delta`. `serviceTier` covers camel-case adapters.
+ */
+export function serviceTierOf(data: unknown): string | undefined {
+	try {
+		if (!isPlainObject(data)) return undefined;
+		const direct = sanitizeServiceTier(data.service_tier) ?? sanitizeServiceTier(data.serviceTier);
+		if (direct) return direct;
+		if (isPlainObject(data.response)) {
+			const responseTier = sanitizeServiceTier(data.response.service_tier);
+			if (responseTier) return responseTier;
+		}
+		if (isPlainObject(data.usage)) {
+			const usageTier = sanitizeServiceTier(data.usage.service_tier);
+			if (usageTier) return usageTier;
+		}
+		if (isPlainObject(data.message) && isPlainObject(data.message.usage)) {
+			return sanitizeServiceTier(data.message.usage.service_tier);
+		}
+		return undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Increment a tier's provider-call count, appending new tiers in first-seen order. */
+export function recordServiceTierCall(counts: ServiceTierCount[], tier: string): void {
+	const existing = counts.find((entry) => entry.tier === tier);
+	if (existing) existing.calls++;
+	else counts.push({ tier, calls: 1 });
+}
+
+/** Validate persisted tier counts, dropping malformed entries and merging sanitized duplicates. */
+export function serviceTierCountsOf(raw: unknown): ServiceTierCount[] {
+	if (!Array.isArray(raw)) return [];
+	const counts: ServiceTierCount[] = [];
+	for (const item of raw) {
+		if (!isPlainObject(item)) continue;
+		const tier = sanitizeServiceTier(item.tier);
+		const calls = item.calls;
+		if (!tier || typeof calls !== "number" || !Number.isSafeInteger(calls) || calls <= 0) continue;
+		const existing = counts.find((entry) => entry.tier === tier);
+		if (existing) {
+			const sum = existing.calls + calls;
+			if (Number.isSafeInteger(sum)) existing.calls = sum;
+		} else {
+			counts.push({ tier, calls });
+		}
+	}
+	return counts;
+}
+
+/** Format the ordered summary of provider calls that reported a tier. */
+export function formatServiceTierSummary(counts: readonly ServiceTierCount[]): string {
+	if (counts.length === 0) return "";
+	const totalCalls = counts.reduce((total, entry) => total + entry.calls, 0);
+	if (totalCalls === 1) return `${counts[0]!.tier} tier`;
+	return counts.map(({ tier, calls }) => `${tier} tier ×${calls}`).join(", ");
+}

package/src/session.ts

@@ -1,6 +1,8 @@
 import type {
 	AgentSettledEvent,
 	AgentStartEvent,
+	BeforeAgentStartEvent,
+	BeforeAgentStartEventResult,
 	CustomEntry,
 	ExtensionAPI,
 	ExtensionCommandContext,
@@ -14,6 +16,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Text, type Component } from "@earendil-works/pi-tui";
 import { ActivityMeter, rateToLevel, TokRateTracker } from "./activity-meter.ts";
+import { ROUTED_MODEL_CHANNEL, routedModelAnnouncement } from "./autorouter-feed.ts";
 import {
 	dimAttribute,
 	getThinkingLevelColorizer,
@@ -39,6 +42,7 @@ import {
 } from "./format.ts";
 import { buildLoaderMessage } from "./loader-message.ts";
 import { showMenu } from "./menu.ts";
+import { applyOutputStyle, OUTPUT_STYLES } from "./output-style.ts";
 import { getResponseModelColorizer } from "./nvidia-green.ts";
 import { registerSetupCommand } from "./setup-command.ts";
 import { applyMenuResult, buildMenuSections, loadSettings, saveSettings, type ThinkingLevelColor } from "./settings.ts";
@@ -46,7 +50,9 @@ import { announcesEmbedded, STATUSLINE_EMBED_CHANNEL } from "./statusline-embed.
 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 { isPlainObject, modelsResemble, stripControlChars } from "./util.ts";
+import { isPlainObject, modelsResemble, sanitizedText, stripControlChars } from "./util.ts";
+import { formatServiceTierSummary, recordServiceTierCall, serviceTierCountsOf, serviceTierOf, type ServiceTierCount } from "./service-tier.ts";
+import { servedModelOf } from "./served-model.ts";
 import { loadBundledWordPacks, loadUserWordPacks, pickWorkingTextSelection, type WorkingTextSelection, type WordPack } from "./word-packs.ts";
 
 type MessageStartEvent = Extract<ExtensionEvent, { type: "message_start" }>;
@@ -55,10 +61,13 @@ type MessageEndEvent = Extract<ExtensionEvent, { type: "message_end" }>;
 type ToolExecutionStartEvent = Extract<ExtensionEvent, { type: "tool_execution_start" }>;
 type UIPromptStartEvent = Extract<ExtensionEvent, { type: "ui_prompt_start" }>;
 type UIPromptEndEvent = Extract<ExtensionEvent, { type: "ui_prompt_end" }>;
+type ProviderStreamEvent = Extract<ExtensionEvent, { type: "provider_stream_event" }>;
 type UIPromptKind = UIPromptStartEvent["kind"];
 
 const DONE_ENTRY_TYPE = "pi-topping-done";
 const RESPONSE_MODEL_STATUS_KEY = "pi-topping-response-model";
+/** Pi's `VIRTUAL_MODEL_API` for extension-registered virtual models; Pi does not export it from its public index. */
+const VIRTUAL_MODEL_API = "pi-virtual";
 const WAITING_LABELS: Record<UIPromptKind, string> = {
 	select: "Waiting for selection",
 	confirm: "Waiting for confirmation",
@@ -73,14 +82,31 @@ const TOKEN_RATE_HOLD_MS = 1_500;
 const TOKEN_RATE_FADE_MS = 250;
 
 interface DoneEntryData {
+	aborted?: boolean;
 	word: string;
 	elapsedMs: number;
 	tokens?: number;
 	midTurnInputs?: number;
+	serviceTiers?: ServiceTierCount[];
 	thinkingLevel?: ThinkingLevel;
 	model?: string;
 }
 
+/** A response model as one source reports it, for `updateResponseModel`. */
+interface ResponseModelReport {
+	raw: unknown;
+	/**
+	 * True for a bare routed model id (a router announcement or, under a virtual selection, the
+	 * message's `model`) rather than a provider-reported value. A weak value never displaces a
+	 * decorated form of itself the provider already reported, such as a dated name.
+	 */
+	weak: boolean;
+	/** The message's own provider when `raw` is its `model`, to recognize a failed route. */
+	provider?: string;
+	backend?: string;
+	routedId?: string;
+}
+
 interface SessionState {
 	startTime: number;
 	workingText: WorkingTextSelection;
@@ -92,6 +118,12 @@ interface SessionState {
 	lastTokenRateSampledAt: number;
 	lastTokenRateTotal: number;
 	responseModel: string;
+	served: { model: string; backend: string; routedId: string } | null;
+	/** The backend companion to the last raw response-model report. */
+	lastResponseModelBackend: string | undefined | typeof NOT_SENT;
+	/** The tier reported by the in-flight provider call, added to counts at its assistant message_end. */
+	pendingServiceTier: string;
+	serviceTiers: ServiceTierCount[];
 	/** Last raw responseModel value seen, or the NOT_SENT sentinel before the first call. */
 	lastResponseModelRaw: unknown;
 	responseModelHoldTimer: ReturnType<typeof setTimeout> | null;
@@ -134,6 +166,10 @@ function makeFreshState(): SessionState {
 		lastTokenRateSampledAt: 0,
 		lastTokenRateTotal: 0,
 		responseModel: "",
+		served: null,
+		lastResponseModelBackend: NOT_SENT,
+		pendingServiceTier: "",
+		serviceTiers: [],
 		lastResponseModelRaw: NOT_SENT,
 		responseModelHoldTimer: null,
 		responseModelFadeTimer: null,
@@ -155,10 +191,6 @@ 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();
@@ -193,13 +225,21 @@ export class SessionManager {
 		}
 	};
 
+	/** Unlike the UI handlers, this runs in every mode: the output style shapes the model's prompt. */
+	#onBeforeAgentStart = (event: BeforeAgentStartEvent): BeforeAgentStartEventResult | undefined =>
+		applyOutputStyle(event.systemPromptOptions?.sections, this.#settings.outputStyle);
+
 	#onInput = async (event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult | void> => {
 		this.#currentCtx = ctx;
 		if (!this.usable(ctx)) return;
 
 		if (!event.streamingBehavior && !this.#state.busy) this.resetTurn(Date.now());
 		else if (event.streamingBehavior && event.source !== "extension") this.#state.midTurnInputs++;
-		if (this.#settings.decorations.decorateUserPrompt && this.shouldDecorate(event)) {
+		if (
+			this.#settings.decorations.decorateUserPrompt &&
+			OUTPUT_STYLES[this.#settings.outputStyle].prompt === undefined &&
+			this.shouldDecorate(event)
+		) {
 			try {
 				await this.#pi.sendMessage<PromptBoxDetails>(
 					{
@@ -246,7 +286,7 @@ export class SessionManager {
 		if (this.usable(ctx) && event.message.role === "assistant") {
 			this.#state.liveTokens = 0;
 			this.#counter.reset();
-			this.updateResponseModel(responseModelOf(event.message));
+			this.updateResponseModel(this.responseModelOf(event.message));
 		}
 	};
 
@@ -260,14 +300,15 @@ export class SessionManager {
 		) {
 			this.#state.liveTokens += this.#counter.count(assistantEvent.delta, assistantEvent.type);
 		}
-		const rawResponseModel = (assistantEvent as { partial?: { responseModel?: unknown } } | undefined)?.partial?.responseModel
-			?? responseModelOf(event.message);
+		const rawResponseModel = this.responseModelOf((assistantEvent as { partial?: unknown } | undefined)?.partial)
+			?? this.responseModelOf(event.message);
 		this.updateResponseModel(rawResponseModel);
 	};
 
 	#onMessageEnd = async (event: MessageEndEvent, ctx: ExtensionContext): Promise<void> => {
 		this.#currentCtx = ctx;
 		if (!this.usable(ctx) || event.message.role !== "assistant") return;
+		this.commitServiceTierCall();
 
 		const rawTokens = event.message.usage?.output;
 		const exactTokens =
@@ -282,9 +323,25 @@ export class SessionManager {
 		}
 		this.#state.liveTokens = 0;
 		this.#counter.reset();
-		this.updateResponseModel(responseModelOf(event.message));
+		this.updateResponseModel(this.responseModelOf(event.message));
 	};
 
+	#onProviderStreamEvent = (event: ProviderStreamEvent, ctx: ExtensionContext): void => {
+		if (!this.usable(ctx) || !this.#state.busy) return;
+		const tier = serviceTierOf(event.data);
+		if (tier) this.#state.pendingServiceTier = tier;
+		const served = servedModelOf(event.data);
+		if (served) {
+			this.updateResponseModel({ raw: served.model, weak: false, provider: event.provider, backend: served.backend });
+		}
+	};
+
+	private commitServiceTierCall(): void {
+		if (!this.#state.pendingServiceTier) return;
+		recordServiceTierCall(this.#state.serviceTiers, this.#state.pendingServiceTier);
+		this.#state.pendingServiceTier = "";
+	}
+
 	#onToolExecutionStart = async (_e: ToolExecutionStartEvent, ctx: ExtensionContext): Promise<void> => {
 		this.#currentCtx = ctx;
 		if (this.usable(ctx)) {
@@ -311,9 +368,10 @@ export class SessionManager {
 		this.tick();
 	};
 
-	#onAgentSettled = async (_e: AgentSettledEvent, ctx: ExtensionContext): Promise<void> => {
+	#onAgentSettled = async (e: AgentSettledEvent, ctx: ExtensionContext): Promise<void> => {
 		this.#currentCtx = ctx;
 		if (!this.usable(ctx)) return;
+		this.commitServiceTierCall();
 
 		const hadPrompt = !!this.#state.startTime;
 		const elapsedMs = hadPrompt ? Date.now() - this.#state.startTime : 0;
@@ -333,11 +391,14 @@ export class SessionManager {
 		resetTokenRateState(this.#state);
 		this.#state.lastMessage = NOT_SENT;
 		if (this.#settings.features.doneMarker && hadPrompt) {
+			const aborted = e.aborted === true;
 			this.#pi.appendEntry<DoneEntryData>(DONE_ENTRY_TYPE, {
-				word: this.#settings.features.randomizeDoneMarker ? this.#state.workingText.pastTense : "Worked",
+				...(aborted ? { aborted: true } : {}),
+				word: aborted ? "Interrupted" : this.#settings.features.randomizeDoneMarker ? this.#state.workingText.pastTense : "Worked",
 				elapsedMs,
 				tokens: this.#state.confirmTokens,
 				midTurnInputs: this.#state.midTurnInputs,
+				...(this.#state.serviceTiers.length ? { serviceTiers: this.#state.serviceTiers.map((count) => ({ ...count })) } : {}),
 				thinkingLevel: ctx.thinkingLevel,
 				model: this.#state.responseModel || undefined,
 			});
@@ -354,6 +415,7 @@ export class SessionManager {
 
 	#renderDoneEntry(entry: CustomEntry<DoneEntryData>, theme: Theme): Component | undefined {
 		if (!entry.data) return undefined;
+		const aborted = entry.data.aborted === true;
 		const word = typeof entry.data.word === "string" ? stripControlChars(entry.data.word) : "Worked";
 		const elapsedMs = typeof entry.data.elapsedMs === "number" && Number.isFinite(entry.data.elapsedMs) ? entry.data.elapsedMs : 0;
 		const features = this.#settings.features;
@@ -362,16 +424,20 @@ export class SessionManager {
 		if (features.doneMarkerInputs && typeof entry.data.midTurnInputs === "number" && Number.isInteger(entry.data.midTurnInputs) && entry.data.midTurnInputs > 0) {
 			details.push(`${entry.data.midTurnInputs} mid-turn input${entry.data.midTurnInputs === 1 ? "" : "s"}`);
 		}
+		if (features.doneMarkerServiceTier) {
+			const summary = formatServiceTierSummary(serviceTierCountsOf(entry.data.serviceTiers));
+			if (summary) details.push(summary);
+		}
 		const icon = features.doneMarkerIcon ? theme.fg("text", this.#settings.decorations.useNerdFont ? "" : "π") : "";
 		const thinkingLevel = isThinkingLevel(entry.data.thinkingLevel) ? entry.data.thinkingLevel : undefined;
-		const rawModel = typeof entry.data.model === "string" ? stripControlChars(entry.data.model).trim() : "";
+		const rawModel = sanitizedText(entry.data.model);
 		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 markerContent = buildCompletionMarkerContent(theme, icon, word, formatElapsed(elapsedMs), details, model, aborted ? "warning" : "dim");
 		const borderStyle = this.#settings.decorations.doneMarkerBorderStyle;
-		const borderColor = this.#settings.decorations.doneMarkerBorderColor;
+		const borderColor = aborted ? "warning" : this.#settings.decorations.doneMarkerBorderColor;
 		const markerStyle = this.#settings.decorations.doneMarkerStyle;
 		if (borderStyle === "none") return new Text(markerContent);
 
@@ -394,11 +460,13 @@ export class SessionManager {
 
 	install(): void {
 		this.#pi.on("session_start", this.#onSessionStart);
+		this.#pi.on("before_agent_start", this.#onBeforeAgentStart);
 		this.#pi.on("input", this.#onInput);
 		this.#pi.on("agent_start", this.#onAgentStart);
 		this.#pi.on("message_start", this.#onMessageStart);
 		this.#pi.on("message_update", this.#onMessageUpdate);
 		this.#pi.on("message_end", this.#onMessageEnd);
+		this.#pi.on("provider_stream_event", this.#onProviderStreamEvent);
 		this.#pi.on("tool_execution_start", this.#onToolExecutionStart);
 		this.#pi.on("agent_settled", this.#onAgentSettled);
 		this.#pi.on("ui_prompt_start", this.#onUIPromptStart);
@@ -407,11 +475,18 @@ export class SessionManager {
 		this.#pi.events.on(STATUSLINE_EMBED_CHANNEL, (data) => {
 			this.#loaderInStatusline = announcesEmbedded(data);
 		});
+		this.#pi.events.on(ROUTED_MODEL_CHANNEL, (data) => {
+			// Direct routes serve compaction and other extensions' side requests; a route while idle
+			// is such a background request too, and must not leave a stale model for the next turn.
+			const announcement = routedModelAnnouncement(data);
+			if (!announcement || announcement.reason === "direct" || !this.#state.busy) return;
+			this.updateResponseModel({ raw: announcement.modelId, weak: true, provider: announcement.provider, routedId: announcement.modelId });
+		});
 		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.",
+			description: "Configure the prompt box, working loader, completion marker, word packs, and output style.",
 			handler: async (_a, ctx) => this.showSettings(ctx),
 		});
 		registerSetupCommand(this.#pi);
@@ -475,25 +550,63 @@ export class SessionManager {
 		}
 	}
 
-	private updateResponseModel(raw: unknown): void {
-		if (raw === this.#state.lastResponseModelRaw) return;
-		this.#state.lastResponseModelRaw = raw;
-		const responseModel = typeof raw === "string" ? stripControlChars(raw).trim() : "";
-		const selectedModel = this.#currentCtx?.model?.id;
-		if (responseModel && modelsResemble(selectedModel, responseModel)) {
+	/**
+	 * The response model a message reports. Under a virtual selection Pi stamps the routed
+	 * physical model on the message's `model` instead, so fall back to that as a weak value;
+	 * a failed route leaves the virtual model itself there, which `restatesSelection` hides.
+	 */
+	private responseModelOf(message: unknown): ResponseModelReport | undefined {
+		if (!isPlainObject(message)) return undefined;
+		if (message.responseModel !== undefined) {
+			return { raw: message.responseModel, weak: false, routedId: sanitizedText(message.model) || undefined };
+		}
+		if (this.#currentCtx?.model?.api !== VIRTUAL_MODEL_API) return undefined;
+		return { raw: message.model, weak: true, provider: typeof message.provider === "string" ? message.provider : undefined };
+	}
+
+	/**
+	 * Whether a response model merely restates the selected model. Under a virtual selection
+	 * the routed model is always another model, so only a failed route, which leaves the
+	 * virtual model itself on the message, is hidden; a resemblance check would also hide a
+	 * routed model whose id contains the virtual id, such as openrouter's `auto`.
+	 */
+	private restatesSelection(report: ResponseModelReport, responseModel: string): boolean {
+		const selected = this.#currentCtx?.model;
+		if (!selected) return false;
+		if (selected.api === VIRTUAL_MODEL_API) return report.provider === selected.provider && responseModel === selected.id;
+		return modelsResemble(selected.id, responseModel);
+	}
+
+	private updateResponseModel(report: ResponseModelReport | undefined): void {
+		const backendReport = report?.backend;
+		if (report?.raw === this.#state.lastResponseModelRaw && backendReport === this.#state.lastResponseModelBackend) return;
+		this.#state.lastResponseModelRaw = report?.raw;
+		this.#state.lastResponseModelBackend = backendReport;
+		if (!report) return;
+		const model = sanitizedText(report.raw);
+		if (!model) return;
+		const backend = report.backend ?? (model === this.#state.served?.model ? this.#state.served.backend : "");
+		const showBackend = !!backend && backend !== report.provider;
+		const restates = this.restatesSelection(report, model);
+		const display = restates ? (showBackend ? `via ${backend}` : "") : (showBackend ? `${model} via ${backend}` : model);
+		if (!display) {
 			if (this.#state.responseModel) {
 				this.#state.responseModel = "";
 				this.stopResponseModelSlide();
 				this.tick();
 			}
+			this.#state.served = null;
 			return;
 		}
-		if (responseModel && responseModel !== this.#state.responseModel) {
+		if (report.weak && model === this.#state.served?.routedId) return;
+		const changed = display !== this.#state.responseModel;
+		if (changed) {
 			// 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();
+			this.#state.responseModel = display;
 		}
+		this.#state.served = { model, backend, routedId: report.routedId ?? model };
+		if (changed) this.tick();
 	}
 
 	/**
@@ -601,7 +714,11 @@ export class SessionManager {
 		state.confirmTokens = 0;
 		state.liveTokens = 0;
 		state.responseModel = "";
+		state.served = null;
+		state.pendingServiceTier = "";
+		state.serviceTiers = [];
 		state.lastResponseModelRaw = NOT_SENT;
+		state.lastResponseModelBackend = NOT_SENT;
 		state.activityMeter.reset();
 		resetTokenRateState(state);
 		state.midTurnInputs = 0;
@@ -688,6 +805,7 @@ export class SessionManager {
 		this.#userPacks = loadUserWordPacks();
 		this.#allPacks = [...this.#bundledPacks, ...this.#userPacks];
 		const before = this.indicatorFingerprint();
+		const styleBefore = this.#settings.outputStyle;
 		const preview = new PreviewRenderer(ctx, this.#allPacks);
 		const result = await showMenu<Record<string, boolean | string>>(ctx, {
 			title: "Pi Topping: Settings",
@@ -717,6 +835,9 @@ export class SessionManager {
 			this.startTimer();
 			this.tick();
 		}
-		ctx.ui.notify("Pi Topping settings saved", "info");
+		const notification = styleBefore === this.#settings.outputStyle
+			? "Pi Topping settings saved"
+			: `Pi Topping settings saved · ${OUTPUT_STYLES[this.#settings.outputStyle].label} output style applies from your next message`;
+		ctx.ui.notify(notification, "info");
 	}
 }

package/src/settings.ts

@@ -3,6 +3,7 @@ import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "
 import { dirname, join } from "node:path";
 import { DEFAULT_METER_UPPER_BOUND_TPS, METER_UPPER_BOUND_TPS_MAX, METER_UPPER_BOUND_TPS_MIN } from "./activity-meter.ts";
 import { DEFAULT_LOADER_ORDER, type LoaderElement } from "./format.ts";
+import { fromLegacyOutputStyle, isOutputStyleId, OUTPUT_STYLE_IDS, OUTPUT_STYLES, type OutputStyleId } from "./output-style.ts";
 import type { MenuNumberEntry, MenuSection } from "./menu.ts";
 import { isWordPackEnabled, isWordPackId, WORD_PACK_MENU_PREFIX, type WordPack } from "./word-packs.ts";
 import { isPlainObject } from "./util.ts";
@@ -119,22 +120,27 @@ export interface DecoratorSettings {
 		randomizeDoneMarker: boolean;
 		doneMarkerTokens: boolean;
 		doneMarkerInputs: boolean;
+		doneMarkerServiceTier: boolean;
 		doneMarkerModel: boolean;
 		includeDefaultWorkingText: boolean;
 	};
 	loaderOrder: LoaderElement[];
 	wordPacks: Record<string, boolean>;
+	outputStyle: OutputStyleId;
 }
 
 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, meterUpperBoundTps: DEFAULT_METER_UPPER_BOUND_TPS, 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, responseModelFooter: false, doneMarker: true, doneMarkerIcon: true, randomizeDoneMarker: true, doneMarkerTokens: true, doneMarkerInputs: true, doneMarkerModel: true, includeDefaultWorkingText: true },
+	features: { substituteDefaultMessage: true, elapsedTime: true, outputTokens: true, tokenRate: true, responseModel: true, responseModelFooter: false, doneMarker: true, doneMarkerIcon: true, randomizeDoneMarker: true, doneMarkerTokens: true, doneMarkerInputs: true, doneMarkerServiceTier: true, doneMarkerModel: true, includeDefaultWorkingText: true },
 	loaderOrder: [...DEFAULT_LOADER_ORDER],
 	wordPacks: {},
+	outputStyle: "default",
 };
 
 /** Menu key carrying the loader element order as a comma-joined list of element ids. */
 export const LOADER_ORDER_ID = "loaderOrder";
+/** Menu key for the output style cycle row. */
+export const OUTPUT_STYLE_ID = "outputStyle";
 const LOADER_ELEMENT_LABELS: Record<LoaderElement, string> = {
 	spinner: "Animated spinner",
 	text: "“Working” text",
@@ -162,6 +168,19 @@ export function parseLoaderOrder(value: unknown): LoaderElement[] {
 }
 
 export function settingsPath(): string { return join(getAgentDir(), "pi-topping", "settings.json"); }
+
+/** pi-topping-insights' saved style, honored until pi-topping's own settings record one. */
+function legacyOutputStyle(): OutputStyleId {
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(join(getAgentDir(), "pi-topping-insights", "settings.json"), "utf8"));
+		return (isPlainObject(parsed) ? fromLegacyOutputStyle(parsed.style) : undefined) ?? DEFAULT_SETTINGS.outputStyle;
+	} catch { return DEFAULT_SETTINGS.outputStyle; }
+}
+
+function defaultSettings(): DecoratorSettings {
+	return { ...structuredClone(DEFAULT_SETTINGS), outputStyle: legacyOutputStyle() };
+}
+
 function mergeGroup<T extends Record<string, boolean | string | number>>(defaults: T, parsed: unknown): T {
 	const merged = { ...defaults };
 	if (!isPlainObject(parsed)) return merged;
@@ -231,6 +250,7 @@ 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: "doneMarkerServiceTier", label: "Service tier", section: "Completion Marker", group: "features", key: "doneMarkerServiceTier" },
 	{ 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" },
@@ -311,6 +331,10 @@ export function buildMenuSections(settings: DecoratorSettings, bundledPacks: rea
 				...buildSection("Word Packs", settings).items.map((item, index) => ({ ...item, spacerBefore: index === 0, disabledUnlessAnyOf: packIds })),
 			],
 		},
+		{
+			title: "Output Style",
+			items: [{ id: OUTPUT_STYLE_ID, label: "Style", value: settings.outputStyle, cycleValues: OUTPUT_STYLE_IDS, cycleValueLabels: Object.fromEntries(OUTPUT_STYLE_IDS.map(id => [id, OUTPUT_STYLES[id].label])) }],
+		},
 		buildSection("Options", settings),
 	];
 }
@@ -335,6 +359,8 @@ export function applyMenuResult(settings: DecoratorSettings, values: Record<stri
 		if (isWordPackId(packId)) next.wordPacks[packId] = value;
 	}
 	if (typeof values[LOADER_ORDER_ID] === "string") next.loaderOrder = parseLoaderOrder(values[LOADER_ORDER_ID]);
+	const outputStyle = values[OUTPUT_STYLE_ID];
+	if (isOutputStyleId(outputStyle)) next.outputStyle = outputStyle;
 	return next;
 }
 
@@ -348,12 +374,13 @@ export function applyMenuResult(settings: DecoratorSettings, values: Record<stri
  * border color is reset. Below 4, the response-model footer inherits the response-model
  * setting. A missing, non-integer, or out-of-range meter upper bound resolves
  * to the default of 80 tps. A legacy `features.simCityWorkingText: true` enables the
- * `simcity` pack when no explicit preference is stored.
+ * `simcity` pack when no explicit preference is stored. A missing or invalid `outputStyle`
+ * falls back to `pi-topping-insights/settings.json`'s `style`, then to `default`, without a schema-version gate.
  */
 export function loadSettings(): DecoratorSettings {
 	try {
 		const parsed = JSON.parse(readFileSync(settingsPath(), "utf8"));
-		if (!isPlainObject(parsed)) return structuredClone(DEFAULT_SETTINGS);
+		if (!isPlainObject(parsed)) return defaultSettings();
 		const wordPacks: Record<string, boolean> = { ...DEFAULT_SETTINGS.wordPacks };
 		if (isPlainObject(parsed.wordPacks)) {
 			for (const [id, enabled] of Object.entries(parsed.wordPacks)) {
@@ -363,7 +390,9 @@ export function loadSettings(): DecoratorSettings {
 		if (isPlainObject(parsed.features) && parsed.features.simCityWorkingText === true && !("simcity" in wordPacks)) {
 			wordPacks.simcity = true;
 		}
-		const settings = { decorations: mergeGroup(DEFAULT_SETTINGS.decorations, parsed.decorations), features: mergeGroup(DEFAULT_SETTINGS.features, parsed.features), loaderOrder: parseLoaderOrder(parsed.loaderOrder), wordPacks };
+		const storedOutputStyle = parsed.outputStyle;
+		const outputStyle = isOutputStyleId(storedOutputStyle) ? storedOutputStyle : legacyOutputStyle();
+		const settings = { decorations: mergeGroup(DEFAULT_SETTINGS.decorations, parsed.decorations), features: mergeGroup(DEFAULT_SETTINGS.features, parsed.features), loaderOrder: parseLoaderOrder(parsed.loaderOrder), wordPacks, outputStyle };
 		if (isPlainObject(parsed.decorations)) {
 			for (const [key, value] of Object.entries(parsed.decorations)) {
 				if (!Object.hasOwn(DEFAULT_SETTINGS.decorations, key) || typeof value !== "string") continue;
@@ -392,7 +421,7 @@ export function loadSettings(): DecoratorSettings {
 			}
 		}
 		return settings;
-	} catch { return structuredClone(DEFAULT_SETTINGS); }
+	} catch { return defaultSettings(); }
 }
 
 export function atomicWriteFile(path: string, contents: string): void {

package/src/util.ts

@@ -8,6 +8,10 @@ export function stripControlChars(text: string): string {
 	return text.replace(/[\p{Cc}\p{Cf}]/gu, "");
 }
 
+export function sanitizedText(value: unknown): string {
+	return typeof value === "string" ? stripControlChars(value).trim() : "";
+}
+
 /** True when a reported response model appears to be a decorated form of the selected model. */
 export function modelsResemble(selectedModel?: string, responseModel?: string): boolean {
 	if (!selectedModel || !responseModel) return false;