auto-model-router 0.7.1 → 0.7.3

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.7.1",
+    "version": "0.7.3",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.7.1",
+      "version": "0.7.3",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -235,7 +235,7 @@ bun tools/install.ts --no-toast --no-configure   # only the required embed exten
 The installer adds:
 
 - `router-embed.ts` — **required**; runs the router in-process.
-- `router-toast.ts` — optional; chosen-model toasts.
+- `router-toast.ts` — optional; per-turn toasts naming the model and why it was chosen.
 - `router-configure.ts` — optional; the `/router` command (configure, usage reports, status).
 - `router-digest.ts` — optional; condenses large tool results with a cheap model before an expensive one reads them (needs `digest.enabled`).
 
@@ -814,6 +814,7 @@ disk and back up the previous file to a timestamped `.bak`.
 | `AUTO_MODEL_ROUTER_URL` | Toast/base URL override (the toast reads the shared port file first). | — |
 | `AUTO_MODEL_ROUTER_API_KEY` | Client bearer for the toast poll when `server.apiKey` is set. | — |
 | `OMP_HARNESS_ID` | Per-harness toast scoping. | — |
+| `AUTO_MODEL_ROUTER_TOAST` | `compact` for the one-line toast; anything else keeps the decision trail. | verbose |
 
 ---
 
@@ -907,6 +908,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `minTrustSamples` | `12` | Attempts before trust is enforced. |
 | `trustScopedByHarness` | `false` | `true` = each harness reads only its own trust rows. |
 | `contextHeadroom` | `1.25` | Fraction of context kept free (a model must fit prompt × this). |
+| `reasoningCompletionFloor` | `512` | Smallest completion budget a **reasoning** model is dispatched with. A reasoning model spends the budget thinking before it answers, so a caller's tight cap (omp asks ~12 tokens for a conversation title) returns nothing: measured on `ollama/gpt-oss:20b`, which hit the cap having produced no content and cost a dead dispatch plus a failover. Raised only for models that reason, never above the model's own ceiling, and a cap is an upper bound so a direct answer still stops early. 0 disables. |
 | `latencyWeight` | `0` | How hard to penalise slow models in scoring (soft multiplier on effective cost). `0` disables it. |
 | `latencyMinSamples` | `20` | Streamed samples before latency is judged against a model. |
 | `cacheReliabilityMinSamples` | `10` | Warm-expected samples before a model's observed cache hit rate discounts its "stay warm" price in the stay/switch comparison. A model whose cache misses when it should be warm (measured: 5-6% on glm/gemini, 11% on ling, 50% on nex) is kept less eagerly. `0` assumes every cache is reliable. |
@@ -1468,11 +1470,27 @@ come from a small omp extension that polls the router's in-process ledger:
 // omp-extension/router-toast.ts  (shipped in this repo)
 ```
 
-It raises a TUI toast (`ctx.ui.notify`) like
-`openrouter · meta/muse-glimmer-30b [trivial] · $0.00001` or
-`ollama · glm-5.3-flash [moderate] · $0.00070` whenever a new model is chosen —
-provider first, so a mixed catalog is legible at a glance. Install it by adding
-the file's absolute path to omp's `extensions:` list.
+It raises a TUI toast (`ctx.ui.notify`) whenever a model is chosen, explaining
+the decision rather than just naming it — provider first, so a mixed catalog is
+legible at a glance:
+
+```
+openrouter · openai/gpt-5.2 [hard] · $0.01820
+why: failover: z-ai/glm-5.3-flash empty_completion (hit the length cap having…
+     escalated from moderate
+48.2k prompt · 12.8k compacted · 11 tools · attempt 2 · 2.1s to first token
+```
+
+The **why** lines come from the router's own decision trail, picked by how much
+they change what you would do: a failover or a policy pin explains a surprising
+model outright, a hold or a tier rescue explains why the obvious cheaper pick was
+skipped, and when nothing surprising happened the ranking rationale itself is
+shown. The last line is what the model was actually handed. An unreported cost
+falls back to the forecast (`~$…`).
+
+`AUTO_MODEL_ROUTER_TOAST=compact` restores the old one-liner
+(`openrouter · meta/muse-glimmer-30b [trivial] · $0.00001`). Install the
+extension by adding the file's absolute path to omp's `extensions:` list.
 
 Because the embedded router binds a random port, the toast resolves the router
 base URL on every poll in this order: the embedded router's port file

package/omp-extension/router-toast.ts

@@ -38,6 +38,9 @@ import { newestId, selectToasts, type ToastDecision } from "./toast-logic.ts";
 // Empty ⇒ toast every harness (single-harness default).
 const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "";
 const POLL_MS = 2_000;
+// The toast explains the choice by default: model, tier, cost, why it was picked
+// and what it was handed. `AUTO_MODEL_ROUTER_TOAST=compact` restores the one-liner.
+const VERBOSE = (process.env.AUTO_MODEL_ROUTER_TOAST ?? "").toLowerCase() !== "compact";
 
 export default function (pi: ExtensionAPI): void {
 	pi.setLabel("auto-model-router toast");
@@ -91,7 +94,7 @@ export default function (pi: ExtensionAPI): void {
 				const entries = body.entries;
 				if (!Array.isArray(entries) || entries.length === 0) return;
 
-				for (const t of selectToasts(entries, lastSeenId, HARNESS_ID, sessionId)) {
+				for (const t of selectToasts(entries, lastSeenId, HARNESS_ID, sessionId, VERBOSE)) {
 					ctx.ui.notify(t.text, "info");
 				}
 				lastSeenId = newestId(entries) ?? lastSeenId;

package/omp-extension/toast-logic.ts

@@ -88,6 +88,20 @@ export interface ToastDecision {
 	 * default. Lets the toast scope to a single interactive session.
 	 */
 	ompSessionId?: string;
+	/** The router's own decision trail, already written for people. */
+	reasons?: string[];
+	/** Classifier inputs; only a few are worth surfacing. */
+	features?: { promptTokens?: number; toolCount?: number; turnDepth?: number; isToolResultContinuation?: boolean } | null;
+	/** Attempt index within the turn; >0 means this served after an escalation. */
+	attempt?: number;
+	/** Prompt tokens compaction removed before dispatch. */
+	promptTokensSaved?: number;
+	/** What the router expected this to cost, before the upstream reported. */
+	predictedUsd?: number;
+	latencyMs?: number;
+	ttftMs?: number | null;
+	task?: string | null;
+	classificationSource?: string;
 }
 
 export interface ToastMessage {
@@ -110,10 +124,89 @@ export function providerOf(slug: string): { provider: string; model: string } {
 	return { provider: "openrouter", model: slug };
 }
 
-export function toToastText(d: ToastDecision): string {
+/**
+ * Which parts of the decision trail earn a line in a toast.
+ *
+ * The router writes many reasons per turn; a toast has room for two. These
+ * patterns are ordered by how much they change what the reader would do:
+ * a failover or a policy pin explains a surprising model outright, a hold or a
+ * rescue explains why the obvious cheaper pick was skipped, and the rest is
+ * ordinary ranking that the tier already conveys.
+ */
+const REASON_PRIORITY: readonly RegExp[] = [
+	/failover|escalat/i,
+	/policy|pin(ned)?|allow|deny/i,
+	/held|sticky|hysteresis|switch margin/i,
+	/budget raised|reasons before it answers/i,
+	// The RESCUE wording only: "cheapest above the quality floor" is ordinary
+	// ranking, and matching a bare "floor" would push it above real surprises.
+	/tier rescue|relaxed|adaptive (floor|ceiling)/i,
+	/cache|warm/i,
+	/compact/i,
+	/explor/i,
+];
+
+const clip = (text: string, max: number): string => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
+
+/** Up to `limit` reasons, most explanatory first, each trimmed for one line. */
+export function whyReasons(reasons: readonly string[] | undefined, limit = 2): string[] {
+	if (reasons === undefined || reasons.length === 0) return [];
+	const picked: string[] = [];
+	const seen = new Set<number>();
+	for (const re of REASON_PRIORITY) {
+		for (let i = 0; i < reasons.length && picked.length < limit; i++) {
+			const r = reasons[i];
+			if (r === undefined || seen.has(i) || !re.test(r)) continue;
+			seen.add(i);
+			picked.push(clip(r.replace(/\s+/g, " ").trim(), 90));
+		}
+		if (picked.length >= limit) break;
+	}
+	// Nothing matched a pattern: the first reason is the ranking rationale itself.
+	if (picked.length === 0 && reasons[0] !== undefined) picked.push(clip(reasons[0].replace(/\s+/g, " ").trim(), 90));
+	return picked;
+}
+
+const tokens = (n: number): string => (n >= 1000 ? `${Math.round(n / 100) / 10}k` : String(n));
+
+/** The turn's shape in a few words: what the model was actually handed. */
+export function factsOf(d: ToastDecision): string[] {
+	const out: string[] = [];
+	const f = d.features ?? undefined;
+	if (f?.promptTokens !== undefined && f.promptTokens > 0) out.push(`${tokens(f.promptTokens)} prompt`);
+	if (d.promptTokensSaved !== undefined && d.promptTokensSaved > 0) out.push(`${tokens(d.promptTokensSaved)} compacted`);
+	if (f?.toolCount !== undefined && f.toolCount > 0) out.push(`${f.toolCount} tools`);
+	if (f?.isToolResultContinuation === true) out.push("tool continuation");
+	if (d.attempt !== undefined && d.attempt > 0) out.push(`attempt ${d.attempt + 1}`);
+	if (d.task !== undefined && d.task !== null && d.task !== "" && d.task !== "coding") out.push(d.task);
+	if (d.ttftMs !== undefined && d.ttftMs !== null && d.ttftMs > 0) out.push(`${(d.ttftMs / 1000).toFixed(1)}s to first token`);
+	else if (d.latencyMs !== undefined && d.latencyMs > 0) out.push(`${(d.latencyMs / 1000).toFixed(1)}s`);
+	return out;
+}
+
+/** `$0.00042`, or the prediction when the upstream reported nothing. */
+function costOf(d: ToastDecision): string {
+	if (d.reportedUsd !== null && d.reportedUsd !== undefined) return `$${d.reportedUsd.toFixed(5)}`;
+	if (d.predictedUsd !== undefined && d.predictedUsd > 0) return `~$${d.predictedUsd.toFixed(5)}`;
+	return "";
+}
+
+/**
+ * The toast body. `verbose` (the default) adds the decision trail and the
+ * turn's shape under the headline; `compact` is the original single line, for
+ * anyone who wants the model name and nothing else.
+ */
+export function toToastText(d: ToastDecision, verbose = true): string {
 	const { provider, model } = providerOf(d.servedSlug ?? d.slug);
-	const cost = d.reportedUsd === null ? "" : ` \u00b7 $${d.reportedUsd.toFixed(5)}`;
-	return `${provider} \u00b7 ${model} [${d.tier}]${cost}`;
+	const cost = costOf(d);
+	const head = `${provider} \u00b7 ${model} [${d.tier}]${cost === "" ? "" : ` \u00b7 ${cost}`}`;
+	if (!verbose) return head;
+	const lines = [head];
+	const why = whyReasons(d.reasons);
+	for (const [i, r] of why.entries()) lines.push(`${i === 0 ? "why: " : "     "}${r}`);
+	const facts = factsOf(d);
+	if (facts.length > 0) lines.push(facts.join(" \u00b7 "));
+	return lines.join("\n");
 }
 
 /**
@@ -129,6 +222,7 @@ export function selectToasts(
 	lastSeenId: string | null,
 	harnessId = "",
 	ompSessionId = "",
+	verbose = true,
 ): ToastMessage[] {
 	if (lastSeenId === null) return [];
 	// `entries` is newest-first. Entries strictly newer than lastSeenId are the
@@ -143,7 +237,7 @@ export function selectToasts(
 		if (d.wasted) continue;
 		if (harnessId !== "" && d.harnessId !== harnessId) continue;
 		if (ompSessionId !== "" && d.ompSessionId !== ompSessionId) continue;
-		out.push({ model: d.servedSlug ?? d.slug, tier: d.tier, costUsd: d.reportedUsd, text: toToastText(d) });
+		out.push({ model: d.servedSlug ?? d.slug, tier: d.tier, costUsd: d.reportedUsd, text: toToastText(d, verbose) });
 	}
 	return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/config-wizard.ts

@@ -189,6 +189,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "filters.trustScopedByHarness", label: "Scope trust per harness", kind: "boolean" },
 			{ path: "filters.trustWindowDays", label: "Trust window", kind: "number", min: 0, hint: "days, 0=all time" },
 			{ path: "filters.contextHeadroom", label: "Context headroom", kind: "number", min: 1 },
+			{ path: "filters.reasoningCompletionFloor", label: "Reasoning completion floor", kind: "number", min: 0 },
 			{ path: "filters.latencyWeight", label: "Latency weight", kind: "number", min: 0, hint: "0=ignore speed" },
 			{ path: "filters.latencyReferenceMs", label: "Latency reference TTFT", kind: "number", min: 1, hint: "ms" },
 			{ path: "filters.latencyReferenceTokensPerSec", label: "Latency reference speed", kind: "number", min: 1, hint: "tok/s" },

package/src/config/defaults.ts

@@ -114,6 +114,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// opt-in after a replay run prices it.
 		trustWindowDays: 0,
 		contextHeadroom: 1.25,
+		// Enough for a short chain of thought plus a brief answer. Measured against
+		// the failure it fixes: gpt-oss:20b and nemotron-3-nano returned empty at a
+		// 12-token cap, then failed over.
+		reasoningCompletionFloor: 512,
 		// Latency scoring is off by default (weight 0): opt in after establishing a
 		// baseline. Expected total wait (TTFT + expected completion / throughput)
 		// above the references inflates a model's effective cost.

package/src/config/schema.ts

@@ -95,6 +95,7 @@ const filters = z.strictObject({
 	trustScopedByHarness: z.boolean().optional(),
 	trustWindowDays: z.number().nonnegative().optional(),
 	contextHeadroom: z.number().positive().optional(),
+	reasoningCompletionFloor: z.number().int().nonnegative().optional(),
 	latencyWeight: z.number().nonnegative().optional(),
 	latencyReferenceMs: z.number().positive().optional(),
 	latencyReferenceTokensPerSec: z.number().positive().optional(),

package/src/config/types.ts

@@ -221,6 +221,21 @@ export interface FilterConfig {
 	includeFree: boolean;
 	/** Require `supported_parameters` to include `tools` whenever the request offers tools. */
 	requireToolSupport: boolean;
+	/**
+	 * Smallest completion budget a REASONING model is dispatched with, tokens.
+	 *
+	 * A reasoning model spends the budget thinking before it answers, so a
+	 * caller's tight cap returns nothing at all: omp asks for ~12 tokens for a
+	 * conversation title, and `ollama/gpt-oss:20b` hit the cap having produced
+	 * no content, which cost a dead dispatch and a failover to another model.
+	 * When the chosen model reasons and the caller asked for less than this, the
+	 * dispatch is raised to this floor (never above the model's own completion
+	 * ceiling). Models that answer directly keep the caller's cap.
+	 *
+	 * A cap is an upper bound, not a target — a model that answers in ten tokens
+	 * still stops at ten. 0 disables the floor.
+	 */
+	reasoningCompletionFloor: number;
 	/** Drop models whose ledger success rate is below this, once `minTrustSamples` is met. */
 	minTrust: number;
 	/**

package/src/router/select.ts

@@ -608,6 +608,18 @@ export function select(args: SelectArgs): Decision {
 		// The ceiling is a hard limit anyway; passing it explicitly also caps runaway completions.
 		maxTokens = maxTokens === undefined ? ceiling : Math.min(maxTokens, ceiling);
 	}
+	// A reasoning model spends the budget thinking before it answers, so a caller's
+	// tight cap returns nothing and the turn fails over having paid for the dispatch.
+	// Raise it to the floor for those models only; the ceiling still wins.
+	const floor = cfg.filters.reasoningCompletionFloor;
+	const thinksBeforeAnswering = chosen.model.reasoningMandatory || (chosen.model.supportsReasoning && reasoning !== "off");
+	if (floor > 0 && thinksBeforeAnswering && maxTokens !== undefined && maxTokens < floor) {
+		const raised = ceiling === undefined ? floor : Math.min(floor, ceiling);
+		if (raised > maxTokens) {
+			reasons.push(`completion budget raised ${maxTokens} → ${raised}: ${chosen.model.slug} reasons before it answers`);
+			maxTokens = raised;
+		}
+	}
 	const stripAssistantReasoning = !(chosen.model.supportsReasoning && REASONING_REPLAY_AUTHORS[chosen.model.author] === true);
 
 	// The recorded forecast is the EXPECTED price of this dispatch, not the

package/test/failover.test.ts

@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",

package/test/select.test.ts

@@ -82,9 +82,11 @@ function run(opts: {
 	tier?: Tier;
 	ledger?: Ledger | null;
 	harnessId?: string;
+	maxTokens?: number;
 }) {
 	const cfg = opts.cfg ?? BASE;
-	const req = request(opts.userText ?? "tidy the retry helper");
+	const base = request(opts.userText ?? "tidy the retry helper");
+	const req = opts.maxTokens === undefined ? base : { ...base, maxTokens: opts.maxTokens };
 	const features = extractFeatures(req, opts.promptTokens ?? 4000);
 	const heuristic = scoreHeuristic(features, cfg);
 	const classification = opts.tier === undefined ? heuristic : { ...heuristic, tier: opts.tier };
@@ -353,6 +355,31 @@ describe("decision shape", () => {
 		}
 	});
 
+	test("a reasoning model gets the completion floor; a direct one keeps the caller's cap", () => {
+		const usable = (m: (typeof MODELS)[number]): boolean => m.supportsTools && m.contextLength >= 32_000 && (m.maxCompletionTokens ?? 100_000) >= 4096;
+		const thinker = MODELS.find((m) => usable(m) && m.supportsReasoning);
+		const direct = MODELS.find((m) => usable(m) && !m.supportsReasoning && !m.reasoningMandatory);
+		expect(thinker).toBeDefined();
+		expect(direct).toBeDefined();
+		const withFloor = (slug: string, floor: number): RouterConfig => ({ ...BASE, filters: { ...BASE.filters, allow: [slug], reasoningCompletionFloor: floor } });
+
+		// omp asks for a dozen tokens for a title; a reasoning model would spend them thinking
+		// and return nothing, so the dispatch is raised.
+		const raised = run({ tier: "trivial", cfg: withFloor(thinker!.slug, 512), maxTokens: 12 });
+		expect(raised.slug).toBe(thinker!.slug);
+		expect(raised.maxTokens).toBe(512);
+		expect(raised.reasons.some((r) => r.includes("reasons before it answers"))).toBe(true);
+
+		// A model that answers directly is untouched: its cap is the caller's.
+		const kept = run({ tier: "trivial", cfg: withFloor(direct!.slug, 512), maxTokens: 12 });
+		expect(kept.slug).toBe(direct!.slug);
+		expect(kept.maxTokens).toBe(12);
+
+		// The floor never raises past what the caller already asked for, and 0 disables it.
+		expect(run({ tier: "trivial", cfg: withFloor(thinker!.slug, 512), maxTokens: 4000 }).maxTokens).toBe(4000);
+		expect(run({ tier: "trivial", cfg: withFloor(thinker!.slug, 0), maxTokens: 12 }).maxTokens).toBe(12);
+	});
+
 	test("plans a probe for cheap tiers and leaves the top tier unprobed", () => {
 		expect(run({ tier: "trivial" }).probe.enabled).toBe(true);
 		// Nothing above `hard` to escalate into, so probing it would only add latency.

package/test/toast-logic.test.ts

@@ -7,8 +7,10 @@ import {
 	newestId,
 	providerOf,
 	resolveRouterUrl,
+	factsOf,
 	selectToasts,
 	toToastText,
+	whyReasons,
 	type ToastDecision,
 } from "../omp-extension/toast-logic.ts";
 
@@ -199,3 +201,62 @@ describe("toToastText", () => {
 		expect(providerOf("z-ai/glm-5.3-flash")).toEqual({ provider: "openrouter", model: "z-ai/glm-5.3-flash" });
 	});
 });
+
+describe("verbose toast", () => {
+	const FULL = dec({
+		slug: "ollama/gpt-oss:20b",
+		servedSlug: "ollama/gpt-oss:20b",
+		tier: "trivial",
+		reportedUsd: 0.000308,
+		reasons: [
+			"policy: pinned to ollama/gpt-oss:20b",
+			"completion budget raised 12 to 512: ollama/gpt-oss:20b reasons before it answers",
+			"cheapest above the quality floor",
+		],
+		features: { promptTokens: 22899, toolCount: 11, isToolResultContinuation: true },
+		attempt: 1,
+		promptTokensSaved: 12800,
+		ttftMs: 2100,
+	});
+
+	test("the headline keeps its shape and the body explains the choice", () => {
+		const lines = toToastText(FULL).split(String.fromCharCode(10));
+		expect(lines[0]).toBe("ollama · gpt-oss:20b [trivial] · $0.00031");
+		expect(lines[1]).toBe("why: policy: pinned to ollama/gpt-oss:20b");
+		expect(lines[2]).toContain("completion budget raised");
+		expect(lines[3]).toBe("22.9k prompt · 12.8k compacted · 11 tools · tool continuation · attempt 2 · 2.1s to first token");
+	});
+
+	test("compact is the old single line", () => {
+		expect(toToastText(FULL, false)).toBe("ollama · gpt-oss:20b [trivial] · $0.00031");
+		expect(toToastText(FULL, false).includes(String.fromCharCode(10))).toBe(false);
+	});
+
+	test("a surprise outranks ordinary ranking, and ranking shows when nothing surprised", () => {
+		// "cheapest above the quality floor" is ordinary: a failover and a hold win.
+		expect(whyReasons(["cheapest above the quality floor", "failover: x/y empty_completion; retrying a/b"])[0]).toContain("failover");
+		expect(whyReasons(["cheapest above the quality floor", "held from the previous turn: switch margin not cleared"])[0]).toContain("held");
+		// Nothing notable: the ranking rationale itself is the answer.
+		expect(whyReasons(["cheapest above the quality floor"])).toEqual(["cheapest above the quality floor"]);
+		expect(whyReasons([])).toEqual([]);
+		expect(whyReasons(undefined)).toEqual([]);
+		// At most two lines, however many reasons the router recorded.
+		expect(whyReasons(["failover: a", "policy: b", "held: c", "cache warm"]).length).toBe(2);
+	});
+
+	test("an unreported cost falls back to the prediction, and thin decisions stay short", () => {
+		expect(toToastText(dec({ reportedUsd: null, predictedUsd: 0.00042, reasons: [], features: null }))).toBe("openrouter · meta/muse-glimmer-30b [trivial] · ~$0.00042");
+		expect(toToastText(dec({ reportedUsd: null, features: null }))).toBe("openrouter · meta/muse-glimmer-30b [trivial]");
+	});
+
+	test("facts skip what a reader does not need", () => {
+		expect(factsOf(dec({ features: { promptTokens: 0, toolCount: 0 }, attempt: 0, task: "coding" }))).toEqual([]);
+		expect(factsOf(dec({ features: { promptTokens: 900 }, task: "vision" }))).toEqual(["900 prompt", "vision"]);
+	});
+
+	test("selectToasts renders compact when asked", () => {
+		const entries = [dec({ id: "d2", slug: "x/b", reasons: ["failover: nope"] }), dec({ id: "d1" })];
+		expect(selectToasts(entries, "d1", "", "", false)[0]?.text.includes(String.fromCharCode(10))).toBe(false);
+		expect(selectToasts(entries, "d1")[0]?.text.includes(String.fromCharCode(10))).toBe(true);
+	});
+});

package/test/turn.test.ts

@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",