auto-model-router 0.30.3 → 0.32.0

package/test/trust-window.test.ts

@@ -1,9 +1,13 @@
 import { describe, expect, test } from "bun:test";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { migrateStore } from "../src/util/schema.ts";
+import { openSqlDb } from "../src/util/sql.ts";
 
 import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
 import type { LedgerEntry } from "../src/cost/types.ts";
-import { openDb } from "../src/util/sqlite.ts";
 
 /**
  * `filters.trustWindowDays` bounds the per-slug trust aggregate, which otherwise
@@ -66,69 +70,70 @@ function entry(over: Partial<LedgerEntry>): LedgerEntry {
 }
 
 /** Old rows: half of them failures. Recent rows: all clean. */
-function seed(windowDays: number) {
+async function seed(windowDays: number) {
 	const cfg = cfgWith(windowDays);
-	const db = openDb(":memory:");
-	const ledger = createLedger(db, cfg);
+	const db = openSqlDb(join(tmpdir(), `t-trust-window.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
+	const ledger = createSqlLedger(db, cfg, { findModel: () => null });
 	const now = Date.now();
 	for (let i = 0; i < 10; i++) {
-		ledger.record(
+		await ledger.record(
 			entry({
 				createdAtMs: now - 30 * DAY,
 				...(i % 2 === 0 ? { error: "server_error: boom", errorKind: "server_error" } : {}),
 			}),
 		);
 	}
-	for (let i = 0; i < 10; i++) ledger.record(entry({ createdAtMs: now - 1 * DAY }));
+	for (let i = 0; i < 10; i++) await ledger.record(entry({ createdAtMs: now - 1 * DAY }));
 	return { db, ledger, cfg };
 }
 
 describe("filters.trustWindowDays", () => {
-	test("0 means all-time: every row counts", () => {
-		const { db, ledger } = seed(0);
-		const trust = ledger.trust("vendor/model");
+	test("0 means all-time: every row counts", async () => {
+		const { db, ledger } = await seed(0);
+		const trust = await ledger.trust("vendor/model");
 		expect(trust?.attempts).toBe(20);
 		expect(trust?.errors).toBe(5);
-		db.close();
+		await db.close();
 	});
 
-	test("a window excludes rows older than it", () => {
-		const { db, ledger } = seed(7);
-		const trust = ledger.trust("vendor/model");
+	test("a window excludes rows older than it", async () => {
+		const { db, ledger } = await seed(7);
+		const trust = await ledger.trust("vendor/model");
 		// Only the 10 recent, clean rows remain.
 		expect(trust?.attempts).toBe(10);
 		expect(trust?.errors).toBe(0);
-		db.close();
+		await db.close();
 	});
 
-	test("the window moves the success rate, which is why it is opt-in", () => {
-		const all = seed(0);
-		const windowed = seed(7);
-		const allTrust = all.ledger.trust("vendor/model");
-		const winTrust = windowed.ledger.trust("vendor/model");
+	test("the window moves the success rate, which is why it is opt-in", async () => {
+		const all = await seed(0);
+		const windowed = await seed(7);
+		const allTrust = await all.ledger.trust("vendor/model");
+		const winTrust = await windowed.ledger.trust("vendor/model");
 		expect(allTrust?.successRate).toBeLessThan(winTrust?.successRate ?? 0);
-		all.db.close();
-		windowed.db.close();
+		await all.db.close();
+		await windowed.db.close();
 	});
 
-	test("is read per call, so a hot-reloaded edit takes effect immediately", () => {
-		const { db, ledger, cfg } = seed(0);
-		expect(ledger.trust("vendor/model")?.attempts).toBe(20);
+	test("is read per call, so a hot-reloaded edit takes effect immediately", async () => {
+		const { db, ledger, cfg } = await seed(0);
+		expect((await ledger.trust("vendor/model"))?.attempts).toBe(20);
 		// Hot reload mutates the shared config object in place.
 		cfg.filters.trustWindowDays = 7;
-		expect(ledger.trust("vendor/model")?.attempts).toBe(10);
-		db.close();
+		expect((await ledger.trust("vendor/model"))?.attempts).toBe(10);
+		await db.close();
 	});
 
-	test("allTrust honours the same window", () => {
-		const { db, ledger } = seed(7);
-		const rows = ledger.allTrust();
+	test("allTrust honours the same window", async () => {
+		const { db, ledger } = await seed(7);
+		const rows = await ledger.allTrust();
 		expect(rows).toHaveLength(1);
 		expect(rows[0]?.attempts).toBe(10);
-		db.close();
+		await db.close();
 	});
 
-	test("ships disabled, so the default install is unchanged", () => {
+	test("ships disabled, so the default install is unchanged", async () => {
 		// DEFAULT_CONFIG, not loadConfig: loadConfig reads the machine's real
 		// config.yml, which has broken this suite before.
 		expect(DEFAULT_CONFIG.filters.trustWindowDays).toBe(0);

package/test/turn.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { fakeLedger } from "./fakes.ts";
 import { createDisabledBridge } from "../src/context/bridge.ts";
 import type { ContextBridge, ContextResolveInput, TurnRecord } from "../src/context/types.ts";
 import type { CatalogModel, CatalogSource } from "../src/catalog/types.ts";
 import type { EscalationConfig, RouterConfig } from "../src/config/types.ts";
-import { EMPTY_USAGE, type Ledger, type LedgerEntry, type UsageCounts } from "../src/cost/types.ts";
+import { EMPTY_USAGE, type AsyncLedger, type LedgerEntry, type UsageCounts } from "../src/cost/types.ts";
 import type {
 	ConversationState,
 	ConversationStore,
@@ -14,6 +15,7 @@ import type {
 	Tier,
 } from "../src/router/types.ts";
 import { runTurn } from "../src/server/turn.ts";
+import { BudgetExceededError } from "../src/router/select.ts";
 import { parseMessagesRequest } from "../src/wire/anthropic/messages.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 import { UpstreamError, type DispatchOptions, type UpstreamClient } from "../src/upstream/types.ts";
@@ -241,21 +243,21 @@ function mkRouter(decisions: Decision[]): { router: Router; calls: { attempt: nu
 	return { router, calls };
 }
 
-function mkLedger(): { ledger: Ledger; entries: LedgerEntry[] } {
+function mkLedger(): { ledger: AsyncLedger; entries: LedgerEntry[] } {
 	const entries: LedgerEntry[] = [];
-	const ledger: Ledger = {
-		record: (e) => {
+	const ledger: AsyncLedger = fakeLedger({
+		record: async (e) => {
 			entries.push(e);
 		},
-		conversationSpend: () => 0,
-		spendSince: () => 0,
-		blendedRate: () => null,
-		latency: () => null,
-		trust: () => null,
-		allTrust: () => [],
-		tokenRatio: () => null,
-		recentEntries: () => [],
-	};
+		conversationSpend: async () => 0,
+		spendSince: async () => 0,
+		blendedRate: async () => null,
+		latency: async () => null,
+		trust: async () => null,
+		allTrust: async () => [],
+		tokenRatio: async () => null,
+		recentEntries: async () => [],
+	});
 	return { ledger, entries };
 }
 
@@ -268,8 +270,8 @@ function mkConversations(): {
 	// Mirrors the real store: money accumulates here, NOT through `save`.
 	const accrued = new Map<string, { spentUsd: number; escalations: number }>();
 	const store: ConversationStore = {
-		get: (k) => map.get(k) ?? null,
-		load: (k) => {
+		get: async (k) => map.get(k) ?? null,
+		load: async (k) => {
 			const existing = map.get(k);
 			if (existing) return existing;
 			const fresh: ConversationState = {
@@ -292,16 +294,16 @@ function mkConversations(): {
 			map.set(k, fresh);
 			return fresh;
 		},
-		save: (s) => {
+		save: async (s) => {
 			map.set(s.key, s);
 		},
-		accrue: (k, d) => {
+		accrue: async (k, d) => {
 			const cur = accrued.get(k) ?? { spentUsd: 0, escalations: 0 };
 			cur.spentUsd += d.spentUsd ?? 0;
 			cur.escalations += d.escalations ?? 0;
 			accrued.set(k, cur);
 		},
-		prune: () => 0,
+		prune: async () => 0,
 	};
 	return { store, map, accrued };
 }
@@ -480,6 +482,36 @@ describe("runTurn", () => {
 		expect(entries[0]!.error).toContain("auth");
 	});
 
+	test("a budget refusal answers 402 budget_exceeded, not a 500", async () => {
+		// `reject` mode is a refusal the router MEANS. Reported as a 500 it reads
+		// as "the router broke" — and a team front door relaying it sends a
+		// capped deployment looking for a crash. Anything else from `route()` is
+		// still an internal failure.
+		const refusing: Router = { route: () => Promise.reject(new BudgetExceededError("24h spend $0.10 > per-day budget $0.05")) };
+		const { upstream } = mkUpstream([{ kind: "chunks", chunks: [] }]);
+		const { ledger, entries } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, errors, finishes } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router: refusing, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toEqual([{ status: 402, code: "budget_exceeded", message: "24h spend $0.10 > per-day budget $0.05" }]);
+		expect(finishes).toHaveLength(0);
+		expect(entries).toHaveLength(0); // refused before dispatch: no turn to record
+	});
+
+	test("an unexpected routing failure is still a 500", async () => {
+		const broken: Router = { route: () => Promise.reject(new Error("catalog exhausted")) };
+		const { upstream } = mkUpstream([{ kind: "chunks", chunks: [] }]);
+		const { ledger } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, errors } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router: broken, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toEqual([{ status: 500, code: "router_error", message: "catalog exhausted" }]);
+	});
+
 	test("a 429 before commit fails over to a different model in the same tier", async () => {
 		const { router, calls } = mkRouter([
 			mkDecision("trivial", "cheap/model", { escalateTo: "simple" }),
@@ -627,7 +659,7 @@ describe("agentdox write-back sees the shape of the turn", () => {
 					records.push(rec);
 				},
 				flush: () => Promise.resolve(),
-				pruneBlocks: () => 0,
+				pruneBlocks: async () => 0,
 				close: () => {},
 			},
 		};
@@ -706,7 +738,7 @@ describe("agentdox injection sees the shape of the turn", () => {
 				},
 				recordTurn: () => {},
 				flush: () => Promise.resolve(),
-				pruneBlocks: () => 0,
+				pruneBlocks: async () => 0,
 				close: () => {},
 			},
 		};
@@ -736,7 +768,7 @@ describe("agentdox injection sees the shape of the turn", () => {
 
 		expect(errors).toHaveLength(0);
 		expect(resolves).toHaveLength(0);
-		expect(store.load(req.conversationKey).contextVersion).toBeNull();
+		expect((await store.load(req.conversationKey)).contextVersion).toBeNull();
 	});
 
 	test("an agent turn with tools is injected", async () => {
@@ -748,7 +780,7 @@ describe("agentdox injection sees the shape of the turn", () => {
 
 		expect(errors).toHaveLength(0);
 		expect(resolves).toHaveLength(1);
-		expect(store.load(req.conversationKey).contextVersion).toBe("v1");
+		expect((await store.load(req.conversationKey)).contextVersion).toBe("v1");
 	});
 
 	test("the layer headers and the harness id reach resolve, and the harness id reaches the record", async () => {
@@ -769,7 +801,7 @@ describe("agentdox injection sees the shape of the turn", () => {
 				records.push(rec);
 			},
 			flush: () => Promise.resolve(),
-			pruneBlocks: () => 0,
+			pruneBlocks: async () => 0,
 			close: () => {},
 		};
 		const req: NormRequest = { ...mkReq(), harnessId: "u_ada", agentdoxScope: "proj", agentdoxGroup: "group.g1", agentdoxPersonal: "proj.u.u_ada", tools: [AGENT_TOOL] };

package/test/upstreams.test.ts

@@ -48,7 +48,7 @@ function sse(frames: string[]): Response {
 }
 
 describe("upstreams config", () => {
-	test("an entry is accepted with defaults filled; a reserved or malformed id is refused", () => {
+	test("an entry is accepted with defaults filled; a reserved or malformed id is refused", async () => {
 		const ok = configInputSchema.safeParse({ upstreams: [{ id: "openai-direct", kind: "openai", baseUrl: "https://api.openai.com/v1", apiKey: "sk", models: [{ id: "gpt-4o", input: 2.5, output: 10 }] }] });
 		expect(ok.success).toBe(true);
 		const full = completeUpstreamEntry({ id: "vllm", kind: "openai", baseUrl: "http://vllm:8000/v1", models: [] });
@@ -61,7 +61,7 @@ describe("upstreams config", () => {
 		expect(configInputSchema.safeParse({ upstreams: [{ id: "x", kind: "bedrock", baseUrl: "https://x", models: [] }] }).success).toBe(false);
 	});
 
-	test("a live patch replaces the list and completes sparse entries", () => {
+	test("a live patch replaces the list and completes sparse entries", async () => {
 		const cfg = cfgWith([]);
 		const changed = applyConfigPatch(cfg, { upstreams: [{ id: "azure-eu", kind: "azure", baseUrl: "https://r.openai.azure.com", apiKey: "k", models: [{ id: "gpt-4o-deploy", input: 2.5, output: 10 }] }] } as never);
 		expect(changed).toEqual(["upstreams"]);
@@ -72,7 +72,7 @@ describe("upstreams config", () => {
 describe("static catalog", () => {
 	const twins = [normalizeCatalogModel(orRaw("openai/gpt-4o", 70, true))!, normalizeCatalogModel(orRaw("anthropic/claude-sonnet-4", 80))!];
 
-	test("models are priced per token, namespaced by the entry id, and borrow the twin's scores and modalities", () => {
+	test("models are priced per token, namespaced by the entry id, and borrow the twin's scores and modalities", async () => {
 		const e = entry({ id: "openai-direct", kind: "openai", models: [{ id: "gpt-4o", input: 2.5, output: 10, cachedInput: 1.25 }, { id: "custom-ft", input: 3, output: 12, contextLength: 32_000, quality: { coding: 55 }, supportsTools: false }] });
 		const models = buildUpstreamModels(e, twins);
 		expect(models.map((m) => m.slug)).toEqual(["openai-direct/gpt-4o", "openai-direct/custom-ft"]);
@@ -91,7 +91,7 @@ describe("static catalog", () => {
 		expect(ft.inputModalities).toEqual(["text"]);
 	});
 
-	test("an explicit twin wins over the name match; an anthropic entry defaults to the Claude tokenizer", () => {
+	test("an explicit twin wins over the name match; an anthropic entry defaults to the Claude tokenizer", async () => {
 		const e = entry({ id: "anthropic-direct", kind: "anthropic", models: [{ id: "claude-sonnet-4-20250514", input: 3, output: 15, twin: "anthropic/claude-sonnet-4", cacheWrite: 3.75, cachedInput: 0.3 }, { id: "claude-unknown", input: 1, output: 5 }] });
 		const [sonnet, unknown] = buildUpstreamModels(e, twins);
 		expect(sonnet!.quality.coding).toBe(80);
@@ -100,7 +100,7 @@ describe("static catalog", () => {
 		expect(unknown!.tokenizer).toBe("Claude");
 	});
 
-	test("a subscription model with no price of its own inherits the twin's, so it never ranks as free", () => {
+	test("a subscription model with no price of its own inherits the twin's, so it never ranks as free", async () => {
 		// A Pro/Max subscription publishes no per-token rates, and pricing it at zero would beat
 		// every model in every tier outright. The twin sells the same weights, so it is the rate.
 		const e = entry({ id: "anthropic-subscription", kind: "anthropic", costBias: 0.1, models: [{ id: "claude-sonnet-4-20250514", twin: "anthropic/claude-sonnet-4" }] });
@@ -117,7 +117,7 @@ describe("static catalog", () => {
 		expect(buildUpstreamModels(free, twins)[0]!.price).toEqual({ prompt: 0, completion: 0 });
 	});
 
-	test("the source rebuilds only when the entries or the OpenRouter models change", () => {
+	test("the source rebuilds only when the entries or the OpenRouter models change", async () => {
 		const cfg = cfgWith([entry({ id: "vllm", kind: "openai" })]);
 		const src = createStaticCatalogSource(cfg);
 		const first = src.get(twins);
@@ -157,7 +157,7 @@ describe("dispatch by slug prefix", () => {
 		expect(namedUpstreamOf("openai-direct/gpt-4o", ["openai-direct"])).toBe("openai-direct");
 	});
 
-	test("the ledger names the provider of a slug from the known ids", () => {
+	test("the ledger names the provider of a slug from the known ids", async () => {
 		setKnownUpstreamIds(["azure-eu", "bad id"]);
 		expect(providerOfSlug("azure-eu/gpt-4o")).toBe("azure-eu");
 		expect(providerOfSlug("openai/gpt-4o")).toBe("openrouter");
@@ -168,7 +168,7 @@ describe("dispatch by slug prefix", () => {
 });
 
 describe("the OpenAI-compatible client", () => {
-	test("the body loses the router's OpenRouter dialect: prefix, cascade, session, cache markers; reasoning becomes reasoning_effort", () => {
+	test("the body loses the router's OpenRouter dialect: prefix, cascade, session, cache markers; reasoning becomes reasoning_effort", async () => {
 		const out = toCompatBody("vllm", { model: "vllm/llama", models: ["vllm/llama", "vllm/other"], session_id: "s", stream: true, reasoning: { effort: "xhigh" }, messages: [{ role: "system", content: [{ type: "text", text: "sys", cache_control: { type: "ephemeral" } }] }, { role: "user", content: "hi" }] });
 		expect(out.model).toBe("llama");
 		expect(out.models).toBeUndefined();
@@ -180,7 +180,7 @@ describe("the OpenAI-compatible client", () => {
 		expect(toCompatBody("vllm", { model: "vllm/llama", reasoning: { enabled: false } }).reasoning_effort).toBeUndefined();
 	});
 
-	test("endpoints: OpenAI bears a token; Azure names the deployment in the path and keys with api-key", () => {
+	test("endpoints: OpenAI bears a token; Azure names the deployment in the path and keys with api-key", async () => {
 		const oa = compatEndpoint(entry({ id: "openai-direct", kind: "openai", baseUrl: "https://api.openai.com/v1/", headers: { "x-org": "o" } }), "gpt-4o");
 		expect(oa.url).toBe("https://api.openai.com/v1/chat/completions");
 		expect(oa.headers).toMatchObject({ authorization: "Bearer sk-x", "x-org": "o" });
@@ -190,7 +190,7 @@ describe("the OpenAI-compatible client", () => {
 		expect(az.headers.authorization).toBeUndefined();
 	});
 
-	test("statuses: OpenAI's insufficient_quota 429 is the account, a plain 429 the moment; 400 context is final", () => {
+	test("statuses: OpenAI's insufficient_quota 429 is the account, a plain 429 the moment; 400 context is final", async () => {
 		expect(classifyCompatStatus("x", 429, { error: { code: "insufficient_quota", message: "You exceeded your current quota" } })).toMatchObject({ kind: "quota", retryable: true });
 		expect(classifyCompatStatus("x", 429, { error: { message: "Rate limit reached" } })).toMatchObject({ kind: "rate_limit", retryable: true });
 		expect(classifyCompatStatus("x", 400, { error: { message: "This model's maximum context length is 8192 tokens" } })).toMatchObject({ kind: "context_length", retryable: false });
@@ -246,7 +246,7 @@ describe("the OpenAI-compatible client", () => {
 });
 
 describe("the Anthropic client", () => {
-	test("the request: system blocks keep cache markers, turns alternate, tools and results map, thinking follows the effort", () => {
+	test("the request: system blocks keep cache markers, turns alternate, tools and results map, thinking follows the effort", async () => {
 		const body = {
 			model: "anthropic-direct/claude-sonnet-4",
 			stream: true,
@@ -286,7 +286,7 @@ describe("the Anthropic client", () => {
 		expect(plain.temperature).toBe(0.2);
 	});
 
-	test("the stream: message_start opens, text and tool blocks become chunks, message_delta closes with usage in the OpenAI convention", () => {
+	test("the stream: message_start opens, text and tool blocks become chunks, message_delta closes with usage in the OpenAI convention", async () => {
 		const t = createAnthropicTranslator("anthropic-direct/claude-sonnet-4");
 		const push = (event: string, data: Record<string, unknown>) => t.push({ event, data: JSON.stringify(data) });
 		const start = push("message_start", { type: "message_start", message: { id: "msg_1", model: "claude-sonnet-4-20250514", usage: { input_tokens: 100, cache_read_input_tokens: 40, cache_creation_input_tokens: 10 } } })!;
@@ -380,7 +380,7 @@ describe("the Anthropic client", () => {
 		};
 		const cfg = cfgWith([entry({ id: "sub", kind: "anthropic", auth: "oauth-bearer", baseUrl: "https://api.anthropic.com", apiKey: "sk-ant-oat01-x", models: [{ id: "claude-sonnet-5", input: 0, output: 0 }] })]);
 		const drain = async (messages: unknown[]): Promise<void> => {
-			const d = await createAnthropicClient(cfg, "sub", fetchImpl).dispatch({ body: { model: "sub/claude-sonnet-5", messages, max_tokens: 16 }, sessionId: "s", signal: new AbortController().signal });
+			const d = await (await createAnthropicClient(cfg, "sub", fetchImpl)).dispatch({ body: { model: "sub/claude-sonnet-5", messages, max_tokens: 16 }, sessionId: "s", signal: new AbortController().signal });
 			for await (const c of d.chunks) void c;
 		};
 		await drain([{ role: "user", content: "ping" }]);

package/test/views.test.ts

@@ -4,12 +4,12 @@ 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 type { LedgerEntry } from "../src/cost/types.ts";
 import { exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../src/cost/views.ts";
 import { startServer, type StartedServer } from "../src/server/http.ts";
-import { openDb } from "../src/util/sqlite.ts";
+import { jsonParam, openSqlDb, type SqlDb } from "../src/util/sql.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
+import { migrateStore } from "../src/util/schema.ts";
 
 /**
  * The ledger views a front door reads instead of the ledger file: spend over
@@ -58,48 +58,64 @@ function entry(over: Partial<LedgerEntry>): LedgerEntry {
 	} as LedgerEntry;
 }
 
-function seeded() {
+async function seeded(): Promise<SqlDb> {
 	const cfg = structuredClone(DEFAULT_CONFIG);
-	cfg.ledger.path = ":memory:";
-	const db = openDb(":memory:");
-	const ledger = createLedger(db, cfg);
-	const feedback = createFeedbackStore(db);
-	ledger.record(entry({ id: "l1", harnessId: "u_ada", scope: "acme.api", slug: "anthropic/claude-sonnet-5", servedSlug: "anthropic/claude-sonnet-5", predictedUsd: 0.01, reportedUsd: 0.012 }));
-	ledger.record(entry({ id: "l2", harnessId: "u_ada", scope: "acme.web", slug: "anthropic/claude-sonnet-5", servedSlug: null, predictedUsd: 0.01, reportedUsd: null, escalationSignal: "circular" }));
-	ledger.record(entry({ id: "l3", harnessId: "u_bob", scope: "acme.api", slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", predictedUsd: 0.001, reportedUsd: 0.001, error: "boom" }));
-	ledger.record(entry({ id: "l4", harnessId: "u_bob", requestedModel: "digest", slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", predictedUsd: 0.5, reportedUsd: 0.5 }));
-	ledger.record(entry({ id: "l5", harnessId: "u_bob", createdAtMs: NOW - 40 * DAY, slug: "ollama/glm-5.3-flash", predictedUsd: 5, reportedUsd: 5 }));
-	feedback.record({ ledgerId: "l1", ompSessionId: "s", slug: "anthropic/claude-sonnet-5", tier: "simple", verdict: "good", note: "" }, NOW - 1000);
-	feedback.record({ ledgerId: "l2", ompSessionId: "s", slug: "anthropic/claude-sonnet-5", tier: "simple", verdict: "bad", note: "" }, NOW - 900);
-	feedback.record({ ledgerId: "l3", ompSessionId: "s", slug: "ollama/glm-5.3-flash", tier: "simple", verdict: "bad", note: "looped" }, NOW - 800);
+	// A file, not :memory:, because the views read through their OWN handle on
+	// the same store — which is the arrangement in a real deployment, and what
+	// an in-memory database cannot represent.
+	const path = join(tmpdir(), `views-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+	cfg.ledger.path = path;
+	const db = openSqlDb(path);
+	await migrateStore(db);
+	const ledger = createSqlLedger(db, cfg, { findModel: () => null });
+	const feedback = {
+		record: async (
+			f: { ledgerId: string; ompSessionId: string; slug: string; tier: string; verdict: string; note: string },
+			atMs: number,
+		): Promise<void> => {
+			await db.sql`INSERT INTO feedback (id, ledger_id, omp_session_id, slug, tier, verdict, note, created_at_ms)
+				VALUES (${crypto.randomUUID()}, ${f.ledgerId}, ${f.ompSessionId}, ${f.slug}, ${f.tier}, ${f.verdict}, ${f.note}, ${atMs})`;
+		},
+	};
+	await ledger.record(entry({ id: "l1", harnessId: "u_ada", scope: "acme.api", slug: "anthropic/claude-sonnet-5", servedSlug: "anthropic/claude-sonnet-5", predictedUsd: 0.01, reportedUsd: 0.012 }));
+	await ledger.record(entry({ id: "l2", harnessId: "u_ada", scope: "acme.web", slug: "anthropic/claude-sonnet-5", servedSlug: null, predictedUsd: 0.01, reportedUsd: null, escalationSignal: "circular" }));
+	await ledger.record(entry({ id: "l3", harnessId: "u_bob", scope: "acme.api", slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", predictedUsd: 0.001, reportedUsd: 0.001, error: "boom" }));
+	await ledger.record(entry({ id: "l4", harnessId: "u_bob", requestedModel: "digest", slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", predictedUsd: 0.5, reportedUsd: 0.5 }));
+	await ledger.record(entry({ id: "l5", harnessId: "u_bob", createdAtMs: NOW - 40 * DAY, slug: "ollama/glm-5.3-flash", predictedUsd: 5, reportedUsd: 5 }));
+	await feedback.record({ ledgerId: "l1", ompSessionId: "s", slug: "anthropic/claude-sonnet-5", tier: "simple", verdict: "good", note: "" }, NOW - 1000);
+	await feedback.record({ ledgerId: "l2", ompSessionId: "s", slug: "anthropic/claude-sonnet-5", tier: "simple", verdict: "bad", note: "" }, NOW - 900);
+	await feedback.record({ ledgerId: "l3", ompSessionId: "s", slug: "ollama/glm-5.3-flash", tier: "simple", verdict: "bad", note: "looped" }, NOW - 800);
 	return db;
 }
 
 describe("ledger views", () => {
-	const db = seeded();
+	let db: SqlDb;
+	beforeAll(async () => {
+		db = await seeded();
+	});
 	const since = NOW - DAY;
 
-	test("spend over a harness set, everything, or nothing", () => {
-		expect(spendUsdSince(db, since, ["u_ada"])).toBeCloseTo(0.022, 6); // reported where present, predicted otherwise
-		expect(spendUsdSince(db, since, ["u_ada", "u_bob"])).toBeCloseTo(0.523, 6); // the digest row counts as spend
-		expect(spendUsdSince(db, since, null)).toBeCloseTo(0.523, 6);
-		expect(spendUsdSince(db, NOW - 60 * DAY, null)).toBeCloseTo(5.523, 6);
-		expect(spendUsdSince(db, since, [])).toBe(0);
+	test("spend over a harness set, everything, or nothing", async () => {
+		expect(await spendUsdSince(db, since, ["u_ada"])).toBeCloseTo(0.022, 6); // reported where present, predicted otherwise
+		expect(await spendUsdSince(db, since, ["u_ada", "u_bob"])).toBeCloseTo(0.523, 6); // the digest row counts as spend
+		expect(await spendUsdSince(db, since, null)).toBeCloseTo(0.523, 6);
+		expect(await spendUsdSince(db, NOW - 60 * DAY, null)).toBeCloseTo(5.523, 6);
+		expect(await spendUsdSince(db, since, [])).toBe(0);
 	});
 
-	test("spend narrowed to one context scope, so a front door charges a project", () => {
+	test("spend narrowed to one context scope, so a front door charges a project", async () => {
 		// l1 (0.012, u_ada) and l3 (0.001, u_bob) carried acme.api; l2 (0.01 predicted) carried acme.web.
-		expect(spendUsdSince(db, since, null, "acme.api")).toBeCloseTo(0.013, 6);
-		expect(spendUsdSince(db, since, null, "acme.web")).toBeCloseTo(0.01, 6);
-		expect(spendUsdSince(db, since, ["u_ada"], "acme.api")).toBeCloseTo(0.012, 6); // harness and scope compose
-		expect(spendUsdSince(db, since, ["u_bob"], "acme.web")).toBe(0);
-		expect(spendUsdSince(db, since, null, "nope")).toBe(0);
-		expect(spendUsdSince(db, since, null, "")).toBeCloseTo(0.523, 6); // no scope given: every turn, scoped or not
-		expect(spendUsdSince(db, since, [], "acme.api")).toBe(0);
+		expect(await spendUsdSince(db, since, null, "acme.api")).toBeCloseTo(0.013, 6);
+		expect(await spendUsdSince(db, since, null, "acme.web")).toBeCloseTo(0.01, 6);
+		expect(await spendUsdSince(db, since, ["u_ada"], "acme.api")).toBeCloseTo(0.012, 6); // harness and scope compose
+		expect(await spendUsdSince(db, since, ["u_bob"], "acme.web")).toBe(0);
+		expect(await spendUsdSince(db, since, null, "nope")).toBe(0);
+		expect(await spendUsdSince(db, since, null, "")).toBeCloseTo(0.523, 6); // no scope given: every turn, scoped or not
+		expect(await spendUsdSince(db, since, [], "acme.api")).toBe(0);
 	});
 
-	test("feedback by model with distinct judges, scoped by harness", () => {
-		const all = feedbackView(db, since, null);
+	test("feedback by model with distinct judges, scoped by harness", async () => {
+		const all = await feedbackView(db, since, null);
 		expect(all.byModel).toEqual([
 			{ slug: "anthropic/claude-sonnet-5", good: 1, bad: 1, judges: 1 },
 			{ slug: "ollama/glm-5.3-flash", good: 0, bad: 1, judges: 1 },
@@ -109,12 +125,12 @@ describe("ledger views", () => {
 			["u_ada", "bad", ""],
 			["u_ada", "good", ""],
 		]);
-		expect(feedbackView(db, since, ["u_bob"]).byModel).toEqual([{ slug: "ollama/glm-5.3-flash", good: 0, bad: 1, judges: 1 }]);
-		expect(feedbackView(db, since, []).recent).toEqual([]);
+		expect((await feedbackView(db, since, ["u_bob"])).byModel).toEqual([{ slug: "ollama/glm-5.3-flash", good: 0, bad: 1, judges: 1 }]);
+		expect((await feedbackView(db, since, [])).recent).toEqual([]);
 	});
 
-	test("export rows by day, harness, served model and scope; digest and old rows out; CSV quoting", () => {
-		const rows = exportRows(db, since, null);
+	test("export rows by day, harness, served model and scope; digest and old rows out; CSV quoting", async () => {
+		const rows = await exportRows(db, since, null);
 		// u_ada's two turns are one model on one day but two projects, so they no longer share a row.
 		expect(rows).toHaveLength(3);
 		expect(rows[0]).toMatchObject({ day: "2026-09-07", harnessId: "u_ada", slug: "anthropic/claude-sonnet-5", scope: "acme.api", provider: "openrouter", dispatches: 1, promptTokens: 1000, cachedTokens: 400, completionTokens: 50, escalations: 0, errors: 0 });
@@ -122,10 +138,10 @@ describe("ledger views", () => {
 		expect(rows[1]).toMatchObject({ harnessId: "u_ada", scope: "acme.web", dispatches: 1, escalations: 1 });
 		expect(rows[1]!.spendUsd).toBeCloseTo(0.01, 6);
 		expect(rows[2]).toMatchObject({ harnessId: "u_bob", scope: "acme.api", provider: "ollama", dispatches: 1, errors: 1 });
-		expect(exportRows(db, since, ["u_bob"])).toHaveLength(1);
-		expect(exportRows(db, since, [])).toEqual([]);
+		expect(await exportRows(db, since, ["u_bob"])).toHaveLength(1);
+		expect(await exportRows(db, since, [])).toEqual([]);
 		// A turn that carried no scope groups under "": what every row written before v18 does.
-		expect(exportRows(db, NOW - 60 * DAY, ["u_bob"]).map((r) => r.scope).sort()).toEqual(["", "acme.api"]);
+		expect((await exportRows(db, NOW - 60 * DAY, ["u_bob"])).map((r) => r.scope).sort()).toEqual(["", "acme.api"]);
 		const csv = exportCsv([{ ...rows[0]!, harnessId: 'ada, "L"' }]);
 		expect(csv.split("\n")[0]).toBe("day,harness,model,provider,dispatches,prompt_tokens,cached_tokens,completion_tokens,spend_usd,escalations,errors,scope");
 		expect(csv.split("\n")[1]).toBe('2026-09-07,"ada, ""L""",anthropic/claude-sonnet-5,openrouter,1,1000,400,50,0.012000,0,0,acme.api');
@@ -138,16 +154,20 @@ describe("ledger views", () => {
 describe("view routes", () => {
 	let handle: StartedServer;
 	const dir = mkdtempSync(join(tmpdir(), "amr-views-"));
-	beforeAll(() => {
+	beforeAll(async () => {
 		const cfg = structuredClone(DEFAULT_CONFIG);
 		cfg.server.host = "127.0.0.1";
 		cfg.server.port = 0;
 		cfg.server.apiKey = "k";
 		cfg.ledger.path = join(dir, "router.db");
 		// Seed through the ledger on the same file before the server opens it.
-		const db = openDb(cfg.ledger.path);
-		createLedger(db, cfg).record(entry({ id: "r1", createdAtMs: Date.now() - 1000, harnessId: "u_x", scope: "acme.api", predictedUsd: 0.2, reportedUsd: 0.25 }));
-		db.close();
+		const db = openSqlDb(cfg.ledger.path);
+		await migrateStore(db);
+		const seed = createSqlLedger(db, cfg, { findModel: () => null });
+		await seed.record(
+			entry({ id: "r1", createdAtMs: Date.now() - 1000, harnessId: "u_x", scope: "acme.api", predictedUsd: 0.2, reportedUsd: 0.25 }),
+		);
+		await db.close();
 		handle = startServer(cfg);
 	});
 	afterAll(async () => {
@@ -190,12 +210,15 @@ describe("view routes", () => {
 });
 
 describe("decision entries", () => {
-	const db = seeded();
+	let db: SqlDb;
+	beforeAll(async () => {
+		db = await seeded();
+	});
 	const since = NOW - DAY;
 
-	test("newest first over a harness set, with the verdicts given on each turn", () => {
+	test("newest first over a harness set, with the verdicts given on each turn", async () => {
 		const { decisionEntries } = require("../src/cost/views.ts") as typeof import("../src/cost/views.ts");
-		const ada = decisionEntries(db, { sinceMs: since, harness: ["u_ada"] });
+		const ada = await decisionEntries(db, { sinceMs: since, harness: ["u_ada"] });
 		expect(ada.map((e) => e.id)).toEqual(["l1", "l2"]); // same instant in the fixture; insertion order within it is stable
 		expect(ada.find((e) => e.id === "l1")?.feedback).toEqual([{ verdict: "good", note: "", createdAtMs: NOW - 1000 }]);
 		expect(ada.find((e) => e.id === "l2")?.escalationSignal).toBe("circular");
@@ -203,27 +226,26 @@ describe("decision entries", () => {
 		expect(ada.find((e) => e.id === "l1")?.scope).toBe("acme.api");
 		expect(ada.find((e) => e.id === "l2")?.scope).toBe("acme.web");
 		// Everyone, within the window: the 40-day-old row stays out; the digest row is a turn like any other.
-		expect(decisionEntries(db, { sinceMs: since, harness: null }).map((e) => e.id).sort()).toEqual(["l1", "l2", "l3", "l4"]);
-		expect(decisionEntries(db, { sinceMs: 0, harness: null }).length).toBe(5);
+		expect((await decisionEntries(db, { sinceMs: since, harness: null })).map((e) => e.id).sort()).toEqual(["l1", "l2", "l3", "l4"]);
+		expect((await decisionEntries(db, { sinceMs: 0, harness: null })).length).toBe(5);
 		// A model, a tier, nobody, and a cap.
-		expect(decisionEntries(db, { sinceMs: since, harness: null, slug: "ollama/glm-5.3-flash" }).map((e) => e.id).sort()).toEqual(["l3", "l4"]);
-		expect(decisionEntries(db, { sinceMs: since, harness: null, tier: "hard" })).toEqual([]);
-		expect(decisionEntries(db, { sinceMs: since, harness: [] })).toEqual([]);
-		expect(decisionEntries(db, { sinceMs: since, harness: null, limit: 1 }).length).toBe(1);
+		expect((await decisionEntries(db, { sinceMs: since, harness: null, slug: "ollama/glm-5.3-flash" })).map((e) => e.id).sort()).toEqual(["l3", "l4"]);
+		expect(await decisionEntries(db, { sinceMs: since, harness: null, tier: "hard" })).toEqual([]);
+		expect(await decisionEntries(db, { sinceMs: since, harness: [] })).toEqual([]);
+		expect((await decisionEntries(db, { sinceMs: since, harness: null, limit: 1 })).length).toBe(1);
 		// The error on l3 and its note ride along, so an explorer can show why a turn went wrong.
-		const bob = decisionEntries(db, { sinceMs: since, harness: ["u_bob"], slug: "ollama/glm-5.3-flash" });
+		const bob = await decisionEntries(db, { sinceMs: since, harness: ["u_bob"], slug: "ollama/glm-5.3-flash" });
 		expect(bob.find((e) => e.id === "l3")?.error).toBe("boom");
 		expect(bob.find((e) => e.id === "l3")?.feedback[0]?.note).toBe("looped");
 	});
 
-	test("the recorded cost split rides along; unpriced rows leave it absent", () => {
+	test("the recorded cost split rides along; unpriced rows leave it absent", async () => {
 		const { decisionEntries } = require("../src/cost/views.ts") as typeof import("../src/cost/views.ts");
 		// The fixture records before any catalog fetch, so every row stored NULL;
 		// one priced row stands in for a turn the router could price at record time.
-		db.run("UPDATE ledger SET cost_breakdown = ? WHERE id = 'l1'", [
-			JSON.stringify({ freshPrompt: 0.006, cacheRead: 0.004, cacheWrite: 0, completion: 0.002, reasoning: 0, images: 0, request: 0, total: 0.006, tierAtPromptTokens: 0 }),
-		]);
-		const entries = decisionEntries(db, { sinceMs: since, harness: null });
+		const breakdown = { freshPrompt: 0.006, cacheRead: 0.004, cacheWrite: 0, completion: 0.002, reasoning: 0, images: 0, request: 0, total: 0.006, tierAtPromptTokens: 0 };
+		await db.sql`UPDATE ledger SET cost_breakdown = ${jsonParam(db, breakdown)} WHERE id = ${"l1"}`;
+		const entries = await decisionEntries(db, { sinceMs: since, harness: null });
 		const priced = entries.find((e) => e.id === "l1");
 		expect(priced?.costBreakdown?.total).toBeCloseTo(0.006, 6);
 		expect(priced?.costBreakdown?.cacheRead).toBeCloseTo(0.004, 6);