auto-model-router 0.3.4 → 0.4.0

package/src/server/turn.ts

@@ -27,6 +27,7 @@ import {
 	type Tier,
 } from "../router/types.ts";
 import { UpstreamError, type Dispatch, type UpstreamClient } from "../upstream/types.ts";
+import type { SessionOverrides } from "./overrides.ts";
 import { createLogger } from "../util/log.ts";
 import type { NormRequest, ResponseSink, TurnSummary, UpstreamChunk } from "../wire/types.ts";
 
@@ -66,6 +67,10 @@ export interface TurnDeps {
 	catalog: CatalogSource;
 	/** agentdox bridge. The disabled bridge makes every call here a no-op. */
 	context: ContextBridge;
+	/** Per-session pin/tier overrides from omp. Absent ⇒ none. */
+	overrides?: SessionOverrides;
+	/** Ledger-vs-meter calibration for Ollama's estimated costs; absent ⇒ 1. */
+	ollamaCostScale?: () => number;
 }
 
 /** A dead client connection surfaces as the sink throwing mid-stream. */
@@ -117,6 +122,9 @@ export async function runTurn(
 	else triggers.delete("length_stop");
 
 	const maxAttempts = Math.max(1, config.escalation.maxAttempts);
+	// A session override applies to the first attempt only: an escalation or
+	// failover after it is the router's business, not the pin's.
+	const override = deps.overrides?.get(req.ompSessionId) ?? null;
 	let escalateFrom: Tier | undefined;
 	let escalations = 0;
 	// Slugs that returned a retryable upstream error on THIS turn, fed back
@@ -138,9 +146,13 @@ export async function runTurn(
 			pendingDecision = null;
 		} else {
 			try {
-				const opts: { attempt: number; escalateFrom?: Tier; excludeSlugs?: readonly string[] } = { attempt };
+				const opts: { attempt: number; escalateFrom?: Tier; excludeSlugs?: readonly string[]; forceTier?: Tier; forceSlug?: string } = { attempt };
 				if (escalateFrom !== undefined) opts.escalateFrom = escalateFrom;
 				if (failedSlugs.length > 0) opts.excludeSlugs = failedSlugs;
+				if (override !== null && attempt === 0) {
+					if (override.tier !== null) opts.forceTier = override.tier;
+					if (override.slug !== null) opts.forceSlug = override.slug;
+				}
 				decision = await router.route(req, opts);
 			} catch (err) {
 				await sink.error({ status: 500, code: "router_error", message: err instanceof Error ? err.message : String(err) });
@@ -480,6 +492,8 @@ export async function runTurn(
 					});
 				}
 				reportedUsd = computeCost(served, usage).total;
+				// Scale the estimate to what the plan meter has been billing for it.
+				if (served.provider === "ollama") reportedUsd *= deps.ollamaCostScale?.() ?? 1;
 			}
 		}
 
@@ -538,6 +552,7 @@ export async function runTurn(
 
 		state.turn = turnNumber;
 		state.currentSlug = servedSlug ?? decision.slug;
+		if (override !== null) deps.overrides?.consume(req.ompSessionId);
 		// Capture the previously-served tier BEFORE overwriting it, so the
 		// hysteresis re-arm below can tell whether this turn changed tier.
 		const prevTier = state.currentTier;

package/src/upstream/ollama-usage.ts

@@ -24,6 +24,7 @@
  * percents) rather than 100%, which errs toward keeping the bias on.
  */
 
+import type { Database } from "bun:sqlite";
 import type { Logger } from "../util/log.ts";
 
 export interface OllamaUsage {
@@ -96,20 +97,94 @@ export function parseOllamaUsage(json: unknown, nowMs = Date.now()): OllamaUsage
 
 export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
 
+/** One reading of the plan meter beside the ledger's own Ollama total. */
+export interface MeterSample {
+	atMs: number;
+	meterUsd: number;
+	ledgerUsd: number;
+}
+
+/** How the ledger's Ollama estimate compares with what ollama.com metered over the same span. */
+export interface OllamaCalibration {
+	/** metered ÷ ledger over the span, clamped to [0.5, 2]. Multiply estimates by it. */
+	factor: number;
+	meterDeltaUsd: number;
+	ledgerDeltaUsd: number;
+	spanHours: number;
+	samples: number;
+}
+
+/** Bounds on the span a calibration may rest on: the meter moves in $0.06 steps on Pro, so a tiny span is noise. */
+const CALIBRATION_MIN_LEDGER_USD = 0.5;
+const CALIBRATION_MIN_METER_USD = 0.06;
+export const CALIBRATION_MIN_FACTOR = 0.5;
+export const CALIBRATION_MAX_FACTOR = 2;
+
+/**
+ * The calibration from samples ordered oldest→newest. Walks back from the
+ * newest reading while the meter is non-decreasing (a drop is a billing-cycle
+ * reset), then compares the two ends. Null until the span carries enough
+ * spend to mean anything.
+ */
+export function calibrationFrom(samples: readonly MeterSample[]): OllamaCalibration | null {
+	if (samples.length < 2) return null;
+	const newest = samples[samples.length - 1]!;
+	let oldest = newest;
+	let n = 1;
+	for (let i = samples.length - 2; i >= 0; i--) {
+		const s = samples[i]!;
+		if (s.meterUsd > oldest.meterUsd || s.ledgerUsd > oldest.ledgerUsd) break; // reset (meter) or a ledger purge
+		oldest = s;
+		n++;
+	}
+	const meterDeltaUsd = newest.meterUsd - oldest.meterUsd;
+	const ledgerDeltaUsd = newest.ledgerUsd - oldest.ledgerUsd;
+	if (ledgerDeltaUsd < CALIBRATION_MIN_LEDGER_USD || meterDeltaUsd < CALIBRATION_MIN_METER_USD) return null;
+	const factor = Math.min(CALIBRATION_MAX_FACTOR, Math.max(CALIBRATION_MIN_FACTOR, meterDeltaUsd / ledgerDeltaUsd));
+	return { factor, meterDeltaUsd, ledgerDeltaUsd, spanHours: (newest.atMs - oldest.atMs) / 3_600_000, samples: n };
+}
+
 export interface OllamaUsageSource {
 	/** Latest usage, refreshed when older than the poll interval; last good value on failure. */
 	get(): Promise<OllamaUsage | null>;
 	/** Last fetched value without touching the network. */
 	peek(): OllamaUsage | null;
+	/** Ledger-vs-meter calibration, when enough metered spend has accrued. */
+	calibration(): OllamaCalibration | null;
 }
 
 /** Inert source for setups with no key (the daemon path without `/login ollama-cloud`). */
-export const NO_USAGE: OllamaUsageSource = { get: async () => null, peek: () => null };
+export const NO_USAGE: OllamaUsageSource = { get: async () => null, peek: () => null, calibration: () => null };
+
+/** Where calibration samples come from and go: the ledger's Ollama total and the plan's credits. */
+export interface CalibrationDeps {
+	db: Database;
+	/** The ledger's all-time Ollama spend, read at sampling time. */
+	ledgerUsd(): number;
+	/** Configured credit override (0 = detect from the plan). */
+	planCreditsOverrideUsd: number;
+}
 
 export function createOllamaUsageSource(
-	opts: { apiKey: string; pollMs: number; timeoutMs: number; log: Logger; fetchImpl?: FetchLike; root?: string },
+	opts: { apiKey: string; pollMs: number; timeoutMs: number; log: Logger; fetchImpl?: FetchLike; root?: string; calibration?: CalibrationDeps },
 ): OllamaUsageSource {
 	if (opts.apiKey === "" || opts.pollMs <= 0) return NO_USAGE;
+	const cal = opts.calibration;
+	const insertSample = cal === undefined ? null : cal.db.query("INSERT OR REPLACE INTO ollama_meter_samples (at_ms, meter_usd, ledger_usd) VALUES (?, ?, ?)");
+	const readSamples = cal === undefined ? null : cal.db.query("SELECT at_ms, meter_usd, ledger_usd FROM ollama_meter_samples WHERE at_ms >= ? ORDER BY at_ms ASC");
+	let calibrationMemo: OllamaCalibration | null = null;
+	function sample(usage: OllamaUsage): void {
+		if (cal === null || cal === undefined || insertSample === null || readSamples === null) return;
+		const credits = ollamaPlanCredits(usage, cal.planCreditsOverrideUsd);
+		if (credits === null || usage.monthlyUsedFraction === null) return;
+		try {
+			insertSample.run(usage.fetchedAtMs, usage.monthlyUsedFraction * credits, cal.ledgerUsd());
+			const rows = readSamples.all(usage.fetchedAtMs - 30 * 86_400_000) as { at_ms: number; meter_usd: number; ledger_usd: number }[];
+			calibrationMemo = calibrationFrom(rows.map((r) => ({ atMs: r.at_ms, meterUsd: r.meter_usd, ledgerUsd: r.ledger_usd })));
+		} catch (err) {
+			opts.log.debug("ollama calibration sample failed", { error: err instanceof Error ? err.message : String(err) });
+		}
+	}
 	const fetchImpl = opts.fetchImpl ?? fetch;
 	const root = (opts.root ?? "https://ollama.com").replace(/\/+$/, "");
 	let current: OllamaUsage | null = null;
@@ -155,6 +230,7 @@ export function createOllamaUsageSource(
 				if (parsed !== null) {
 					current = { ...parsed, plan };
 					warned = false;
+					sample(current);
 				} else if (!warned) {
 					warned = true;
 					opts.log.warn("ollama usage payload had no recognisable fields; credit-aware bias stays on its last reading");
@@ -184,6 +260,7 @@ export function createOllamaUsageSource(
 			return inflight;
 		},
 		peek: () => current,
+		calibration: () => calibrationMemo,
 	};
 }
 

package/src/util/sqlite.ts

@@ -29,6 +29,14 @@ CREATE TABLE IF NOT EXISTS catalog_cache (
   key_scoped INTEGER NOT NULL DEFAULT 0
 );
 
+-- Last built Ollama Cloud model set, so a restart routes from disk and
+-- offline tools (tools/replay.ts) see the same composite catalog the router did.
+CREATE TABLE IF NOT EXISTS ollama_catalog_cache (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  payload TEXT NOT NULL,
+  fetched_at_ms INTEGER NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS benchmark_cache (
   id INTEGER PRIMARY KEY CHECK (id = 1),
   payload TEXT NOT NULL,
@@ -111,6 +119,28 @@ CREATE TABLE IF NOT EXISTS context_blocks (
   fetched_at_ms INTEGER NOT NULL
 );
 
+-- ollama.com plan-meter readings beside the ledger's own Ollama total at the
+-- same instant, so the ledger's estimate can be calibrated against the bill.
+CREATE TABLE IF NOT EXISTS ollama_meter_samples (
+  at_ms INTEGER PRIMARY KEY,
+  meter_usd REAL NOT NULL,
+  ledger_usd REAL NOT NULL
+);
+
+-- User verdicts on routed turns (/router feedback), tied to the ledger row judged.
+CREATE TABLE IF NOT EXISTS feedback (
+  id TEXT PRIMARY KEY,
+  ledger_id TEXT NOT NULL,
+  omp_session_id TEXT NOT NULL DEFAULT '',
+  slug TEXT NOT NULL,
+  tier TEXT NOT NULL,
+  verdict TEXT NOT NULL,
+  note TEXT NOT NULL DEFAULT '',
+  created_at_ms INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_feedback_created ON feedback (created_at_ms);
+CREATE INDEX IF NOT EXISTS idx_feedback_ledger ON feedback (ledger_id);
+
 CREATE TABLE IF NOT EXISTS agentdox_sessions (
   conversation_key TEXT PRIMARY KEY,
   scope TEXT NOT NULL,

package/test/config-wizard.test.ts

@@ -166,7 +166,7 @@ describe("WIZARD_SECTIONS coverage", () => {
 		// they are listed here so a typo in a new field path fails loudly.
 		const KNOWN_OPTIONAL = new Set([
 			"server.apiKey", "server.harnessId", "openrouter.referer",
-			"budget.perTurnUsd", "budget.perConversationUsd", "budget.perDayUsd", "filters.maxExpectedWaitMs",
+			"budget.perTurnUsd", "budget.perConversationUsd", "budget.perDayUsd", "budget.perMonthUsd", "filters.maxExpectedWaitMs", "filters.latencyWeightContinuation",
 			...["trivial", "simple", "moderate", "hard"].flatMap((t) => [
 				`tiers.${t}.maxInputPerMtok`, `tiers.${t}.maxOutputPerMtok`, `tiers.${t}.qualityNormalization`, `tiers.${t}.capabilityFloorUsd`,
 			]),
@@ -303,6 +303,7 @@ describe("runWizard", () => {
 			CLEAR_TOKEN, // clear perTurnUsd
 			"",
 			"",
+			"", // perMonthUsd
 			"",
 			"s",
 		]);

package/test/controls.test.ts

@@ -0,0 +1,223 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { createFeedbackStore } from "../src/cost/feedback.ts";
+import { createLedger } from "../src/cost/ledger.ts";
+import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
+import { startServer, type StartedServer } from "../src/server/http.ts";
+import { ollamaRunway } from "../src/server/http.ts";
+import { createSessionOverrides, OVERRIDE_TTL_MS } from "../src/server/overrides.ts";
+import { openDb } from "../src/util/sqlite.ts";
+import { describeOverride, parseOverrideArgs, renderWhy, type WhyEntry } from "../omp-extension/report-logic.ts";
+
+/**
+ * Session controls from omp: pin/tier overrides (process-local, per omp
+ * session, counted down per committed dispatch), user feedback tied to the
+ * ledger row judged, and the /router why rendering.
+ */
+
+describe("session overrides", () => {
+	test("set, read, count down, clear, and expire", () => {
+		const o = createSessionOverrides();
+		const now = Date.now();
+		expect(o.get("s1")).toBeNull();
+		o.set("s1", { tier: "hard", turns: 2 }, now);
+		expect(o.get("s1")).toEqual({ slug: null, tier: "hard", turnsLeft: 2, setAtMs: now });
+		// A pin added later keeps the tier and its countdown.
+		o.set("s1", { slug: "ollama/glm-5.3-flash" }, now + 1);
+		expect(o.get("s1")?.slug).toBe("ollama/glm-5.3-flash");
+		expect(o.get("s1")?.tier).toBe("hard");
+		o.consume("s1");
+		expect(o.get("s1")?.turnsLeft).toBe(1);
+		o.consume("s1");
+		expect(o.get("s1")).toBeNull(); // used up
+		o.set("s2", { slug: "x/y", turns: 0 });
+		o.consume("s2");
+		o.consume("s2");
+		expect(o.get("s2")?.turnsLeft).toBe(0); // unlimited never counts down
+		o.clear("s2");
+		expect(o.get("s2")).toBeNull();
+		o.set("s3", { tier: "simple" }, Date.now() - OVERRIDE_TTL_MS - 1);
+		expect(o.get("s3")).toBeNull(); // expired
+		expect(o.get("")).toBeNull();
+	});
+
+	test("clearing both fields reads as no override", () => {
+		const o = createSessionOverrides();
+		o.set("s", { tier: "hard" });
+		o.set("s", { tier: null });
+		expect(o.get("s")).toBeNull();
+		expect(o.list()).toHaveLength(1); // the entry exists but carries nothing
+	});
+});
+
+describe("feedback store", () => {
+	function entry(over: Partial<LedgerEntry>): LedgerEntry {
+		return {
+			id: crypto.randomUUID(),
+			createdAtMs: Date.now(),
+			conversationKey: "k",
+			sessionId: "s",
+			turn: 1,
+			requestedModel: "auto",
+			harnessId: "",
+			ompSessionId: "omp-1",
+			slug: "v/m",
+			servedSlug: "v/m",
+			tier: "simple",
+			classificationSource: "heuristic",
+			reasons: [],
+			features: null,
+			score: null,
+			confidence: null,
+			task: null,
+			classifierReasons: null,
+			exploredFrom: null,
+			holdArm: null,
+			predictedUsd: 0.001,
+			reportedUsd: 0.001,
+			usage: { ...EMPTY_USAGE, promptTokens: 10, completionTokens: 5 },
+			attempt: 0,
+			escalationSignal: null,
+			latencyMs: 100,
+			ttftMs: 50,
+			finishReason: "stop",
+			wasted: false,
+			upstreamGenerationId: null,
+			error: null,
+			promptTokensSaved: null,
+			...over,
+		} as LedgerEntry;
+	}
+
+	test("records verdicts against the session's newest kept turn and counts them by model", () => {
+		const db = openDb(":memory:");
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		cfg.ledger.path = ":memory:";
+		const ledger = createLedger(db, cfg);
+		const fb = createFeedbackStore(db);
+		ledger.record(entry({ createdAtMs: 1_000, slug: "a/m", servedSlug: "a/m" }));
+		ledger.record(entry({ createdAtMs: 2_000, slug: "b/m", servedSlug: "b/m", wasted: true })); // a wasted probe is never "the turn"
+		ledger.record(entry({ createdAtMs: 3_000, slug: "c/m", servedSlug: "c/m" }));
+		ledger.record(entry({ createdAtMs: 4_000, ompSessionId: "omp-2", slug: "d/m", servedSlug: "d/m" }));
+		const latest = ledger.latestForSession!("omp-1")!;
+		expect(latest.servedSlug).toBe("c/m");
+		expect(ledger.entriesForSession!("omp-1", 10).map((e) => e.servedSlug)).toEqual(["c/m", "a/m"]);
+		expect(ledger.latestForSession!("")).toBeNull();
+
+		fb.record({ ledgerId: latest.id, ompSessionId: "omp-1", slug: "c/m", tier: "simple", verdict: "bad", note: "wrong file" }, 5_000);
+		fb.record({ ledgerId: latest.id, ompSessionId: "omp-1", slug: "c/m", tier: "simple", verdict: "good", note: "" }, 6_000);
+		expect(fb.forLedgerId(latest.id).map((f) => f.verdict)).toEqual(["good", "bad"]);
+		expect([...fb.countsBySlug(0).entries()]).toEqual([["c/m", { good: 1, bad: 1 }]]);
+		expect(fb.countsBySlug(5_500).get("c/m")).toEqual({ good: 1, bad: 0 });
+		db.close();
+	});
+});
+
+describe("override and feedback endpoints", () => {
+	let handle: StartedServer;
+	let baseUrl = "";
+	beforeAll(() => {
+		const cfg: RouterConfig = {
+			...structuredClone(DEFAULT_CONFIG),
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24 },
+			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
+			logLevel: "silent",
+		};
+		handle = startServer(cfg);
+		baseUrl = `http://127.0.0.1:${handle.server.port}`;
+	});
+	afterAll(async () => {
+		await handle.stop();
+	});
+	const post = (path: string, body: unknown) =>
+		fetch(`${baseUrl}${path}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+
+	test("override: validates, sets a tier with a countdown, shows it, clears it", async () => {
+		expect((await post("/v1/router/override", { tier: "hard" })).status).toBe(400); // no session
+		expect((await post("/v1/router/override", { ompSessionId: "s", tier: "epic" })).status).toBe(400);
+		expect((await post("/v1/router/override", { ompSessionId: "s", slug: "nope/model" })).status).toBe(404);
+		const set = (await (await post("/v1/router/override", { ompSessionId: "s", tier: "hard", turns: 3 })).json()) as { override: { tier: string; turnsLeft: number } };
+		expect(set.override.tier).toBe("hard");
+		expect(set.override.turnsLeft).toBe(3);
+		const shown = (await (await fetch(`${baseUrl}/v1/router/override?session=s`)).json()) as { override: { tier: string } | null };
+		expect(shown.override?.tier).toBe("hard");
+		const all = (await (await fetch(`${baseUrl}/v1/router/override`)).json()) as { overrides: unknown[] };
+		expect(all.overrides).toHaveLength(1);
+		const cleared = (await (await post("/v1/router/override", { ompSessionId: "s", clear: true })).json()) as { override: null };
+		expect(cleared.override).toBeNull();
+	});
+
+	test("feedback: rejects a bad verdict and a session with no turns", async () => {
+		expect((await post("/v1/router/feedback", { ompSessionId: "s", verdict: "meh" })).status).toBe(400);
+		expect((await post("/v1/router/feedback", { ompSessionId: "never", verdict: "good" })).status).toBe(404);
+	});
+
+	test("decisions can be narrowed to a session", async () => {
+		const body = (await (await fetch(`${baseUrl}/v1/router/decisions?session=none`)).json()) as { entries: unknown[] };
+		expect(body.entries).toEqual([]);
+	});
+});
+
+describe("/router why and override parsing", () => {
+	const entry: WhyEntry = {
+		id: "abc",
+		createdAtMs: 1_000_000,
+		turn: 12,
+		slug: "z-ai/glm-5.3-flash",
+		servedSlug: "ollama/glm-5.3-flash",
+		tier: "moderate",
+		classificationSource: "heuristic",
+		confidence: 0.42,
+		task: "coding",
+		reasons: ["classified moderate", "cache: keeping warm ollama/glm-5.3-flash (stay $0.0010 ≤ switch $0.0300 × 1.3)"],
+		classifierReasons: ["+0.10 complexity keyword: refactor"],
+		reportedUsd: 0.0123,
+		predictedUsd: 0.02,
+		usage: { promptTokens: 120_000, cachedTokens: 100_000, completionTokens: 300, cachedEstimated: true },
+		latencyMs: 4_200,
+		ttftMs: 900,
+		attempt: 0,
+		escalationSignal: null,
+		feedback: [{ verdict: "bad", note: "edited the wrong file", createdAtMs: 1_000_500 }],
+	};
+
+	test("renderWhy names the model, tier, confidence, cost, cache, trail and feedback", () => {
+		const text = renderWhy(entry, 1_060_000);
+		expect(text).toContain("turn 12 · 1m ago · ollama · ollama/glm-5.3-flash (asked z-ai/glm-5.3-flash) [moderate]");
+		expect(text).toContain("classified moderate by heuristic at 42% confidence · task coding");
+		expect(text).toContain("cost $0.0123 · prompt 120,000 tok (cache 83% est.) · completion 300 tok · ttft 0.9s · total 4.2s");
+		expect(text).toContain("  - cache: keeping warm");
+		expect(text).toContain("  - +0.10 complexity keyword: refactor");
+		expect(text).toContain("  - bad: edited the wrong file");
+	});
+
+	test("parseOverrideArgs handles pin, tier with turns, off, and errors", () => {
+		expect(parseOverrideArgs("pin", "ollama/glm-5.3-flash")).toEqual({ kind: "pin", slug: "ollama/glm-5.3-flash" });
+		expect(parseOverrideArgs("pin", "off")).toEqual({ kind: "pin", slug: null });
+		expect(parseOverrideArgs("pin", "")).toEqual({ kind: "show" });
+		expect(parseOverrideArgs("tier", "hard")).toEqual({ kind: "tier", tier: "hard", turns: 10 });
+		expect(parseOverrideArgs("tier", "Simple 3")).toEqual({ kind: "tier", tier: "simple", turns: 3 });
+		expect(parseOverrideArgs("tier", "off")).toEqual({ kind: "tier", tier: null, turns: 0 });
+		expect(parseOverrideArgs("tier", "epic").kind).toBe("error");
+		expect(parseOverrideArgs("tier", "hard x").kind).toBe("error");
+	});
+
+	test("describeOverride summarises what is in force", () => {
+		expect(describeOverride(null)).toBe("no override on this session");
+		expect(describeOverride({ slug: "a/b", tier: "hard", turnsLeft: 1 })).toBe("pinned to a/b, tier forced to hard · 1 turn left");
+		expect(describeOverride({ slug: null, tier: "simple", turnsLeft: 0 })).toBe("tier forced to simple · until cleared");
+	});
+});
+
+describe("ollamaRunway", () => {
+	test("days of credits left at the calibrated weekly burn", () => {
+		const r = ollamaRunway({ usedUsd: 6.3, creditsUsd: 60 }, 7, 1.25)!;
+		expect(r.dailyBurnUsd).toBeCloseTo(1.25, 6);
+		expect(r.creditsLeftUsd).toBeCloseTo(53.7, 6);
+		expect(r.days).toBeCloseTo(53.7 / 1.25, 6);
+		expect(ollamaRunway({ usedUsd: 6.3, creditsUsd: 60 }, 0, 1)!.days).toBeNull();
+		expect(ollamaRunway(null, 7, 1)).toBeNull();
+	});
+});

package/test/failover.test.ts

@@ -46,10 +46,10 @@ 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, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
-			model: "test/adjudicator",
+			model: "test/adjudicator", learnedModelPath: "",
 			maxCostFraction: 0.1,
 			maxCostUsd: 0.01,
 			timeoutMs: 5000,
@@ -76,6 +76,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1 },
 		budget: { onExceeded: "downgrade" },
+		report: { baselines: [] },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
 		adaptiveTierFloors: true,

package/test/features.test.ts

@@ -306,3 +306,34 @@ describe("user-visible tool failure (review 2026-09-05)", () => {
 		expect(f.lastToolFailed).toBe(false);
 	});
 });
+
+describe("prompt anatomy", () => {
+	test("splits prompt bytes by role and marks the older half and stale tool results", () => {
+		// 24 non-system messages: 12 tool-call/result pairs. The newest 20
+		// non-system messages are "fresh"; the 4 before them hold 2 stale tool results.
+		const messages: unknown[] = [SYSTEM];
+		for (let i = 0; i < 12; i++) {
+			messages.push(toolCall(`c${i}`, "bash", `{"command":"ls ${i}"}`));
+			messages.push({ role: "tool", tool_call_id: `c${i}`, content: "x".repeat(100) });
+		}
+		messages.push({ role: "user", content: "y".repeat(50) });
+		const f = extractFeatures(req(messages), 5000);
+		const a = f.anatomy!;
+		expect(a.messages).toBe(26);
+		expect(a.systemBytes).toBe("You are a coding agent.".length);
+		expect(a.userBytes).toBe(50);
+		expect(a.toolBytes).toBe(1200);
+		// 25 non-system messages; the older half is the first 12 (6 pairs ⇒ 6 tool results).
+		expect(a.olderHalfBytes).toBeGreaterThanOrEqual(600);
+		expect(a.olderHalfBytes).toBeLessThan(1200);
+		// Stale: tool results among the first 25-20 = 5 non-system messages ⇒ results at index 1 and 3.
+		expect(a.staleToolBytes).toBe(200);
+	});
+
+	test("a bare chat request has no stale tool bytes", () => {
+		const a = extractFeatures(req([SYSTEM, { role: "user", content: "hi" }]), 20).anatomy!;
+		expect(a.toolBytes).toBe(0);
+		expect(a.staleToolBytes).toBe(0);
+		expect(a.olderHalfBytes).toBe(0);
+	});
+});

package/test/learned.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+
+import { auc, FEATURE_NAMES, learnedVector, predictRisk, trainLogistic, type LearnedModel } from "../src/router/learned.ts";
+
+/**
+ * The learned escalation-risk model: a deterministic logistic regression that
+ * must separate a synthetic dataset, score by rank correctly, and tolerate
+ * old ledger rows missing fields.
+ */
+
+describe("learnedVector", () => {
+	test("matches FEATURE_NAMES in length and tolerates missing fields", () => {
+		const v = learnedVector({});
+		expect(v).toHaveLength(FEATURE_NAMES.length);
+		expect(v.every((x) => x === 0)).toBe(true);
+		const w = learnedVector({ promptTokens: 1000, lastToolFailed: true, requestedReasoning: "high", complexityKeywords: ["refactor", "migrate"] });
+		expect(w[FEATURE_NAMES.indexOf("log_prompt_tokens")]).toBeCloseTo(Math.log1p(1000), 6);
+		expect(w[FEATURE_NAMES.indexOf("last_tool_failed")]).toBe(1);
+		expect(w[FEATURE_NAMES.indexOf("requested_reasoning")]).toBe(3);
+		expect(w[FEATURE_NAMES.indexOf("complexity_keywords")]).toBe(2);
+	});
+});
+
+describe("auc", () => {
+	test("perfect ranking is 1, inverted is 0, ties count half", () => {
+		expect(auc([0.9, 0.8, 0.1, 0.2], [1, 1, 0, 0])).toBe(1);
+		expect(auc([0.1, 0.2, 0.9, 0.8], [1, 1, 0, 0])).toBe(0);
+		expect(auc([0.5, 0.5], [1, 0])).toBe(0.5);
+		expect(auc([0.3], [1])).toBe(0.5);
+	});
+});
+
+describe("trainLogistic", () => {
+	test("separates a dataset where escalation follows failed tools and long prompts", () => {
+		const xs: number[][] = [];
+		const ys: number[] = [];
+		let seed = 7;
+		const rnd = () => ((seed = (seed * 1103515245 + 12345) % 2147483648) / 2147483648);
+		for (let i = 0; i < 2000; i++) {
+			const failed = rnd() < 0.1;
+			const prompt = Math.floor(rnd() * 150_000);
+			const y = failed && prompt > 60_000 ? (rnd() < 0.9 ? 1 : 0) : rnd() < 0.02 ? 1 : 0;
+			xs.push(learnedVector({ promptTokens: prompt, lastToolFailed: failed, turnDepth: Math.floor(rnd() * 100), toolCount: 12 }));
+			ys.push(y);
+		}
+		const fit = trainLogistic(xs.slice(0, 1600), ys.slice(0, 1600), { epochs: 300 });
+		const model: LearnedModel = { version: 1, trainedAtMs: 0, rows: 1600, positives: 0, names: [...FEATURE_NAMES], means: fit.means, stds: fit.stds, weights: fit.weights, bias: fit.bias, auc: 0 };
+		const scores = xs.slice(1600).map((x) => {
+			// predictRisk takes features; rebuild the same vector through it for parity.
+			const f = { promptTokens: Math.expm1(x[0]!), lastToolFailed: x[8] === 1, turnDepth: x[2]!, toolCount: x[3]! };
+			return predictRisk(model, f);
+		});
+		expect(auc(scores, ys.slice(1600))).toBeGreaterThan(0.85);
+		expect(fit.weights[FEATURE_NAMES.indexOf("last_tool_failed")]!).toBeGreaterThan(0);
+		expect(fit.weights[FEATURE_NAMES.indexOf("log_prompt_tokens")]!).toBeGreaterThan(0);
+	});
+
+	test("refuses an empty dataset", () => {
+		expect(() => trainLogistic([], [])).toThrow();
+	});
+});