auto-model-router 0.3.4 → 0.4.1

package/src/server/providers.ts

@@ -12,6 +12,7 @@ import type { CatalogSource } from "../catalog/types.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { createMultiUpstream } from "../upstream/multi.ts";
 import { createOllamaClient, type OllamaClient } from "../upstream/ollama.ts";
+import { createLedger } from "../cost/ledger.ts";
 import { createOllamaUsageSource, NO_USAGE, type OllamaUsageSource } from "../upstream/ollama-usage.ts";
 import { createOpenRouterClient } from "../upstream/openrouter.ts";
 import type { UpstreamClient } from "../upstream/types.ts";
@@ -24,31 +25,38 @@ export interface Providers {
 	ollama: OllamaClient | null;
 	/** Plan usage reader; inert without a key. */
 	ollamaUsage: OllamaUsageSource;
+	/** Multiplier that brings the ledger's Ollama estimate in line with the plan meter; 1 until calibrated. */
+	ollamaCostScale: () => number;
 }
 
 export function createProviders(cfg: RouterConfig, db: Database, log: Logger = createLogger(cfg.logLevel)): Providers {
 	const openrouter = createOpenRouterClient(cfg);
 	const openrouterCatalog = createCatalog(cfg, openrouter, db);
-	if (!cfg.ollama.enabled) return { upstream: openrouter, catalog: openrouterCatalog, ollama: null, ollamaUsage: NO_USAGE };
+	if (!cfg.ollama.enabled) return { upstream: openrouter, catalog: openrouterCatalog, ollama: null, ollamaUsage: NO_USAGE, ollamaCostScale: () => 1 };
 	// Ollama Cloud is a second upstream ranked in the same catalog: `ollama/…`
 	// slugs dispatch to it, everything else to OpenRouter.
 	const ollama = createOllamaClient(cfg);
 	// Plan usage lives on ollama.com whichever base URL dispatches; it needs the
 	// key, so the daemon path without `/login ollama-cloud` keeps a static bias.
+	const ledgerForCalibration = createLedger(db, cfg);
 	const ollamaUsage = createOllamaUsageSource({
 		apiKey: cfg.ollama.apiKey,
 		pollMs: cfg.ollama.usagePollMs,
 		timeoutMs: Math.min(cfg.ollama.timeoutMs, 15_000),
 		log,
+		// Each poll records the meter beside the ledger's Ollama total, so the
+		// estimate can be scaled to what ollama.com actually bills.
+		calibration: { db, ledgerUsd: () => ledgerForCalibration.providerSpendSince?.("ollama/", 0) ?? 0, planCreditsOverrideUsd: cfg.ollama.planCreditsUsd },
 	});
 	return {
 		upstream: createMultiUpstream(openrouter, ollama),
-		catalog: createCompositeCatalog(openrouterCatalog, createOllamaCatalog(cfg.ollama, log), ollama, {
+		catalog: createCompositeCatalog(openrouterCatalog, createOllamaCatalog(cfg.ollama, log, fetch, db), ollama, {
 			costBias: cfg.ollama.costBias,
 			biasUntilUsage: cfg.ollama.biasUntilUsage,
 			usage: ollamaUsage,
 		}),
 		ollama,
 		ollamaUsage,
+		ollamaCostScale: () => ollamaUsage.calibration()?.factor ?? 1,
 	};
 }

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/src/wire/openai/request.ts

@@ -292,6 +292,9 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	// ⇒ the server falls back to its configured default scope.
 	const agentdoxScope = (headers.get("x-agentdox-scope") ?? "").trim();
 
+	// Subagent marker from the embed extension (sessions without a UI).
+	const isSubagent = (headers.get("x-omp-subagent") ?? "").trim() === "1";
+
 	if (typeof b.model !== "string" || b.model.length === 0) {
 		throw invalidRequest("model must be a non-empty string");
 	}
@@ -352,6 +355,7 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		harnessId,
 		ompSessionId,
 		agentdoxScope,
+		isSubagent,
 		requestedModel,
 		messages,
 		tools,

package/src/wire/types.ts

@@ -82,6 +82,8 @@ export interface NormRequest {
 	 * and if that is empty too the bridge stays inert for this request.
 	 */
 	agentdoxScope: string;
+	/** `X-Omp-Subagent: 1`: the caller is an omp subagent (a session without a UI). */
+	isSubagent: boolean;
 	/** Virtual model the client selected, e.g. `auto`, `auto-cheap`, `auto-max`. */
 	requestedModel: string;
 	messages: NormMessage[];

package/test/classify.test.ts

@@ -458,3 +458,16 @@ describe("classifyTask", () => {
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "explain the architecture of the system" }], []))).toBe("documentation");
 	});
 });
+
+describe("classifier.readOnlyToolWeight", () => {
+	test("subtracts only when enabled and the tail is a read-only loop", () => {
+		const base = { ...featuresFor([{ role: "user", content: "look" }]), isToolResultContinuation: true, readOnlyToolTail: true };
+		const off = scoreHeuristic(base, DEFAULT_CONFIG);
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		cfg.classifier.readOnlyToolWeight = 0.1;
+		const on = scoreHeuristic(base, cfg);
+		expect(on.score).toBeCloseTo(Math.max(0, off.score - 0.1), 6);
+		expect(on.reasons.some((r) => r.includes("read-only tool loop"))).toBe(true);
+		expect(scoreHeuristic({ ...base, readOnlyToolTail: false }, cfg).score).toBeCloseTo(off.score, 6);
+	});
+});

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`,
 			]),
@@ -280,6 +280,7 @@ describe("runWizard", () => {
 			"", // keep apiKey
 			"", // keep harnessId
 			"", // keep maxConcurrentTurns
+			"", // keep subagentProfile
 			"s",
 		]);
 		expect(partial).toEqual({ server: { port: 9000 } });
@@ -303,6 +304,7 @@ describe("runWizard", () => {
 			CLEAR_TOKEN, // clear perTurnUsd
 			"",
 			"",
+			"", // perMonthUsd
 			"",
 			"s",
 		]);
@@ -357,7 +359,7 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles).toHaveLength(3);
+		expect(profiles).toHaveLength(4);
 		expect(profiles[0]).toMatchObject({ id: "auto", contextWindow: 500000 });
 		expect(profiles[1]).toMatchObject({ id: "auto-cheap", contextWindow: 400000 });
 	});
@@ -378,8 +380,8 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles).toHaveLength(4);
-		expect(profiles[3]).toEqual({
+		expect(profiles).toHaveLength(5);
+		expect(profiles[4]).toEqual({
 			id: "auto-fast",
 			name: "Auto Fast",
 			minTier: "trivial",
@@ -399,11 +401,11 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles.map((p) => (p as Record<string, unknown>)["id"])).toEqual(["auto", "auto-max"]);
+		expect(profiles.map((p) => (p as Record<string, unknown>)["id"])).toEqual(["auto", "auto-max", "auto-sub"]);
 	});
 
 	test("refuses to delete the last remaining profile", async () => {
-		const { out } = await drive(["p", "x3", "x2", "x1", "b", "q"]);
+		const { out } = await drive(["p", "x4", "x3", "x2", "x1", "b", "q"]);
 		expect(out).toContain("cannot delete the last profile");
 	});
 

package/test/controls.test.ts

@@ -0,0 +1,238 @@
+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 { resolveProfile } from "../src/router/index.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, subagentProfile: "auto-sub" },
+			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();
+	});
+});
+
+describe("subagent profile", () => {
+	test("a subagent asking for the default profile is routed under server.subagentProfile; explicit profiles are honoured", () => {
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto-sub");
+		expect(resolveProfile(cfg, "auto", false).id).toBe("auto");
+		expect(resolveProfile(cfg, "auto-max", true).id).toBe("auto-max");
+		expect(resolveProfile(cfg, "unknown", true).id).toBe("auto-sub"); // unknown ids fall back to the default, which a subagent remaps
+		cfg.server.subagentProfile = "";
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
+		cfg.server.subagentProfile = "nope";
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
+	});
+});

package/test/escalate.test.ts

@@ -24,6 +24,7 @@ function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): Nor
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: "auto",
 		messages,
 		tools: [],