one-code-extension 0.4.0 → 0.5.0

package/extensions/lib/model-pairings.ts

@@ -0,0 +1,152 @@
+/**
+ * The model pairing table (pure): for the models people run most, which model
+ * a session hands its subagents and its auto-mode classifier. Each row comes
+ * from measured data, not from tiers or price alone: Artificial Analysis's
+ * Intelligence Index (maximum effort for subagents; low effort for the
+ * classifier, which runs with thinking off) and list prices, with OpenRouter's
+ * usage rankings choosing which models get a row. The snapshot and the numbers
+ * behind every row are in `working-docs/decisions/model-policy.md` ("Model
+ * pairing table").
+ *
+ * A pick is the cheapest same-vendor model within 15 points at maximum effort
+ * (subagent) or 7 points at low effort (classifier); `"session"` keeps the
+ * session's own model, which also overrides the cost algorithm. A model the
+ * table does not name goes to the cost algorithm (`model-tier.ts`
+ * `sameTierContainedCandidates`).
+ *
+ * The table knows only what existed on PAIRINGS_AS_OF. When the session's
+ * provider serves a model of the session's vendor released after that date,
+ * the table is skipped for that vendor: a new model may change every pairing,
+ * and the algorithm judges it where the table cannot.
+ */
+
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { catalogModelFor } from "./model-catalog.ts";
+import { isAliasOrVariantId, isDatedDuplicate, modelsContainedToSession, pricedInput, supportsImageInput, vendorProfile } from "./model-policy.ts";
+import { isAutoSelectable, type ModelPrice, servedCatalogIds } from "./model-tier.ts";
+
+export type PairingRole = "subagent" | "classifier";
+
+interface PairingRow {
+	/** Session models, as catalog ids, all of one vendor. */
+	sessions: readonly string[];
+	/** A catalog id (`vendor/id`), or SESSION for the session's own model. */
+	subagent: string;
+	classifier: string;
+}
+
+/** The data date: Artificial Analysis and OpenRouter rankings, 2026-10-13. */
+export const PAIRINGS_AS_OF = "2026-10-13";
+
+const SESSION = "session";
+
+export const PAIRING_TABLE: readonly PairingRow[] = [
+	// Anthropic. Sonnet 5.5 is within 2 points of Opus 5.5 at half the price and above Fable 5.1.
+	{
+		sessions: ["anthropic/claude-opus-5-5", "anthropic/claude-opus-5", "anthropic/claude-opus-4-8", "anthropic/claude-fable-5", "anthropic/claude-fable-5-1"],
+		subagent: "anthropic/claude-sonnet-5-5",
+		classifier: "anthropic/claude-sonnet-5-5",
+	},
+	{ sessions: ["anthropic/claude-sonnet-5-5", "anthropic/claude-sonnet-5"], subagent: "anthropic/claude-haiku-5-5", classifier: "anthropic/claude-haiku-5-5" },
+	{ sessions: ["anthropic/claude-haiku-5-5"], subagent: SESSION, classifier: SESSION },
+	// OpenAI. GPT-6.1 Sol is within a point of Astra at a fifth of the price; Luna drops 20 points at low effort.
+	{ sessions: ["openai/gpt-6-astra"], subagent: "openai/gpt-6.1-sol", classifier: "openai/gpt-6.1-sol" },
+	{ sessions: ["openai/gpt-6.1-sol", "openai/gpt-6-sol"], subagent: "openai/gpt-6-luna", classifier: SESSION },
+	{ sessions: ["openai/gpt-5.6-sol"], subagent: "openai/gpt-6.1-sol", classifier: "openai/gpt-6.1-sol" },
+	{ sessions: ["openai/gpt-5.6-terra", "openai/gpt-5.6-luna"], subagent: "openai/gpt-6-luna", classifier: "openai/gpt-6-luna" },
+	{ sessions: ["openai/gpt-6-luna"], subagent: SESSION, classifier: SESSION },
+	// Google. Gemini 3.8 Flash outscores 3.1 Pro; Argon's classifier pick is the user's call (2026-10-13).
+	{
+		sessions: ["google/gemini-4-argon", "google/gemini-3.1-pro-preview", "google/gemini-3.7-flash", "google/gemini-3.6-flash", "google/gemini-3.5-flash"],
+		subagent: "google/gemini-3.8-flash",
+		classifier: "google/gemini-3.8-flash",
+	},
+	{ sessions: ["google/gemini-3.8-flash"], subagent: SESSION, classifier: SESSION },
+	// DeepSeek. V4.1 Flash outscores V4 Pro at under a quarter of its price.
+	{
+		sessions: ["deepseek/deepseek-v4-pro", "deepseek/deepseek-v4-pro-0813", "deepseek/deepseek-v4-flash", "deepseek/deepseek-v4-flash-0731"],
+		subagent: "deepseek/deepseek-v4.1-flash",
+		classifier: "deepseek/deepseek-v4.1-flash",
+	},
+	{ sessions: ["deepseek/deepseek-v4.1-flash"], subagent: SESSION, classifier: SESSION },
+	// Z.ai, Xiaomi, Qwen: each vendor's flash model.
+	{ sessions: ["zhipuai/glm-5.3"], subagent: "zhipuai/glm-5.3-flash", classifier: "zhipuai/glm-5.3-flash" },
+	{ sessions: ["zhipuai/glm-5.3-flash"], subagent: SESSION, classifier: SESSION },
+	{ sessions: ["xiaomi/mimo-v2.6-pro"], subagent: "xiaomi/mimo-v2.6-flash", classifier: SESSION },
+	{ sessions: ["xiaomi/mimo-v2.6-flash"], subagent: SESSION, classifier: SESSION },
+	{ sessions: ["alibaba/qwen3.8-max", "alibaba/qwen3.8-max-0902"], subagent: "alibaba/qwen3.8-flash", classifier: "alibaba/qwen3.8-flash" },
+	{ sessions: ["alibaba/qwen3.8-flash"], subagent: SESSION, classifier: SESSION },
+	// No same-vendor model within 15 points: the session model serves both roles.
+	{ sessions: ["moonshotai/kimi-k3"], subagent: SESSION, classifier: SESSION },
+	{ sessions: ["xai/grok-4.7"], subagent: SESSION, classifier: SESSION },
+	{ sessions: ["meta/muse-spark-1.3"], subagent: SESSION, classifier: SESSION },
+	{ sessions: ["minimax/MiniMax-M3"], subagent: SESSION, classifier: SESSION },
+	{ sessions: ["stepfun/step-5-preview"], subagent: SESSION, classifier: SESSION },
+	{ sessions: ["mistral/mistral-large-4"], subagent: SESSION, classifier: SESSION },
+];
+
+const ROW_BY_SESSION: ReadonlyMap<string, PairingRow> = new Map(PAIRING_TABLE.flatMap((row) => row.sessions.map((id) => [id.toLowerCase(), row] as const)));
+const AS_OF_TIME = Date.parse(`${PAIRINGS_AS_OF}T23:59:59Z`);
+
+export type Pairing = { kind: "session" } | { kind: "model"; model: Model<Api> };
+
+/**
+ * The table's pick for `role` on `sessionModel`, or undefined when the table
+ * does not decide: no row names the session model, the session's provider
+ * serves a model of its vendor released after PAIRINGS_AS_OF, or no model in
+ * the session's contained pool serves the pick, costs no more than the
+ * session model on that route, and passes the caller's gates
+ * (`requireImageInput`, and `accept`: the classifier's context window). The
+ * caller then runs the cost algorithm.
+ *
+ * Both checks read the pool the cost algorithm starts from (no dated
+ * duplicates, only auto-selectable models) but need no price: the table's
+ * picks are measured, so they hold on a route with no list prices. Where both
+ * are priced, a pick dearer than the session is skipped: a route can price an
+ * older model below its successor (OpenRouter's DeepSeek V4 Flash), and an
+ * automatic pick never costs more than the session (`price`, list input by
+ * default; the classifier passes its per-call price).
+ */
+export function pairedModel(
+	role: PairingRole,
+	available: Model<Api>[],
+	sessionModel: Model<Api>,
+	opts: { contained?: Model<Api>[]; requireImageInput?: boolean; price?: ModelPrice; accept?: (model: Model<Api>) => boolean } = {},
+): Pairing | undefined {
+	const sessionEntry = catalogModelFor(sessionModel);
+	const row = sessionEntry && ROW_BY_SESSION.get(sessionEntry.id.toLowerCase());
+	if (!sessionEntry || !row) return undefined;
+	const pool = opts.contained ?? modelsContainedToSession(available, sessionModel);
+	const served = servedCatalogIds(pool);
+	const selectable = pool.filter((model) => isAutoSelectable(model, served));
+	// The table predates this vendor's newest model: it no longer speaks for the
+	// vendor. A new dated snapshot counts, even beside the undated alias.
+	const vendor = vendorProfile(sessionEntry.vendor);
+	const newer = selectable.some((model) => {
+		const entry = catalogModelFor(model);
+		return entry !== undefined && vendorProfile(entry.vendor) === vendor && entry.released !== undefined && entry.released > AS_OF_TIME;
+	});
+	if (newer) return undefined;
+	const usable = selectable.filter((model) => !isDatedDuplicate(model, pool));
+	const pick = row[role];
+	if (pick === SESSION) return { kind: "session" };
+	const wanted = pick.toLowerCase();
+	const accept = opts.accept ?? (() => true);
+	const priceOf = opts.price ?? pricedInput;
+	const sessionPrice = priceOf(sessionModel);
+	const notDearer = (model: Model<Api>) => {
+		const price = priceOf(model);
+		return sessionPrice === undefined || price === undefined || price <= sessionPrice;
+	};
+	const serving = usable
+		.filter(
+			(model) =>
+				catalogModelFor(model)?.id.toLowerCase() === wanted &&
+				(!opts.requireImageInput || supportsImageInput(model)) &&
+				notDearer(model) &&
+				accept(model),
+		)
+		// A plain row before a gateway variant (`…:batch`) of the same model.
+		.sort((a, b) => Number(isAliasOrVariantId(a.id)) - Number(isAliasOrVariantId(b.id)) || a.id.length - b.id.length);
+	return serving[0] ? { kind: "model", model: serving[0] } : undefined;
+}

package/extensions/{auto-mode → lib}/model-picker.ts

@@ -1,21 +1,12 @@
 /**
- * The `/auto-mode model` picker (pure).
+ * Shared interactive model picker (pure).
  *
- * Filtering, key decoding, selection movement, and rendering for the
- * interactive classifier-model picker, kept free of pi imports so they are
- * unit-testable. The thin `ctx.ui.custom` component in the permissions
- * extension owns nothing but mutable state and repaint calls.
- *
- * A picker exists because the alternative was worse in practice: choosing the
- * classifier automatically took three rounds of fault-fixing against real
- * catalogs, and when auto-selection picks badly the only recourse was
- * hand-editing settings.json with a model id the user has to guess. Naming a
- * model here is the explicit consent `autoMode.classifierModel` stands for —
- * including consent to another provider, which auto-selection must never
- * assume (see model-select.ts).
+ * Filtering, key decoding, selection movement, and rendering stay free of pi
+ * imports so command wiring can own only mutable state and repaint calls.
  */
 
-import { truncateLine } from "../lib/tui-render.ts";
+import { truncateLine } from "./tui-render.ts";
+import { keyId, keyText } from "./key-input.ts";
 
 export interface PickerEntry {
 	provider: string;
@@ -68,26 +59,23 @@ export type PickerKey =
  * shortcuts: every printable character belongs to the filter query.
  */
 export function decodePickerKey(data: string): PickerKey | undefined {
-	switch (data) {
-		case "\x1b[A":
-		case "\x1bOA":
+	switch (keyId(data)) {
+		case "up":
 			return { kind: "up" };
-		case "\x1b[B":
-		case "\x1bOB":
+		case "down":
 			return { kind: "down" };
-		case "\r":
-		case "\n":
+		case "enter":
 			return { kind: "confirm" };
-		case "\x1b":
-		case "\x03": // ctrl+c — same intent as escape while the picker is focused
+		case "escape":
+		case "ctrl+c": // same intent as escape while the picker is focused
 			return { kind: "cancel" };
-		case "\x7f":
-		case "\b":
+		case "backspace":
+		case "ctrl+backspace":
 			return { kind: "backspace" };
 		default: {
-			// Printable text only (covers paste); control sequences are ignored.
-			const text = [...data].filter((char) => char >= " " && char !== "\x7f").join("");
-			return text.length > 0 && !data.startsWith("\x1b") ? { kind: "type", text } : undefined;
+			// Printable text only (covers paste); control sequences type nothing.
+			const text = keyText(data);
+			return text ? { kind: "type", text } : undefined;
 		}
 	}
 }
@@ -109,9 +97,9 @@ export interface PickerView {
 	/** The currently configured spec, marked in the listing. */
 	current?: string;
 	maxVisible?: number;
-	/** Picker header; defaults to the auto-mode classifier copy. */
-	title?: string;
-	subtitle?: string;
+	/** Picker header and explanatory subtitle. */
+	title: string;
+	subtitle: string;
 }
 
 const formatPrice = (price?: number): string => (price === undefined ? "" : `$${price}/M in`);
@@ -130,15 +118,13 @@ export function toPickerEntries(models: { provider: string; id: string; cost?: {
 export interface PickerComponentOptions {
 	entries: PickerEntry[];
 	current?: string;
-	title?: string;
-	subtitle?: string;
+	title: string;
+	subtitle: string;
 }
 
 /**
- * The `ctx.ui.custom` component behind `/auto-mode model` and `/subagent`:
- * filter-as-you-type over the entries, enter confirms, esc cancels. Kept here
- * (structurally typed, no pi imports) so both commands share one keyboard
- * loop instead of drifting copies.
+ * A `ctx.ui.custom` model picker: filter-as-you-type over the entries, enter
+ * confirms, esc cancels. Kept here with no pi imports.
  */
 export function modelPickerComponent(
 	options: PickerComponentOptions,
@@ -191,7 +177,7 @@ export function modelPickerComponent(
 			if (key.kind === "cancel") return done(null);
 			if (key.kind === "confirm") return done(filtered[index] ?? null);
 			if (key.kind === "up") index = Math.max(0, index - 1);
-			else if (key.kind === "down") index = Math.min(filtered.length - 1, index + 1);
+			else if (key.kind === "down") index = Math.max(0, Math.min(filtered.length - 1, index + 1));
 			else {
 				query = key.kind === "backspace" ? query.slice(0, -1) : query + key.text;
 				filtered = filterEntries(options.entries, query);
@@ -208,9 +194,6 @@ export function modelPickerComponent(
 
 /** Key hint, kept on its own line so it survives at narrow widths. */
 const PICKER_HINT = "type to filter · ↑/↓ · enter · esc";
-/** Default privacy note for the classifier picker (the key hint rides its own line below). */
-const CLASSIFIER_SUBTITLE = "It reads your prompts and CLAUDE.md — picking another provider sends them there.";
-
 export function renderModelPicker(view: PickerView, paint: Paint, width = Infinity): string[] {
 	const maxVisible = view.maxVisible ?? 10;
 	// Every line is cut to `width` — pi-tui crashes the whole app on a rendered
@@ -218,8 +201,8 @@ export function renderModelPicker(view: PickerView, paint: Paint, width = Infini
 	// lines uncut (truncateLine returns them unchanged) for unit tests.
 	const cut = (line: string): string => truncateLine(line, width);
 	const lines: string[] = [];
-	lines.push(cut(paint("accent", view.title ?? "Select the auto-mode classifier model")));
-	lines.push(cut(paint("dim", view.subtitle ?? CLASSIFIER_SUBTITLE)));
+	lines.push(cut(paint("accent", view.title)));
+	lines.push(cut(paint("dim", view.subtitle)));
 	// The key hint is always its own line, so a narrow terminal never clips the
 	// only place the keys are documented.
 	lines.push(cut(paint("dim", `  ${PICKER_HINT}`)));

package/extensions/lib/model-policy.ts

@@ -18,7 +18,7 @@ export function isClaudeFamilyModel(model: { provider: string; id: string }): bo
  * subagent opens either. A model whose modality is unknown (undefined `input`, as
  * on some opaque/self-hosted providers, or a minimal test stub, or no model at all) reads as
  * text-only here — the safe direction for a gate that only ever ADDS a
- * requirement, never relaxes one. See `docs/decisions/model-policy.md`.
+ * requirement, never relaxes one. See `working-docs/decisions/model-policy.md`.
  */
 export function supportsImageInput(model: { input?: readonly string[] } | undefined): boolean {
 	return Array.isArray(model?.input) && model.input.includes("image");
@@ -30,6 +30,8 @@ export interface ProviderPolicy {
 	kind: ProviderPolicyKind;
 	/** Fixed profile for direct vendors and stable hosted catalogs. */
 	profile?: string;
+	/** The provider also serves other vendors' models: a row whose id names its vendor takes that vendor's profile. */
+	profileFromId?: boolean;
 }
 
 const direct = (profile: string): ProviderPolicy => ({ kind: "direct", profile });
@@ -38,7 +40,9 @@ const gateway = (): ProviderPolicy => ({ kind: "gateway" });
 const opaque = (): ProviderPolicy => ({ kind: "opaque" });
 
 /**
- * Every built-in language-model provider in pi 0.84.0. Unknown/custom providers
+ * Every built-in language-model provider in pi 1.1.0 (`model-policy.test.ts`
+ * checks the list against pi's own), plus the names older pi still in the
+ * tested range uses. Unknown/custom providers
  * get the opaque policy below, so a pi upgrade fails safe rather than widening
  * automatic routing.
  */
@@ -49,6 +53,9 @@ export const BUILTIN_PROVIDER_POLICIES: Readonly<Record<string, ProviderPolicy>>
 	google: direct("google"),
 	"google-vertex": direct("google"),
 	openai: direct("openai"),
+	// Also serves Foundry models from other vendors (`deepseek-v4-pro`).
+	azure: { ...direct("openai"), profileFromId: true },
+	// pi before 1.0.3 named `azure` this way.
 	"azure-openai-responses": direct("openai"),
 	"openai-codex": direct("openai"),
 	radius: opaque(),
@@ -78,6 +85,8 @@ export const BUILTIN_PROVIDER_POLICIES: Readonly<Record<string, ProviderPolicy>>
 	"cloudflare-ai-gateway": gateway(),
 	"qwen-token-plan": hosted("host:qwen-plan"),
 	"qwen-token-plan-cn": hosted("host:qwen-plan"),
+	"qwen-token-plan-individual": hosted("host:qwen-plan"),
+	meta: direct("meta"),
 	xiaomi: direct("xiaomi"),
 	"xiaomi-token-plan-cn": direct("xiaomi"),
 	"xiaomi-token-plan-ams": direct("xiaomi"),
@@ -95,6 +104,7 @@ const VENDOR_ALIASES: Readonly<Record<string, string>> = {
 	deepseek: "deepseek",
 	zai: "zai",
 	"z-ai": "zai",
+	zhipuai: "zai",
 	qwen: "host:qwen-plan",
 	alibaba: "host:qwen-plan",
 	moonshotai: "moonshot",
@@ -115,12 +125,21 @@ export interface ModelIdentity {
 	confidence: "exact" | "family" | "opaque";
 }
 
-const providerPolicy = (provider: string): ProviderPolicy => BUILTIN_PROVIDER_POLICIES[provider] ?? opaque();
+export const providerPolicy = (provider: string): ProviderPolicy => BUILTIN_PROVIDER_POLICIES[provider] ?? opaque();
 
 function canonicalVendor(value: string): string | undefined {
 	return VENDOR_ALIASES[value.toLowerCase()];
 }
 
+/**
+ * The identity profile a catalog vendor name stands for (`z-ai`, `zhipuai` and
+ * `zai` are one vendor), else the name itself: the key `model-catalog.ts`
+ * matches a row to its vendor's model under.
+ */
+export function vendorProfile(vendor: string): string {
+	return canonicalVendor(vendor) ?? vendor.toLowerCase();
+}
+
 function prefixedIdentity(model: Model<Api>, prefix: string): ModelIdentity {
 	const raw = model.id.startsWith("~") ? model.id.slice(1) : model.id;
 	const slash = raw.indexOf("/");
@@ -153,8 +172,13 @@ function bareFamily(id: string): string | undefined {
 }
 
 function bedrockIdentity(model: Model<Api>): ModelIdentity {
-	const geography = model.id.match(/^(us|eu|apac|au|global)\./i)?.[1]?.toLowerCase() ?? "in-region";
-	const raw = model.id.replace(/^(?:us|eu|apac|au|global)\./i, "");
+	// A cross-region inference profile prefixes the vendor with its geography
+	// (`us.`, `jp.`, `us-gov.`, …): a first segment that is not a vendor, followed
+	// by one that is. Reading it that way needs no list of AWS region codes.
+	const [first, second] = model.id.split(".");
+	const regional = second !== undefined && !canonicalVendor(first) && canonicalVendor(second) !== undefined;
+	const geography = regional ? first.toLowerCase() : "in-region";
+	const raw = regional ? model.id.slice(first.length + 1) : model.id;
 	const dot = raw.indexOf(".");
 	if (dot <= 0 || raw.startsWith("arn:")) {
 		return { containment: `${model.provider}:opaque:${model.id}`, normalizedId: model.id, confidence: "opaque" };
@@ -209,7 +233,7 @@ export function modelIdentity(model: Model<Api>): ModelIdentity {
 	}
 	return {
 		containment: model.provider,
-		profile: policy.profile,
+		profile: (policy.profileFromId && bareFamily(model.id)) || policy.profile,
 		normalizedId: model.id,
 		confidence: "exact",
 	};
@@ -219,8 +243,8 @@ const UNSUITABLE_VARIANT = /:(batch|free|online|thinking)$/i;
 
 /**
  * The id without OpenRouter's `~` redirect-alias marker and without a
- * `:batch`-style endpoint variant — the spelling the name rules, the facts
- * table and the capability index all key on (`~deepseek/deepseek-v4-flash-latest`
+ * `:batch`-style endpoint variant — the spelling the model-catalog lookups key
+ * on (`~deepseek/deepseek-v4-flash-latest`
  * → `deepseek/deepseek-v4-flash-latest`, `gpt-5-mini:batch` → `gpt-5-mini`).
  */
 export function baseModelId(id: string): string {
@@ -237,20 +261,88 @@ export function isAliasOrVariantId(id: string): boolean {
  * and OpenRouter's `~vendor/family-latest` redirect aliases ("always redirects to
  * the latest model in the family"): the model behind one moves without notice,
  * so it has no stable identity to tier, date or price — and the classifier is a
- * permission boundary. The alias stays available by hand (/model, an explicit
- * `subagentModel` / `classifierModel` setting).
+ * permission boundary. The alias stays available by hand through `/model` or
+ * an explicit `subagentModel` setting.
  */
 export function isSelectableVariant(model: Model<Api>): boolean {
 	return !UNSUITABLE_VARIANT.test(model.id) && !model.id.startsWith("~");
 }
 
-/** One day in milliseconds, for the release-date arithmetic in model-facts.ts and capability-index.ts. */
+/**
+ * A moving alias: an id that names whichever model its vendor points it at
+ * today (`mistral-large-latest`, `gpt-daybreak-blue-latest`, OpenRouter's
+ * `~vendor/…-latest` redirects). What answers can change without notice, so
+ * it never supersedes a dated model, is never suggested as an upgrade, and is
+ * never picked as the auto-mode classifier (a permission boundary). Other
+ * automatic picks may still use one: Mistral serves most models only so.
+ */
+export function isMovingAlias(id: string): boolean {
+	return id.startsWith("~") || /-latest(?=$|[-:@])/i.test(id);
+}
+
+/**
+ * An experimental build (`deepseek-v4-flash-vision-exp`, `tev1-4b-experimental`):
+ * a research variant, never picked automatically (as a screener or the
+ * subagent default) or suggested as an upgrade. `preview` is deliberately not matched: Google ships mainline
+ * Gemini models under it (`gemini-3-flash-preview`).
+ */
+export function isExperimentalBuild(id: string): boolean {
+	return /-exp(?:$|[-:])|experimental/i.test(id);
+}
+
+/** A positive finite catalog context window, the only value safe to compare windows by. */
+export function hasCatalogContextWindow(model: { contextWindow?: number }): model is { contextWindow: number } {
+	return Number.isFinite(model.contextWindow) && (model.contextWindow as number) > 0;
+}
+
+/** One day in milliseconds, for the release-date arithmetic in model-catalog.ts. */
 export const DAY_MS = 86_400_000;
 
-/** Non-positive values are catalog sentinels/unpriced, not evidence of being free. */
+/** A catalog price, or undefined: non-positive values are sentinels/unpriced, not evidence of being free. */
+function catalogPrice(value: number | undefined): number | undefined {
+	return typeof value === "number" && value > 0 ? value : undefined;
+}
+
+/** The model's list input price, or undefined when it is unpriced. */
 export function pricedInput(model: Model<Api>): number | undefined {
-	const input = model.cost?.input;
-	return typeof input === "number" && input > 0 ? input : undefined;
+	return catalogPrice(model.cost?.input);
+}
+
+/** A classifier call's measured shape: the cached ruleset and transcript, the new turn, the verdict. */
+export const CLASSIFIER_CALL_TOKENS = { cachedInput: 28_000, freshInput: 2_000, output: 700 } as const;
+
+/**
+ * One classifier call's estimated cost in dollars at `CLASSIFIER_CALL_TOKENS`,
+ * or undefined for a model with no input price. A model without a cache-read
+ * price pays its input price for the cached part, and one without an output
+ * price its input price for the verdict: both overstate, never understate.
+ */
+export function classifierCallCost(model: Model<Api>): number | undefined {
+	const input = pricedInput(model);
+	if (input === undefined) return undefined;
+	const priced = (value: number | undefined) => catalogPrice(value) ?? input;
+	const { cachedInput, freshInput, output } = CLASSIFIER_CALL_TOKENS;
+	return (priced(model.cost?.cacheRead) * cachedInput + input * freshInput + priced(model.cost?.output) * output) / 1_000_000;
+}
+
+/**
+ * How classifier candidates are priced against `base` (the session model):
+ * per classifier call, unless `base` lists no cache-read price. Then its
+ * per-call cost would be overstated (a quarter of OpenRouter's priced models
+ * list none) and a dearer model could win, so both sides compare by list
+ * input price. The selector and the cost warnings share this, so "cheaper per
+ * call" means one thing everywhere.
+ */
+export function classifierPrice(base: Model<Api>): (model: Model<Api>) => number | undefined {
+	return catalogPrice(base.cost?.cacheRead) === undefined ? pricedInput : classifierCallCost;
+}
+
+/** How many times `model`'s classifier call costs `base`'s (priced by `classifierPrice(base)`), or undefined when either price is unknown. */
+export function classifierCostRatio(model: Model<Api>, base: Model<Api>): number | undefined {
+	const price = classifierPrice(base);
+	const cost = price(model);
+	const baseCost = price(base);
+	return cost !== undefined && baseCost !== undefined && baseCost > 0 ? cost / baseCost : undefined;
 }
 
 /** A dated snapshot id (`claude-haiku-4-5-20251001`): the trailing `-YYYYMMDD` marks a pinned alias of an undated model. */
@@ -339,7 +431,12 @@ export function forcedReasoningLevel(model: Model<Api>): ThinkingLevel | undefin
  * A false positive only costs one retry with minimal thinking.
  */
 export function isReasoningMandatoryError(message: string): boolean {
-	return /(reasoning|thinking)[^.]*\b(mandatory|cannot be disabled|can't be disabled|must be enabled|is required)\b/i.test(message);
+	return (
+		/(reasoning|thinking)[^.]*\b(mandatory|cannot be disabled|can't be disabled|must be enabled|is required)\b/i.test(message) ||
+		// Anthropic's: Opus 5.5 ("\"thinking.type.disabled\" is not supported for this model")
+		// and Sonnet 5.5 ("To turn thinking off on this model, send … between_tools"), findings §43.
+		/thinking\.type\.disabled\W+is not supported|to turn thinking off on this model/i.test(message)
+	);
 }
 
 /** The level to retry with after isReasoningMandatoryError: the lowest real level the model supports. */