auto-model-router 0.30.3 → 0.32.0

package/test/wire-request.test.ts

@@ -23,7 +23,7 @@ function userBody(content: unknown): Record<string, unknown> {
 }
 
 describe("parseChatRequest normalization", () => {
-	test("string content and equivalent content-part array normalize to the same text", () => {
+	test("string content and equivalent content-part array normalize to the same text", async () => {
 		const fromString = parseChatRequest(userBody("hello world"), HEADERS);
 		const fromParts = parseChatRequest(
 			userBody([{ type: "text", text: "hello world" }]),
@@ -34,7 +34,7 @@ describe("parseChatRequest normalization", () => {
 		expect(fromParts.messages[0]!.images).toBe(0);
 	});
 
-	test("image parts are counted and flag hasImages", () => {
+	test("image parts are counted and flag hasImages", async () => {
 		const req = parseChatRequest(
 			userBody([
 				{ type: "text", text: "look at these" },
@@ -49,7 +49,7 @@ describe("parseChatRequest normalization", () => {
 		expect(parseChatRequest(userBody("plain"), HEADERS).hasImages).toBe(false);
 	});
 
-	test("provider prefix is stripped from model", () => {
+	test("provider prefix is stripped from model", async () => {
 		expect(parseChatRequest(userBody("hi"), HEADERS).requestedModel).toBe("auto");
 		const prefixed = parseChatRequest(
 			{ model: "auto-model-router/auto", messages: [{ role: "user", content: "hi" }] },
@@ -58,18 +58,18 @@ describe("parseChatRequest normalization", () => {
 		expect(prefixed.requestedModel).toBe("auto");
 	});
 
-	test("reads harness and omp session ids from headers, trimmed", () => {
+	test("reads harness and omp session ids from headers, trimmed", async () => {
 		const headers = new Headers({ "x-omp-harness": " prod-a ", "x-omp-session": " sess-1 " });
 		const req = parseChatRequest(userBody("hi"), headers);
 		expect(req.harnessId).toBe("prod-a");
 		expect(req.ompSessionId).toBe("sess-1");
 	});
 
-	test("omp session id defaults to empty when the header is absent", () => {
+	test("omp session id defaults to empty when the header is absent", async () => {
 		expect(parseChatRequest(userBody("hi"), HEADERS).ompSessionId).toBe("");
 	});
 
-	test("tool schemas, names, and descriptions contribute to promptBytes", () => {
+	test("tool schemas, names, and descriptions contribute to promptBytes", async () => {
 		const parameters = { type: "object", properties: { path: { type: "string" } } };
 		const withTools = parseChatRequest(
 			{
@@ -92,7 +92,7 @@ describe("parseChatRequest normalization", () => {
 		);
 	});
 
-	test("tool calls and tool results are carried into NormMessage", () => {
+	test("tool calls and tool results are carried into NormMessage", async () => {
 		const req = parseChatRequest(
 			{
 				model: "auto",
@@ -114,7 +114,7 @@ describe("parseChatRequest normalization", () => {
 		expect(req.messages[1]!.toolName).toBe("read");
 	});
 
-	test("forcedToolChoice only for objects and non-auto/none strings", () => {
+	test("forcedToolChoice only for objects and non-auto/none strings", async () => {
 		const base = userBody("hi");
 		expect(parseChatRequest(base, HEADERS).forcedToolChoice).toBe(false);
 		expect(parseChatRequest({ ...base, tool_choice: "auto" }, HEADERS).forcedToolChoice).toBe(false);
@@ -128,7 +128,7 @@ describe("parseChatRequest normalization", () => {
 		).toBe(true);
 	});
 
-	test("reasoning accepted from both spellings, omitted when absent", () => {
+	test("reasoning accepted from both spellings, omitted when absent", async () => {
 		expect(
 			parseChatRequest({ ...userBody("hi"), reasoning_effort: "high" }, HEADERS).reasoning,
 		).toBe("high");
@@ -142,7 +142,7 @@ describe("parseChatRequest normalization", () => {
 		expect("reasoning" in plain).toBe(false);
 	});
 
-	test("malformed input throws WireErrorException", () => {
+	test("malformed input throws WireErrorException", async () => {
 		expect(() => parseChatRequest(null, HEADERS)).toThrow(WireErrorException);
 		expect(() => parseChatRequest({ model: "auto", messages: [] }, HEADERS)).toThrow(WireErrorException);
 		expect(() => parseChatRequest({ messages: [{ role: "user", content: "hi" }] }, HEADERS)).toThrow(
@@ -163,7 +163,7 @@ describe("conversationKey", () => {
 	const system = { role: "system", content: "You are a coding agent." };
 	const first = { role: "user", content: "Fix the bug in main.ts" };
 
-	test("stable across later turns of the same conversation", () => {
+	test("stable across later turns of the same conversation", async () => {
 		const turn1 = parseChatRequest({ model: "auto", messages: [system, first] }, HEADERS);
 		const turn3 = parseChatRequest(
 			{
@@ -181,7 +181,7 @@ describe("conversationKey", () => {
 		expect(turn1.conversationKey).toMatch(/^[0-9a-f]{32}$/);
 	});
 
-	test("differs when the first non-system message differs", () => {
+	test("differs when the first non-system message differs", async () => {
 		const a = parseChatRequest({ model: "auto", messages: [system, first] }, HEADERS);
 		const b = parseChatRequest(
 			{ model: "auto", messages: [system, { role: "user", content: "Write a poem" }] },
@@ -192,7 +192,7 @@ describe("conversationKey", () => {
 });
 
 describe("renderUpstreamBody", () => {
-	test("two renders are independent and never mutate the original body", () => {
+	test("two renders are independent and never mutate the original body", async () => {
 		const original = {
 			model: "auto",
 			messages: [{ role: "user", content: "hi" }],
@@ -236,7 +236,7 @@ describe("renderUpstreamBody", () => {
 		expect(JSON.stringify(original)).toBe(before);
 	});
 
-	test("maxTokens lands on whichever spelling the client used", () => {
+	test("maxTokens lands on whichever spelling the client used", async () => {
 		const req = parseChatRequest(
 			{ model: "auto", messages: [{ role: "user", content: "hi" }], max_completion_tokens: 200 },
 			HEADERS,
@@ -246,13 +246,13 @@ describe("renderUpstreamBody", () => {
 		expect("max_tokens" in out).toBe(false);
 	});
 
-	test("reasoning off renders as { enabled: false }", () => {
+	test("reasoning off renders as { enabled: false }", async () => {
 		const req = parseChatRequest(userBody("hi"), HEADERS);
 		const out = req.renderUpstreamBody(mutations({ reasoning: "off" }));
 		expect(out.reasoning).toEqual({ enabled: false });
 	});
 
-	test("cache breakpoints land on named messages and promote string content to parts", () => {
+	test("cache breakpoints land on named messages and promote string content to parts", async () => {
 		const req = parseChatRequest(
 			{
 				model: "auto",
@@ -280,7 +280,7 @@ describe("renderUpstreamBody", () => {
 		]);
 	});
 
-	test("stripAssistantReasoning removes all three spellings from assistant messages only", () => {
+	test("stripAssistantReasoning removes all three spellings from assistant messages only", async () => {
 		const req = parseChatRequest(
 			{
 				model: "auto",

package/test/wire-responses.test.ts

@@ -12,7 +12,7 @@ import type { StreamEvent, TurnSummary, UpstreamChunk } from "../src/wire/types.
 const HEADERS = new Headers({ "X-Omp-Harness": "codex" });
 
 describe("responsesToChatBody", () => {
-	test("instructions, messages, function calls and their outputs become chat messages", () => {
+	test("instructions, messages, function calls and their outputs become chat messages", async () => {
 		const chat = responsesToChatBody({
 			model: "auto",
 			instructions: "Be terse.",
@@ -59,7 +59,7 @@ describe("responsesToChatBody", () => {
 		for (const k of ["instructions", "input", "store", "include", "prompt_cache_key", "max_output_tokens"]) expect(k in chat).toBe(false);
 	});
 
-	test("a string input is one user message; images survive; previous_response_id is refused", () => {
+	test("a string input is one user message; images survive; previous_response_id is refused", async () => {
 		expect(responsesToChatBody({ model: "auto", input: "hi" }).messages).toEqual([{ role: "user", content: "hi" }]);
 		const withImage = responsesToChatBody({ model: "auto", input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "what is this" }, { type: "input_image", image_url: "data:image/png;base64,AAAA" }] }] });
 		expect(withImage.messages).toEqual([{ role: "user", content: [{ type: "text", text: "what is this" }, { type: "image_url", image_url: { url: "data:image/png;base64,AAAA" } }] }]);
@@ -67,7 +67,7 @@ describe("responsesToChatBody", () => {
 		expect(() => responsesToChatBody({ model: "auto", input: [] })).toThrow(WireErrorException);
 	});
 
-	test("Codex identity is read from the body when the headers carry none", () => {
+	test("Codex identity is read from the body when the headers carry none", async () => {
 		const meta = (agent: string) => JSON.stringify({ session_id: "t1", thread_id: "t1", agent_name: agent, turn_id: "u1" });
 		const body = { model: "auto", input: "x", prompt_cache_key: "t1", client_metadata: { thread_id: "t1", session_id: "t1", "x-codex-turn-metadata": meta("/root") } };
 		const main = parseResponsesRequest(body, HEADERS);
@@ -81,7 +81,7 @@ describe("responsesToChatBody", () => {
 		expect(identityHeadersFromBody({ model: "auto", input: "x", client_metadata: { "x-codex-turn-metadata": "not json" } }, HEADERS).get("x-omp-subagent")).toBeNull();
 	});
 
-	test("parseResponsesRequest yields a routed request tagged with the wire", () => {
+	test("parseResponsesRequest yields a routed request tagged with the wire", async () => {
 		const req = parseResponsesRequest({ model: "auto-model-router/auto-cheap", input: "hello", stream: false }, HEADERS);
 		expect(req.protocol).toBe("openai-responses");
 		expect(req.requestedModel).toBe("auto-cheap");

package/tools/agentdox-e2e.ts

@@ -14,7 +14,8 @@ import { createContextBridge } from "../src/context/bridge.ts";
 import { createContextStore } from "../src/context/store.ts";
 import type { ContextResolveInput } from "../src/context/types.ts";
 import { createLogger } from "../src/util/log.ts";
-import { openDb } from "../src/util/sqlite.ts";
+import { migrateStore } from "../src/util/schema.ts";
+import { openSqlDb } from "../src/util/sql.ts";
 
 const baseUrl = process.env.AGENTDOX_URL ?? "http://localhost:3003";
 const token = process.env.AGENTDOX_TOKEN ?? "";
@@ -32,7 +33,9 @@ function check(name: string, ok: boolean, detail = ""): void {
 }
 
 const log = createLogger("warn");
-const db = openDb(":memory:");
+// A temp file rather than `:memory:`: the shim opens one store per handle.
+const db = openSqlDb(`${process.env.TMPDIR ?? "/tmp"}/agentdox-e2e-${Date.now()}.db`);
+await migrateStore(db);
 const client = createAgentDoxClient({ baseUrl, token, timeoutMs: 5_000, log });
 const bridge = createContextBridge({
 	client,

package/tools/export-benchmarks.ts

@@ -22,9 +22,9 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { loadConfig } from "../src/config/load.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
 import { computeStats } from "../src/server/http.ts";
-import { openDb } from "../src/util/sqlite.ts";
+import { openSqlDb } from "../src/util/sql.ts";
 
 const ROOT = resolve(import.meta.dir, "..");
 const DATA_PATH = join(ROOT, "site", "data", "benchmarks.json");
@@ -56,9 +56,9 @@ if (!existsSync(dbPath)) {
 	process.exit(0);
 }
 
-const db = openDb(dbPath);
+const db = openSqlDb(dbPath);
 try {
-	const stats = computeStats(createLedger(db, cfg), days === undefined ? {} : { windowDays: days });
+	const stats = await computeStats(createSqlLedger(db, cfg, { findModel: () => null }), days === undefined ? {} : { windowDays: days });
 	const perTurnUsd = stats.requests > 0 ? stats.windowSpendUsd / stats.requests : 0;
 	data.ledgerSnapshot = {
 		generatedAt: new Date(stats.generatedAtMs).toISOString().slice(0, 10),
@@ -78,5 +78,5 @@ try {
 	writeFileSync(DATA_PATH, `${JSON.stringify(data, null, 2)}\n`, "utf8");
 	console.log(`ledgerSnapshot \u2190 ${stats.requests} turns from ${dbPath} (${stats.windowDays === null ? "all time" : `${stats.windowDays}d`})`);
 } finally {
-	db.close();
+	await db.close();
 }

package/tools/ledger-parity.ts

@@ -0,0 +1,266 @@
+/**
+ * Parity: the one ledger must answer identically on both engines, reading the
+ * same production rows.
+ *
+ * The point is not that the SQL looks portable — it is that trust, latency,
+ * spend, blend, escalation cost and every report come out EQUAL, because
+ * routing decisions are made from those numbers and a front door may read a
+ * SQLite file while the router writes Postgres. Every silent bug found while
+ * porting (a `SUM()` read as a string skewing a trust score, a double-encoded
+ * JSON column nulling an escalation term, a nested `json_extract` path that
+ * SQLite tolerates and Postgres reads as NULL) was caught by comparing
+ * computed values rather than by a type error.
+ *
+ * Usage: bun tools/ledger-parity.ts <sqlite-path> [postgres-url]
+ */
+import { Database } from "bun:sqlite";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
+import { migrateStore } from "../src/util/schema.ts";
+import type { AsyncLedger } from "../src/cost/types.ts";
+import { openSqlDb, type SqlDb } from "../src/util/sql.ts";
+import { decisionEntries, exportRows, feedbackView, spendUsdSince } from "../src/cost/views.ts";
+import { buildUsageReport } from "../src/cost/report.ts";
+import { buildDailySummary, countTierChanges } from "../src/cost/summary.ts";
+
+const sqlitePath = process.argv[2] ?? "/data/router/router.db";
+const pgUrl = process.argv[3] ?? "";
+
+// Windows wide open so every row counts, and the scoped query shapes exercised.
+const cfg: RouterConfig = structuredClone(DEFAULT_CONFIG);
+cfg.filters.trustWindowDays = 0;
+cfg.filters.feedbackWeight = 1;
+cfg.filters.cacheReliabilityMinSamples = 1;
+cfg.filters.escalationCostWeight = 1;
+cfg.filters.latencyMinSamples = 1;
+
+// The source of real rows. Read-only: the harness copies out of it and
+// never writes to a live ledger.
+const db = new Database(sqlitePath, { readonly: true });
+
+const slugs = (db.query("SELECT DISTINCT slug FROM ledger WHERE slug IS NOT NULL").all() as { slug: string }[]).map((r) => r.slug);
+const harnesses = (db.query("SELECT DISTINCT harness_id FROM ledger WHERE harness_id <> '' LIMIT 2").all() as { harness_id: string }[]).map(
+	(r) => r.harness_id,
+);
+const sessions = (
+	db.query("SELECT DISTINCT omp_session_id FROM ledger WHERE omp_session_id <> '' LIMIT 2").all() as { omp_session_id: string }[]
+).map((r) => r.omp_session_id);
+
+/**
+ * Key-order-insensitive comparison. A JSON column round-tripped through
+ * Postgres' jsonb comes back with its keys reordered — jsonb does not preserve
+ * input order — which is not a difference in the value.
+ */
+function stable(value: unknown): string {
+	return JSON.stringify(value, (_key, v: unknown) =>
+		v !== null && typeof v === "object" && !Array.isArray(v)
+			? Object.fromEntries(Object.entries(v as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b)))
+			: v,
+	);
+}
+
+/**
+ * Structural comparison with a tolerance on every number, at any depth.
+ *
+ * Two engines summing the same rows in a different order land a few ULPs apart
+ * ($39.722225609861425 against ...56), which is arithmetic, not divergence. A
+ * strict compare on a nested total would report that as a mismatch and bury
+ * the real ones.
+ */
+function deepEqual(a: unknown, b: unknown, tol: number): boolean {
+	if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) <= tol * Math.max(1, Math.abs(a));
+	if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return stable(a) === stable(b);
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		return a.length === b.length && a.every((v, i) => deepEqual(v, b[i], tol));
+	}
+	const ra = a as Record<string, unknown>;
+	const rb = b as Record<string, unknown>;
+	const keys = new Set([...Object.keys(ra), ...Object.keys(rb)]);
+	for (const key of keys) if (!deepEqual(ra[key], rb[key], tol)) return false;
+	return true;
+}
+
+let checks = 0;
+let bad = 0;
+/** Which side is which in a mismatch report; set before each comparison pass. */
+let labelA = "a";
+let labelB = "b";
+function eq(label: string, a: unknown, b: unknown, tol = 1e-9): void {
+	checks++;
+	const same = deepEqual(a, b, tol);
+	if (!same) {
+		bad++;
+		console.log(`  MISMATCH ${label}\n    ${labelA}=${JSON.stringify(a)}\n    ${labelB}=${JSON.stringify(b)}`);
+	}
+}
+
+/** Copies the real rows into whichever store the unified ledger will read. */
+async function load(target: SqlDb): Promise<void> {
+	await migrateStore(target);
+	for (const table of ["ledger", "feedback", "token_calibration"]) {
+		await target.sql.unsafe(`DELETE FROM ${table}`);
+	}
+	// The json columns are TEXT in the source; Postgres wants objects, so they
+	// are parsed when the destination stores JSONB.
+	const jsonCols = new Set(["usage", "cost_breakdown", "features", "classifier_reasons", "reasons"]);
+	const copy = async (table: string): Promise<number> => {
+		const cols = (db.query(`PRAGMA table_info(${table})`).all() as { name: string }[]).map((c) => c.name);
+		const rows = db.query(`SELECT ${cols.join(", ")} FROM ${table}`).all() as Record<string, unknown>[];
+		for (let i = 0; i < rows.length; i += 500) {
+			const batch = rows.slice(i, i + 500).map((r) => {
+				const o: Record<string, unknown> = {};
+				for (const c of cols) {
+					const v = r[c] ?? null;
+					o[c] = target.dialect === "postgres" && jsonCols.has(c) && typeof v === "string" ? JSON.parse(v) : v;
+				}
+				return o;
+			});
+			await target.sql`INSERT INTO ${target.sql.unsafe(table)} ${target.sql(batch, ...cols)}`;
+		}
+		return rows.length;
+	};
+	const ledgerRows = await copy("ledger");
+	// tokenRatio reads this table, so without it the unified side reports null
+	// against a real calibrated ratio — another harness-shaped "mismatch".
+	await copy("token_calibration");
+	let feedbackRows = 0;
+	try {
+		feedbackRows = await copy("feedback");
+	} catch (err) {
+		// Never swallowed: a failed feedback copy makes the unified side read no
+		// verdicts and shows up as a trust-score "mismatch" that is really a
+		// harness bug. It cost a diagnosis once already.
+		console.log(`  feedback copy FAILED: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	console.log(`  loaded ${ledgerRows} ledger rows, ${feedbackRows} feedback rows`);
+}
+
+/**
+ * Every ported view, as one comparable value. The views moved to the shim in
+ * the same change as the ledger, so there is no synchronous version left to
+ * diff against — what matters is that the two ENGINES agree, since a front
+ * door may read a file while the router writes a database.
+ */
+async function viewsSnapshot(db: SqlDb): Promise<Record<string, unknown>> {
+	const harness = harnesses[0] ?? null;
+	// A FIXED instant: the windows are relative to "now", so two engines read a
+	// moment apart would legitimately disagree and hide a real difference.
+	const nowMs = 1_789_000_000_000;
+	const report = await buildUsageReport(db, { windowDays: 3650, nowMs });
+	const summary = await buildDailySummary(db, { nowMs });
+	return {
+		reportTotals: report.totals,
+		reportProviders: report.providers.map((r) => [r.key, r.dispatches, Number(r.spendUsd.toFixed(9)), Number(r.cacheHitRate.toFixed(9)), r.escalations, r.errors]),
+		reportModels: report.models.map((m) => [m.key, m.provider, m.dispatches, Number(m.spendUsd.toFixed(9)), m.tiers, m.feedback]),
+		reportTiers: report.tiers.map((r) => [r.key, r.dispatches, Number(r.spendUsd.toFixed(9))]),
+		reportDays: report.days.map((d) => [d.day, d.dispatches, Number(d.spendUsd.toFixed(9)), Number(d.cacheHitRate.toFixed(9))]),
+		reportAnatomy: report.anatomy,
+		summaryCurrent: summary.current,
+		summaryPrevious: summary.previous,
+		summaryTopModels: summary.topModels.map((m) => [m.slug, m.dispatches, Number(m.spendUsd.toFixed(9))]),
+		tierChanges: await countTierChanges(db, 0, ""),
+		spendAll: await spendUsdSince(db, 0, null),
+		spendHarness: harness === null ? 0 : await spendUsdSince(db, 0, [harness]),
+		spendNone: await spendUsdSince(db, 0, []),
+		exportRows: (await exportRows(db, 0, null)).map((r) => [r.day, r.harnessId, r.slug, r.scope, r.dispatches, r.promptTokens, r.cachedTokens, r.completionTokens, Number(r.spendUsd.toFixed(9)), r.escalations, r.errors]),
+		feedback: await feedbackView(db, 0, null),
+		decisions: (await decisionEntries(db, { sinceMs: 0, harness: null, limit: 25 })).map((e) => [e.id, e.slug, e.servedSlug, e.tier, e.wasted, e.feedback.length, e.costBreakdown?.total ?? null]),
+	};
+}
+
+/**
+ * Every signal the router reads off the ledger, as one comparable value.
+ *
+ * A FIXED instant throughout: `spendSince` and the spike windows are relative
+ * to "now", so two engines read a moment apart would legitimately disagree and
+ * hide a real difference.
+ */
+async function ledgerSnapshot(unified: AsyncLedger): Promise<Record<string, unknown>> {
+	const nowMs = 1_789_000_000_000;
+	const out: Record<string, unknown> = {};
+
+	for (const days of [0, 1, 7]) {
+		const since = days === 0 ? 0 : nowMs - days * 86_400_000;
+		out[`spendSince(${days}d)`] = await unified.spendSince(since);
+		for (const h of harnesses) out[`spendSince(${days}d,${h})`] = await unified.spendSince(since, h);
+	}
+
+	const esc = await unified.escalationCost(cfg.ledger.blendWindowDays);
+	out.escalationCost = esc === null ? null : [esc.samples, esc.usdPerPromptToken];
+	const blend = await unified.blendedRate(cfg.ledger.blendWindowDays);
+	out.blendedRate = blend === null ? null : [blend.sampleCount, blend.inputPerMtok, blend.outputPerMtok, blend.cacheReadPerMtok];
+
+	// The prefetch the turn path actually uses, global and per harness.
+	for (const harness of [undefined, ...harnesses]) {
+		const tag = harness ?? "global";
+		const signals = await unified.signals(slugs, harness);
+		for (const slug of slugs) {
+			const s = signals.get(slug);
+			const trust = s?.trust ?? null;
+			const latency = s?.latency ?? null;
+			out[`trust[${tag}][${slug}]`] = trust === null
+				? null
+				: [trust.attempts, trust.escalations, trust.errors, trust.successRate, trust.meanCostError];
+			out[`latency[${tag}][${slug}]`] = latency === null ? null : [latency.samples, latency.ttftMs, latency.tokensPerSec];
+		}
+	}
+
+	// Keyed by slug: row order is not part of the meaning here.
+	out.allTrust = Object.fromEntries((await unified.allTrust()).map((t) => [t.slug, [t.attempts, t.successRate]]));
+	const cache = await unified.cacheReliability(slugs);
+	out.cacheReliability = Object.fromEntries(slugs.map((s) => [s, cache.get(s) === undefined ? null : [cache.get(s)?.samples, cache.get(s)?.hitRate]]));
+
+	for (const prefix of ["ollama/", "deepseek/", "anthropic-subscription/"]) {
+		out[`providerSpendSince(${prefix})`] = await unified.providerSpendSince(prefix, 0);
+	}
+
+	// Entry round-trip: the JSON columns are where a dialect difference shows.
+	out.recentEntries = (await unified.recentEntries(25)).map((e) => [e.id, e.usage, e.reasons, e.costBreakdown ?? null, e.scope ?? null, e.wasted]);
+
+	for (const session of sessions) {
+		out[`latestForSession(${session})`] = (await unified.latestForSession(session))?.id ?? null;
+		out[`entriesForSession(${session})`] = (await unified.entriesForSession(session, 5)).map((e) => e.id);
+	}
+
+	out.softFailureSpikes = (await unified.softFailureSpikes(nowMs)).map((s) => [s.slug, s.recentRate, s.recentDispatches, s.baselineRate]);
+	for (const tokenizer of ["gpt", "claude", "qwen", "llama"]) {
+		out[`tokenRatio(${tokenizer})`] = await unified.tokenRatio(tokenizer);
+	}
+	return out;
+}
+
+const targets: { engine: string; url: string }[] = [
+	{ engine: "sqlite", url: `sqlite:///tmp/ledger-parity-${Date.now()}.db` },
+	...(pgUrl === "" ? [] : [{ engine: "postgres", url: pgUrl }]),
+];
+
+const snapshots = new Map<string, Record<string, unknown>>();
+for (const target of targets) {
+	console.log(`\n=== loading ${target.engine} ===`);
+	const store = openSqlDb(target.url);
+	await load(store);
+	const ledger = createSqlLedger(store, cfg, { findModel: () => null });
+	snapshots.set(target.engine, { ...(await ledgerSnapshot(ledger)), ...(await viewsSnapshot(store)) });
+	await store.close();
+}
+
+// Every signal and every view, engine against engine. One engine alone still
+// proves nothing was thrown: it loads the rows and computes the lot.
+const [first, ...rest] = [...snapshots.keys()];
+if (first !== undefined) {
+	const a = snapshots.get(first) as Record<string, unknown>;
+	labelA = first;
+	for (const other of rest) {
+		console.log(`\n=== ${other} vs ${first} ===`);
+		labelB = other;
+		const b = snapshots.get(other) as Record<string, unknown>;
+		for (const key of Object.keys(a)) eq(key, a[key], b[key], 1e-9);
+	}
+	if (rest.length === 0) console.log(`\n=== ${first} only: ${Object.keys(a).length} values computed, nothing to compare against ===`);
+}
+
+console.log(`\n${checks - bad}/${checks} checks equal${bad === 0 ? "" : `, ${bad} MISMATCHED`}`);
+process.exit(bad === 0 ? 0 : 1);

package/tools/replay.ts

@@ -70,7 +70,9 @@ import type { CatalogModel, CatalogSnapshot } from "../src/catalog/types.ts";
 import { loadConfig } from "../src/config/load.ts";
 import type { RouterConfig } from "../src/config/types.ts";
 import { computeCost } from "../src/cost/forecast.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
+import { prefetchTurnReads } from "../src/router/index.ts";
+import { openSqlDb } from "../src/util/sql.ts";
 import type { UsageCounts } from "../src/cost/types.ts";
 import { classifyTask, scoreHeuristic } from "../src/router/classify.ts";
 import { resolveHoldTurns } from "../src/router/explore.ts";
@@ -324,7 +326,11 @@ function snapshotFor(cfg: RouterConfig): CatalogSnapshot {
 const snapshotA = snapshotFor(cfgA);
 const snapshotB = snapshotFor(cfgB);
 const bySlug = new Map([...snapshotA.models, ...snapshotB.models].map((m) => [m.slug, m]));
-const ledger = createLedger(db, cfgA);
+// Replay reads through the engine-agnostic handle: `select` takes the ledger's
+// answers as DATA now, so each replayed turn prefetches the same reads a live
+// turn would. Read-only — nothing here writes.
+const sqlDb = openSqlDb(dbPath);
+const ledger = createSqlLedger(sqlDb, cfgA, { findModel: (slug: string) => bySlug.get(slug) ?? null });
 
 const predicate = args.where === "" ? "" : ` AND (${args.where})`;
 // Newest-first to honour --limit, then flipped to chronological so each row can
@@ -371,7 +377,7 @@ interface Outcome {
 	trail: VariantTrail;
 }
 
-function run(
+async function run(
 	cfg: RouterConfig,
 	snapshot: CatalogSnapshot,
 	row: Row,
@@ -379,7 +385,7 @@ function run(
 	prior: PriorTurn | undefined,
 	trail: VariantTrail | undefined,
 	esc: EscalationContext,
-): Outcome {
+): Promise<Outcome> {
 	const f = featuresOf(row, usage.promptTokens);
 	const req = requestOf(row, f);
 	const state = stateOf(row, prior, trail, args.warmth);
@@ -399,14 +405,16 @@ function run(
 	} else {
 		classification = scoreHeuristic(f, cfg);
 	}
+	const profile = profileOf(cfg, row.requested_model);
+	const reads = await prefetchTurnReads(ledger, req, profile, cfg, snapshot, classification.task, row.created_at_ms);
 	const decision: Decision = select({
 		req,
 		features: f,
 		classification,
-		profile: profileOf(cfg, row.requested_model),
+		profile,
 		state,
 		snapshot,
-		ledger,
+		reads,
 		cfg,
 		// The row's own clock: cache warmth and hold windows are judged against
 		// when the turn happened, not against today. Passing Date.now() here made
@@ -500,8 +508,8 @@ for (const row of rows) {
 		excludeSlugs: wasted.map((w) => w.served_slug ?? w.slug),
 	};
 	if (esc.escalateFrom !== undefined) escalationsReplayed++;
-	const a = run(cfgA, snapshotA, row, u, prior, trailA.get(row.conversation_key), esc);
-	const b = run(cfgB, snapshotB, row, u, prior, trailB.get(row.conversation_key), esc);
+	const a = await run(cfgA, snapshotA, row, u, prior, trailA.get(row.conversation_key), esc);
+	const b = await run(cfgB, snapshotB, row, u, prior, trailB.get(row.conversation_key), esc);
 	trailA.set(row.conversation_key, a.trail);
 	trailB.set(row.conversation_key, b.trail);