auto-model-router 0.4.3 → 0.4.5

package/src/router/select.ts

@@ -8,7 +8,7 @@
 
 import type { CatalogSnapshot } from "../catalog/types.ts";
 import type { ProfileConfig, RouterConfig } from "../config/types.ts";
-import { priceAt } from "../cost/forecast.ts";
+import { forecast, priceAt } from "../cost/forecast.ts";
 import type { Ledger } from "../cost/types.ts";
 import { explorationDraw } from "./explore.ts";
 import type { CompactionEdit, NormRequest, ReasoningLevel } from "../wire/types.ts";
@@ -610,13 +610,33 @@ export function select(args: SelectArgs): Decision {
 	}
 	const stripAssistantReasoning = !(chosen.model.supportsReasoning && REASONING_REPLAY_AUTHORS[chosen.model.author] === true);
 
+	// The recorded forecast is the EXPECTED price of this dispatch, not the
+	// cold worst case candidates are ranked on. When the chosen model's cache
+	// is warm, the previous prompt's tokens are priced as cache reads at the
+	// model's measured hit rate; coldUsd stays the cold figure the budget
+	// guards used. Before this every recorded forecast was cold while nine
+	// turns in ten were warm: 89% over-predicted, median error 220%.
+	let expectedForecast = chosen.forecast;
+	if (warmSlug !== null && chosen.model.slug === warmSlug && effFeatures.promptTokens > 0 && state.lastPromptTokens > 0) {
+		const cachedShare = Math.min(1, state.lastPromptTokens / effFeatures.promptTokens);
+		let images = 0;
+		if (req.hasImages) for (const m of req.messages) images += m.images;
+		const warm = forecast(chosen.model, {
+			promptTokens: effFeatures.promptTokens,
+			completionTokens: EXPECTED_COMPLETION_TOKENS,
+			cacheHitRate: cacheHitExpectation(chosen.model.slug).rate * cachedShare,
+			images,
+		});
+		expectedForecast = { ...warm, coldUsd: chosen.forecast.coldUsd };
+	}
+
 	return {
 		slug: chosen.model.slug,
 		fallbacks,
 		tier: chosenTier,
 		classification: cls,
 		features,
-		forecast: chosen.forecast,
+		forecast: expectedForecast,
 		sessionId: state.sessionId,
 		sticky,
 		cacheBreakpointMessageIndices,

package/src/server/advise.ts

@@ -0,0 +1,82 @@
+/**
+ * Harness-side model switch: the router advises a tier for a prompt BEFORE
+ * the harness dispatches it, so the harness can move its active model to one
+ * the router cannot proxy (a Claude subscription model, say) for hard work
+ * and back to the router for the rest.
+ *
+ * Why this shape: proxying a subscription upstream would mean translating
+ * the OpenAI wire to that provider's and carrying its OAuth token through a
+ * third-party process. Advising is cheaper and keeps the token where it
+ * belongs. The cost of a native turn lands on the subscription, not the
+ * ledger; the router only sees the turns it serves.
+ *
+ * The advice is the heuristic classifier over the user's prompt text alone
+ * (the harness has not built the request yet), plus the session's last
+ * routed tier for context. No adjudicator call, no dispatch, nothing recorded.
+ */
+
+import type { RouterConfig } from "../config/types.ts";
+import type { Ledger } from "../cost/types.ts";
+import { scoreHeuristic } from "../router/classify.ts";
+import { extractFeatures } from "../router/features.ts";
+import { estimateTokens } from "../tokens/estimate.ts";
+import type { TaskType, Tier } from "../router/types.ts";
+import type { NormRequest } from "../wire/types.ts";
+
+export interface AdviseRequest {
+	ompSessionId: string;
+	harnessId: string;
+	/** The user's prompt as submitted. */
+	text: string;
+}
+
+export interface Advice {
+	tier: Tier;
+	task: TaskType;
+	confidence: number;
+	score: number;
+	reasons: string[];
+	/** The tier this session's last routed turn ran at, when the router served one. */
+	lastTier: Tier | null;
+}
+
+const SYSTEM_STUB = "You are a coding agent.";
+
+function requestOf(req: AdviseRequest): NormRequest {
+	const text = req.text;
+	return {
+		protocol: "openai-chat",
+		conversationKey: `advise:${req.ompSessionId}`,
+		harnessId: req.harnessId,
+		ompSessionId: req.ompSessionId,
+		agentdoxScope: "",
+		isSubagent: false,
+		requestedModel: "auto",
+		messages: [
+			{ role: "system", text: SYSTEM_STUB, images: 0, textBytes: Buffer.byteLength(SYSTEM_STUB), toolCalls: [] },
+			{ role: "user", text, images: 0, textBytes: Buffer.byteLength(text), toolCalls: [] },
+		],
+		tools: [],
+		forcedToolChoice: false,
+		stream: false,
+		hasImages: false,
+		promptBytes: Buffer.byteLength(SYSTEM_STUB) + Buffer.byteLength(text),
+		renderUpstreamBody: () => ({}),
+	};
+}
+
+/** Classifies a prompt the way the first turn of a conversation would be, without dispatching anything. */
+export function advise(cfg: RouterConfig, ledger: Ledger | null, req: AdviseRequest): Advice {
+	const norm = requestOf(req);
+	const features = extractFeatures(norm, estimateTokens(norm.promptBytes, "unknown", ledger));
+	const cls = scoreHeuristic(features, cfg);
+	const last = req.ompSessionId === "" ? null : (ledger?.latestForSession?.(req.ompSessionId)?.tier ?? null);
+	return {
+		tier: cls.tier,
+		task: cls.task,
+		confidence: cls.confidence,
+		score: cls.score,
+		reasons: cls.reasons,
+		lastTier: last === null ? null : (last as Tier),
+	};
+}

package/src/server/compaction-digest.ts

@@ -23,6 +23,8 @@ import type { DigestRequest, DigestResult } from "./digest.ts";
 
 export interface CompactionDigester {
 	digest(req: DigestRequest): Promise<DigestResult>;
+	/** See Digester.noteToolCalls; optional so a fake need not implement it. */
+	noteToolCalls?(ompSessionId: string, calls: readonly { name: string; argsJson: string }[], nowMs?: number): number;
 }
 
 export interface DigestCompactionArgs {

package/src/server/digest.ts

@@ -23,6 +23,7 @@ import type { DigestConfig, RouterConfig } from "../config/types.ts";
 import { computeCost, forecast } from "../cost/forecast.ts";
 import type { Ledger, LedgerEntry } from "../cost/types.ts";
 import { buildCandidates } from "../router/candidates.ts";
+import { primaryArg } from "../router/compaction.ts";
 import { extractFeatures } from "../router/features.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { estimateTokens } from "../tokens/estimate.ts";
@@ -107,8 +108,31 @@ function syntheticRequest(req: DigestRequest, promptText: string): NormRequest {
 	};
 }
 
-export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest): Promise<DigestResult> } {
+/** A digest the agent may still go back on: same tool, same primary argument, within RERUN_WINDOW_MS. */
+interface RecentDigest {
+	tool: string;
+	arg: string | null;
+	atMs: number;
+	ledgerId: string;
+	rerun: boolean;
+}
+const RERUN_WINDOW_MS = 2 * 3_600_000;
+const RECENT_PER_SESSION = 50;
+
+export interface Digester {
+	digest(req: DigestRequest): Promise<DigestResult>;
+	/**
+	 * Quality signal: the tool calls a session just made. One that repeats a
+	 * recent digest (same tool, same primary argument) means the agent went
+	 * back for the full output; that digest's ledger row is marked wasted and
+	 * the report shows the re-run rate. Returns how many were marked.
+	 */
+	noteToolCalls(ompSessionId: string, calls: readonly { name: string; argsJson: string }[], nowMs?: number): number;
+}
+
+export function createDigester(deps: DigesterDeps): Digester {
 	const { cfg, catalog, ledger, upstream, log } = deps;
+	const recent = new Map<string, RecentDigest[]>();
 
 	/** Cheapest simple-tier model that fits the prompt, or the configured one. */
 	async function pickModel(req: NormRequest, promptTokens: number): Promise<CatalogModel | null> {
@@ -229,6 +253,11 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 			}
 			if (error !== null) return { digested: false, reason: `digest model failed: ${error}` };
 			if (text === "" || text.length >= inputBytes * 0.9) return { digested: false, reason: "digest did not shrink the output" };
+			if (req.ompSessionId !== "") {
+				const list = recent.get(req.ompSessionId) ?? [];
+				list.push({ tool: req.toolName.toLowerCase(), arg: primaryArg(JSON.stringify(req.input)), atMs: startedAt, ledgerId: entry.id, rerun: false });
+				recent.set(req.ompSessionId, list.slice(-RECENT_PER_SESSION));
+			}
 			return {
 				digested: true,
 				text: `${digestMarker(req.toolName, req.input, model.slug, inputBytes, text.length)}\n${text}`,
@@ -239,5 +268,30 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 				ms,
 			};
 		},
+		noteToolCalls(ompSessionId, calls, nowMs = Date.now()) {
+			const list = recent.get(ompSessionId);
+			if (list === undefined || list.length === 0) return 0;
+			let marked = 0;
+			for (const c of calls) {
+				const tool = c.name.toLowerCase();
+				const arg = primaryArg(c.argsJson);
+				if (arg === null) continue;
+				for (const d of list) {
+					if (d.rerun || d.tool !== tool || d.arg !== arg || nowMs - d.atMs > RERUN_WINDOW_MS) continue;
+					d.rerun = true;
+					marked++;
+					try {
+						ledger.markWasted?.(d.ledgerId);
+					} catch (err) {
+						log.debug("digest re-run mark failed", { error: err instanceof Error ? err.message : String(err) });
+					}
+					log.info("digest re-run: the agent fetched the full output after all", { tool, arg: arg.slice(0, 80) });
+				}
+			}
+			const kept = list.filter((d) => nowMs - d.atMs <= RERUN_WINDOW_MS);
+			if (kept.length === 0) recent.delete(ompSessionId);
+			else recent.set(ompSessionId, kept);
+			return marked;
+		},
 	};
 }

package/src/server/http.ts

@@ -7,6 +7,7 @@ import { createFeedbackStore, type Verdict } from "../cost/feedback.ts";
 import { createLedger } from "../cost/ledger.ts";
 import { createSessionOverrides } from "./overrides.ts";
 import { createDigester } from "./digest.ts";
+import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport } from "../cost/report.ts";
 import { buildDailySummary, createKv, markSummaryShown, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
@@ -17,7 +18,7 @@ import { UpstreamError } from "../upstream/types.ts";
 import { apiKeySource, ollamaKeySource } from "../config/load.ts";
 import { ollamaMeter } from "../upstream/ollama-usage.ts";
 import { routerConfigPath } from "../cli/config-cmd.ts";
-import { watchConfig } from "../config/hot-reload.ts";
+import { PINNED_CONFIG_PATHS, watchConfig } from "../config/hot-reload.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { createLogger } from "../util/log.ts";
 import { openDb } from "../util/sqlite.ts";
@@ -202,15 +203,16 @@ export function startServer(cfg: RouterConfig): StartedServer {
 
 	// Hot reload: ranking knobs (tiers, filters, escalation, budgets, …) take
 	// effect on the next turn without a restart, because every consumer reads
-	// the shared config object at call time. Construction-captured blocks
-	// (server socket, OpenRouter client, agentdox bridge) are pinned — editing
-	// those still requires a restart, and the watcher says so explicitly.
-	const pinned = { ...cfg };
+	// the shared config object at call time. Construction-captured settings
+	// (server socket, upstream clients, agentdox bridge, ledger file) are
+	// pinned by path (PINNED_CONFIG_PATHS); editing those still requires a
+	// restart. The blocks are deep-copied so a reload cannot mutate the pin.
+	const pinned = structuredClone(cfg);
 	const configWatcher = watchConfig(
 		routerConfigPath(),
 		cfg,
 		pinned,
-		["server", "openrouter", "ollama", "context", "ledger"],
+		PINNED_CONFIG_PATHS,
 		{
 			onReload: ({ changed }) => {
 				log.info("config reloaded", { changed: changed.join(", ") });
@@ -269,6 +271,20 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	}, 60_000);
 	pruneTimer.unref();
 
+	// Ledger retention: hourly, and once at boot so a lowered setting takes
+	// effect without waiting. Reads the live config, so it hot-reloads.
+	const retain = (): void => {
+		try {
+			const dropped = ledger.prune?.(cfg.ledger.retentionDays) ?? 0;
+			if (dropped > 0) log.info("pruned ledger rows past retention", { dropped, retentionDays: cfg.ledger.retentionDays });
+		} catch (err) {
+			log.warn("ledger retention prune failed", { error: err instanceof Error ? err.message : String(err) });
+		}
+	};
+	const retentionTimer = setInterval(retain, 3_600_000);
+	retentionTimer.unref();
+	setTimeout(retain, 5_000).unref();
+
 	// Periodically refetch the (key-scoped) catalog in the background so
 	// guardrail/preference changes are picked up without needing traffic and a
 	// TTL expiry. catalogRefreshMs === 0 disables this.
@@ -400,6 +416,25 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					const harnessId = url.searchParams.get("harness") ?? "";
 					return json(buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) }));
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/advise/policy") {
+					const h = cfg.harnessSwitch;
+					return json({ enabled: h.enabled, models: h.models, minConfidence: h.minConfidence });
+				}
+				if (req.method === "POST" && url.pathname === "/v1/router/advise") {
+					// Harness-side switch: classify a prompt before the harness builds
+					// the request. Heuristic only; nothing is dispatched or recorded.
+					const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;
+					if (body === null || typeof body.text !== "string") {
+						return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "text required" });
+					}
+					return json(
+						advise(cfg, ledger, {
+							ompSessionId: typeof body.ompSessionId === "string" ? body.ompSessionId : "",
+							harnessId: typeof body.harnessId === "string" ? body.harnessId : "",
+							text: body.text.slice(0, 16_000),
+						}),
+					);
+				}
 				if (req.method === "GET" && url.pathname === "/v1/router/summary") {
 					// The last 24 hours in a few lines. `auto=1` is the session-start
 					// caller: it gets `due: false` unless report.dailySummary is on, no

package/src/server/providers.ts

@@ -54,6 +54,7 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 			costBias: cfg.ollama.costBias,
 			biasUntilUsage: cfg.ollama.biasUntilUsage,
 			usage: ollamaUsage,
+			live: () => ({ costBias: cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage }),
 		}),
 		ollama,
 		ollamaUsage,

package/src/server/turn.ts

@@ -114,6 +114,17 @@ export async function runTurn(
 	const log = createLogger(config.logLevel);
 	const state = conversations.load(req.conversationKey);
 	const turnNumber = state.turn + 1;
+	// Digest quality signal: the calls the agent just made, matched against
+	// recent digests of this session (a re-run of a digested read means the
+	// digest was not enough). The last assistant message holds this turn's calls.
+	if (deps.digester?.noteToolCalls !== undefined && req.ompSessionId !== "") {
+		for (let i = req.messages.length - 1; i >= 0; i--) {
+			const m = req.messages[i];
+			if (m === undefined || m.role !== "assistant") continue;
+			if (m.toolCalls.length > 0) deps.digester.noteToolCalls(req.ompSessionId, m.toolCalls.map((c) => ({ name: c.name, argsJson: c.argsJson })));
+			break;
+		}
+	}
 	// Request header wins; the configured default covers harnesses that send none.
 	const doxScope = req.agentdoxScope !== "" ? req.agentdoxScope : config.context.defaultScope;
 	const doxActive = bridge.enabled && doxScope !== "";

package/test/cache-control.test.ts

@@ -93,7 +93,7 @@ describe("planCacheBreakpoints", () => {
 	test("milestones follow post-compaction sizes", () => {
 		const req = loop(30);
 		const tail = req.messages.length - 1;
-		const plan = planCompaction(req.messages, BASE.compaction, req.promptBytes * 0.3, req.promptBytes);
+		const plan = planCompaction(req.messages, { ...BASE.compaction, enabled: true }, req.promptBytes * 0.3, req.promptBytes);
 		expect(plan.edits.length).toBeGreaterThan(0);
 		const options = cfg({ maxBreakpoints: 64, milestoneTokens: 4_000 });
 		const raw = planCacheBreakpoints(req, MODEL, options).filter((i) => i !== 0 && i !== tail);

package/test/config-wizard.test.ts

@@ -172,6 +172,7 @@ describe("WIZARD_SECTIONS coverage", () => {
 			]),
 			...["coding", "vision", "documentation", "data", "chat"].flatMap((t) => [`tasks.${t}.minQuality`, `tasks.${t}.requireImage`, `tasks.${t}.prefer`]),
 			...["trivial", "simple", "moderate", "hard"].map((t) => `exploration.rates.${t}`),
+			...["trivial", "simple", "moderate", "hard"].map((t) => `harnessSwitch.models.${t}`),
 		]);
 		const known = new Set(leaves(DEFAULT_CONFIG));
 		const unknown = WIZARD_SECTIONS.flatMap((s) => s.fields.map((f) => f.path)).filter((p) => !known.has(p) && !KNOWN_OPTIONAL.has(p));

package/test/digest.test.ts

@@ -184,6 +184,28 @@ describe("createDigester", () => {
 		db.close();
 	});
 
+	test("a later call of the same tool with the same primary argument marks the digest wasted", async () => {
+		const cfg = cfgWith();
+		const db = openDb(":memory:");
+		const ledger = createLedger(db, cfg);
+		seedSession(ledger, "hard");
+		const dg = createDigester({ cfg, catalog, ledger, upstream: fakeUpstream(() => "Condensed.").upstream, log });
+		const r = await dg.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: { path: "src/a.ts", offset: 1 }, content: BIG, query: "" });
+		expect(r.digested).toBe(true);
+		const row = () => ledger.recentEntries(10).find((e) => e.requestedModel === "digest")!;
+		expect(row().wasted).toBe(false);
+		// A different file, a different tool, another session: no match.
+		expect(dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/b.ts"}' }, { name: "grep", argsJson: '{"pattern":"src/a.ts"}' }])).toBe(0);
+		expect(dg.noteToolCalls("omp-2", [{ name: "read", argsJson: '{"path":"src/a.ts"}' }])).toBe(0);
+		expect(row().wasted).toBe(false);
+		// The same read again (case-insensitive tool name, any other args): the agent wanted the full output.
+		expect(dg.noteToolCalls("omp-1", [{ name: "Read", argsJson: '{"path":"src/a.ts","limit":50}' }])).toBe(1);
+		expect(row().wasted).toBe(true);
+		// Marked once; a third read does not count again.
+		expect(dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/a.ts"}' }])).toBe(0);
+		db.close();
+	});
+
 	test("a pinned digest model is used as-is", async () => {
 		const pinned = MODELS.find((m) => m.price.prompt > 0)!.slug;
 		const cfg = cfgWith({ model: pinned });

package/test/failover.test.ts

@@ -77,9 +77,10 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		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, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
+		harnessSwitch: { enabled: false, models: {}, minConfidence: 0.6 },
 		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
 		profiles: [],
-		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
+		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 , retentionDays: 0,},
 		adaptiveTierFloors: true,
 		adaptivePriceCeilings: false,
 		logLevel: "silent",

package/test/harness-switch.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { TIER_ORDER } from "../src/router/types.ts";
+import { advise } from "../src/server/advise.ts";
+import { decideSwitch, nativeModelFor, parseSwitchPolicy, type SwitchPolicy } from "../omp-extension/switch-logic.ts";
+
+/**
+ * Harness-side model switch: the router's prompt-only advice, and the
+ * extension's decision about moving omp's active model.
+ */
+
+describe("advise", () => {
+	test("classifies a prompt without a ledger or dispatch and reports the shape the extension reads", () => {
+		const a = advise(DEFAULT_CONFIG, null, { ompSessionId: "s", harnessId: "", text: "Redesign the routing pipeline so escalation and failover share one retry loop; consider cache costs and write the migration plan." });
+		expect(TIER_ORDER).toContain(a.tier);
+		expect(a.confidence).toBeGreaterThanOrEqual(0);
+		expect(a.confidence).toBeLessThanOrEqual(1);
+		expect(a.reasons.length).toBeGreaterThan(0);
+		expect(a.lastTier).toBeNull();
+		const terse = advise(DEFAULT_CONFIG, null, { ompSessionId: "", harnessId: "", text: "ok" });
+		expect(TIER_ORDER.indexOf(terse.tier)).toBeLessThanOrEqual(TIER_ORDER.indexOf(a.tier));
+	});
+});
+
+describe("switch policy", () => {
+	test("parses defensively and maps a tier to the nearest configured tier at or below it", () => {
+		expect(parseSwitchPolicy(null).enabled).toBe(false);
+		const p = parseSwitchPolicy({ enabled: true, models: { moderate: "anthropic/claude-sonnet-5", hard: "anthropic/claude-opus-4-8", simple: "no-slash" }, minConfidence: 0.5 });
+		expect(p.models).toEqual({ moderate: "anthropic/claude-sonnet-5", hard: "anthropic/claude-opus-4-8" });
+		expect(nativeModelFor(p, "hard")).toBe("anthropic/claude-opus-4-8");
+		expect(nativeModelFor(p, "moderate")).toBe("anthropic/claude-sonnet-5");
+		expect(nativeModelFor(p, "simple")).toBeUndefined();
+		expect(nativeModelFor(p, "trivial")).toBeUndefined();
+	});
+});
+
+describe("decideSwitch", () => {
+	const policy: SwitchPolicy = { enabled: true, models: { hard: "anthropic/claude-opus-4-8" }, minConfidence: 0.6 };
+	const router = "auto-model-router/auto";
+
+	test("moves up from the router for confident hard work, back for lighter work, and never past a manual choice", () => {
+		const up = decideSwitch({ policy, advised: { tier: "hard", confidence: 0.8 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null });
+		expect(up).toMatchObject({ action: "up", model: "anthropic/claude-opus-4-8" });
+		// Low confidence: stay.
+		expect(decideSwitch({ policy, advised: { tier: "hard", confidence: 0.3 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null }).action).toBe("none");
+		// Unmapped tier while on the router: stay.
+		expect(decideSwitch({ policy, advised: { tier: "moderate", confidence: 0.9 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null }).action).toBe("none");
+		// On our own switch, hard again: already there.
+		expect(decideSwitch({ policy, advised: { tier: "hard", confidence: 0.9 }, active: "anthropic/claude-opus-4-8", activeIsRouter: false, switchedTo: "anthropic/claude-opus-4-8", returnTo: router }).action).toBe("none");
+		// On our own switch, lighter work: back to the router model we left.
+		expect(decideSwitch({ policy, advised: { tier: "simple", confidence: 0.9 }, active: "anthropic/claude-opus-4-8", activeIsRouter: false, switchedTo: "anthropic/claude-opus-4-8", returnTo: router })).toMatchObject({ action: "back", model: router });
+		// The user chose a model by hand: leave it alone whatever the advice.
+		expect(decideSwitch({ policy, advised: { tier: "hard", confidence: 0.9 }, active: "openai/gpt-5", activeIsRouter: false, switchedTo: null, returnTo: null }).action).toBe("none");
+		expect(decideSwitch({ policy, advised: { tier: "trivial", confidence: 0.9 }, active: "openai/gpt-5", activeIsRouter: false, switchedTo: "anthropic/claude-opus-4-8", returnTo: router }).action).toBe("none");
+		// Disabled: nothing moves.
+		expect(decideSwitch({ policy: { ...policy, enabled: false }, advised: { tier: "hard", confidence: 0.9 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null }).action).toBe("none");
+	});
+});

package/test/hot-reload.test.ts

@@ -3,7 +3,7 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import type { RouterConfig } from "../src/config/types.ts";
-import { readValidatedConfig, watchConfig, type ConfigWatcher } from "../src/config/hot-reload.ts";
+import { PINNED_CONFIG_PATHS, readValidatedConfig, watchConfig, type ConfigWatcher } from "../src/config/hot-reload.ts";
 
 const DIR = join(import.meta.dir, ".tmp-hot-reload");
 const CFG = join(DIR, "config.yml");
@@ -129,3 +129,39 @@ describe("watchConfig", () => {
 		expect(live.filters.latencyWeight).not.toBe(9.9);
 	});
 });
+
+describe("watchConfig pins by path", () => {
+	const CFG2 = join(DIR, "config-paths.yml");
+	const live: RouterConfig = structuredClone(DEFAULT_CONFIG);
+	let watcher: ConfigWatcher | null = null;
+
+	beforeAll(() => {
+		writeFileSync(CFG2, "");
+		const pinned = structuredClone(DEFAULT_CONFIG);
+		pinned.ollama.apiKey = "pinned-key";
+		watcher = watchConfig(CFG2, live, pinned, PINNED_CONFIG_PATHS);
+	});
+	afterAll(() => watcher?.close());
+
+	test("a pinned key inside a block keeps its construction value while its siblings hot-reload", async () => {
+		writeFileSync(CFG2, yamlOf({ ollama: { apiKey: "from-file", costBias: 0.25, biasUntilUsage: 0.5 }, server: { port: 1, subagentProfile: "auto" }, ledger: { retentionDays: 30 } }));
+		await settle();
+		expect(live.ollama.costBias).toBe(0.25);
+		expect(live.ollama.biasUntilUsage).toBe(0.5);
+		expect(live.ollama.apiKey).toBe("pinned-key");
+		expect(live.server.port).toBe(DEFAULT_CONFIG.server.port);
+		expect(live.server.subagentProfile).toBe("auto");
+		expect(live.ledger.retentionDays).toBe(30);
+		expect(live.ledger.path).toBe(DEFAULT_CONFIG.ledger.path);
+	});
+
+	test("the pinned path list names only real config keys", () => {
+		const root = DEFAULT_CONFIG as unknown as Record<string, Record<string, unknown>>;
+		for (const p of PINNED_CONFIG_PATHS) {
+			const [block = "", key] = p.split(".");
+			expect(block in root).toBe(true);
+			// Optional keys (server.apiKey, server.harnessId) are absent from the defaults but real.
+			if (key !== undefined && !["apiKey", "harnessId"].includes(key)) expect(key in root[block]!).toBe(true);
+		}
+	});
+});

package/test/migrations.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "bun:test";
+import { copyFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { createFeedbackStore } from "../src/cost/feedback.ts";
+import { createLedger } from "../src/cost/ledger.ts";
+import { buildUsageReport } from "../src/cost/report.ts";
+import { buildDailySummary, createKv } from "../src/cost/summary.ts";
+import { createConversationStore } from "../src/router/state.ts";
+import { openDb } from "../src/util/sqlite.ts";
+
+/**
+ * Every ledger a past release wrote must open under the current bootstrap:
+ * the version lands on the current number, every prepared statement the
+ * router uses compiles against the migrated schema, the carried rows survive
+ * with their backfills, and the aggregates run. The fixtures come from
+ * tools/gen-migration-fixtures.ts (each tag's own bootstrap plus one row per
+ * table), so a column added without a guard, or a statement that assumes a
+ * column older files lack, fails here rather than on a user's install.
+ */
+
+const FIXTURES = join(import.meta.dir, "fixtures", "migrations");
+const files = readdirSync(FIXTURES).filter((f) => /^router-v\d+\.db$/.test(f)).sort((a, b) => Number(/\d+/.exec(a)![0]) - Number(/\d+/.exec(b)![0]));
+const CURRENT_VERSION = 17;
+
+describe("schema migrations from every shipped version", () => {
+	test("fixtures exist for the versions that shipped", () => {
+		expect(files.map((f) => Number(/\d+/.exec(f)![0]))).toEqual([4, 5, 10, 12, 13, 14, 16]);
+	});
+
+	for (const file of files) {
+		const from = Number(/\d+/.exec(file)![0]);
+		test(`v${from} → v${CURRENT_VERSION}: opens, migrates, keeps its rows, and every consumer runs`, () => {
+			const dir = mkdtempSync(join(tmpdir(), "amr-migrate-"));
+			const path = join(dir, "router.db");
+			copyFileSync(join(FIXTURES, file), path);
+			const cfg = structuredClone(DEFAULT_CONFIG);
+			cfg.ledger.path = path;
+			const db = openDb(path);
+			try {
+				expect((db.query("PRAGMA user_version").get() as { user_version: number }).user_version).toBe(CURRENT_VERSION);
+				// Every column the current code writes exists after migration.
+				const ledgerCols = new Set((db.query("PRAGMA table_info(ledger)").all() as { name: string }[]).map((c) => c.name));
+				for (const c of ["harness_id", "error_kind", "omp_session_id", "features", "explored_from", "hold_arm", "prompt_tokens_saved"]) expect(ledgerCols.has(c)).toBe(true);
+				const convCols = new Set((db.query("PRAGMA table_info(conversations)").all() as { name: string }[]).map((c) => c.name));
+				for (const c of ["context_version", "compaction_plan", "compaction_plan_tokens", "upgrade_deferred_tier"]) expect(convCols.has(c)).toBe(true);
+				// The fixture's ledger row survived the ALTERs with its values.
+				const row = db.query("SELECT id, error, slug FROM ledger").get() as { id: string; error: string | null; slug: string } | null;
+				expect(row).toEqual({ id: "fixture-id", error: "upstream_error: 502", slug: "fixture-slug" });
+				// Every prepared statement compiles and every consumer runs on the migrated file.
+				const ledger = createLedger(db, cfg);
+				const conversations = createConversationStore(db);
+				createFeedbackStore(db);
+				createKv(db);
+				expect(ledger.recentEntries(5)).toHaveLength(1);
+				expect(ledger.trust("fixture-slug")).not.toBeNull();
+				expect(ledger.softFailureSpikes?.()).toEqual([]);
+				expect(ledger.latestForSession?.("nope")).toBeNull();
+				expect(conversations.load("fixture-key").key).toBe("fixture-key");
+				expect(buildUsageReport(db, { windowDays: 3650 }).totals.dispatches).toBe(1);
+				expect(buildDailySummary(db, {}).current.dispatches).toBe(0);
+				expect(ledger.prune?.(0)).toBe(0);
+			} finally {
+				db.close();
+				try {
+					rmSync(dir, { recursive: true, force: true });
+				} catch {
+					// Windows keeps the file locked until the statements are collected; the temp dir is disposable.
+				}
+			}
+		});
+	}
+
+	test("a fresh database lands on the same version as a migrated one", () => {
+		const db = openDb(":memory:");
+		try {
+			expect((db.query("PRAGMA user_version").get() as { user_version: number }).user_version).toBe(CURRENT_VERSION);
+		} finally {
+			db.close();
+		}
+	});
+});

package/test/report-hub.test.ts

@@ -80,7 +80,7 @@ function report(over: Partial<UsageReport> = {}): UsageReport {
 			subagentSpendUsd: 0,
 			digests: 0,
 			digestSpendUsd: 0,
-			digestInputTokens: 0,
+			digestInputTokens: 0, digestReruns: 0, forecastSamples: 0, forecastMeanError: 0, forecastOverShare: 0,
 		},
 		providers: [row("openrouter", 2), row("ollama", 1)],
 		models: [

package/test/report.test.ts

@@ -229,7 +229,7 @@ describe("buildUsageReport", () => {
 			subagentSpendUsd: 0,
 			digests: 0,
 			digestSpendUsd: 0,
-			digestInputTokens: 0,
+			digestInputTokens: 0, digestReruns: 0, forecastSamples: 0, forecastMeanError: 0, forecastOverShare: 0,
 		});
 		expect(r.providers).toEqual([]);
 		expect(r.models).toEqual([]);
@@ -291,3 +291,31 @@ describe("renderUsageReport", () => {
 		db.close();
 	});
 });
+
+describe("digest re-runs and forecast accuracy", () => {
+	test("wasted digest rows count as re-runs; forecast error is judged on clean kept rows only", () => {
+		const { db, ledger } = seeded();
+		try {
+			ledger.record(entry({ requestedModel: "digest", conversationKey: "d1", reportedUsd: 0.001, predictedUsd: 0.001 }));
+			ledger.record(entry({ requestedModel: "digest", conversationKey: "d2", reportedUsd: 0.001, predictedUsd: 0.001, wasted: true }));
+			// Two clean turns: one predicted double, one predicted half.
+			ledger.record(entry({ predictedUsd: 0.02, reportedUsd: 0.01 }));
+			ledger.record(entry({ predictedUsd: 0.005, reportedUsd: 0.01 }));
+			// Excluded from the forecast judgement: wasted, errored, no reported cost.
+			ledger.record(entry({ predictedUsd: 1, reportedUsd: 0.01, wasted: true }));
+			ledger.record(entry({ predictedUsd: 1, reportedUsd: 0.01, error: "upstream_error: 500" }));
+			ledger.record(entry({ predictedUsd: 1, reportedUsd: null }));
+			const t = buildUsageReport(db, { windowDays: 1, nowMs: NOW }).totals;
+			expect(t.digests).toBe(2);
+			expect(t.digestReruns).toBe(1);
+			expect(t.forecastSamples).toBe(2);
+			expect(t.forecastMeanError).toBeCloseTo((1 + 0.5) / 2, 6);
+			expect(t.forecastOverShare).toBeCloseTo(0.5, 6);
+			const text = renderUsageReport(buildUsageReport(db, { windowDays: 1, nowMs: NOW }));
+			expect(text).toContain("re-run rate 50% (1 fetched again in full)");
+			expect(text).toContain("forecast: mean error 75% of reported cost over 2 turns · 50% over-predicted");
+		} finally {
+			db.close();
+		}
+	});
+});