auto-model-router 0.31.0 → 0.32.0

package/test/ledger-sql.test.ts

@@ -0,0 +1,342 @@
+/**
+ * The unified ledger, on every engine it claims to support.
+ *
+ * SQLite runs always (a temp file); Postgres runs when AMR_ROUTER_TEST_PG
+ * points at one, following the team edition's convention for store tests. The
+ * same assertions run against both, because the reason this implementation
+ * replaced two backends is that two implementations of one meaning drift
+ * silently — a `SUM()` read as a string skewed a trust score by three points,
+ * and a double-encoded JSON column made an escalation-cost term null, both
+ * without raising anything.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+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 { createConversationStore } from "../src/router/state.ts";
+import { migrateStore } from "../src/util/schema.ts";
+import type { AsyncLedger, LedgerEntry } from "../src/cost/types.ts";
+import { openSqlDb, type SqlDb } from "../src/util/sql.ts";
+
+const DAY_MS = 86_400_000;
+const PG = process.env.AMR_ROUTER_TEST_PG;
+
+const engines: { name: string; url: string }[] = [
+	{ name: "sqlite", url: `sqlite://${join(tmpdir(), `ledger-sql-${process.pid}-${Date.now()}.db`)}` },
+	...(PG === undefined ? [] : [{ name: "postgres", url: PG }]),
+];
+
+function cfgWith(over: Partial<RouterConfig["filters"]> = {}): RouterConfig {
+	const cfg = structuredClone(DEFAULT_CONFIG);
+	cfg.filters = { ...cfg.filters, trustWindowDays: 0, feedbackWeight: 1, ...over };
+	return cfg;
+}
+
+function entry(over: Partial<LedgerEntry> & { id: string; slug: string }): LedgerEntry {
+	return {
+		createdAtMs: Date.now(),
+		conversationKey: `conv-${over.id}`,
+		// `LedgerEntry.sessionId` is a string and the column is NOT NULL: a null
+		// here only ever passed because the second bootstrap declared the column
+		// laxer than the nineteen shipped migrations do.
+		sessionId: `sess-${over.id}`,
+		turn: 1,
+		requestedModel: "auto",
+		harnessId: "",
+		ompSessionId: "",
+		servedSlug: over.slug,
+		tier: "simple",
+		classificationSource: "forced",
+		reasons: ["because"],
+		predictedUsd: 0,
+		reportedUsd: null,
+		usage: { promptTokens: 100, completionTokens: 10, cachedTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0, images: 0 },
+		attempt: 0,
+		escalationSignal: null,
+		latencyMs: 100,
+		ttftMs: 50,
+		finishReason: "stop",
+		wasted: false,
+		upstreamGenerationId: null,
+		error: null,
+		features: null,
+		score: null,
+		confidence: null,
+		task: null,
+		classifierReasons: null,
+		exploredFrom: null,
+		holdArm: null,
+		promptTokensSaved: null,
+		...over,
+	} as LedgerEntry;
+}
+
+for (const engine of engines) {
+	describe(`ledger on ${engine.name}`, () => {
+		// ONE handle per engine. A `SqlDb` is a connection pool, and opening one
+		// per test exhausts a default Postgres (`sorry, too many clients
+		// already`) — the same limit a host packed with many small tenants hits.
+		let db: SqlDb;
+
+		beforeAll(async () => {
+			db = openSqlDb(engine.url);
+			await migrateStore(db);
+		});
+
+		afterAll(async () => {
+			await db.close();
+		});
+
+		// Tables are emptied rather than dropped: these tests assert over global
+		// aggregates (allTrust, recentEntries, unscoped spend), so leftovers from
+		// a neighbour would couple them.
+		beforeEach(async () => {
+			for (const table of ["ledger", "feedback", "token_calibration", "ollama_meter_samples"]) {
+				await db.sql.unsafe(`DELETE FROM ${table}`);
+			}
+		});
+
+		const setup = async (cfg = cfgWith()): Promise<{ db: SqlDb; ledger: AsyncLedger }> => ({
+			db,
+			ledger: createSqlLedger(db, cfg, { findModel: () => null }),
+		});
+
+		test("a write is visible to a second handle on the same store, so a shared cap holds", async () => {
+			const cfg = cfgWith();
+			const { db, ledger: a } = await setup(cfg);
+			// A second ledger over the same store is what a second router replica
+			// is. With a per-process file, B would read 0 for A's spend.
+			const b = createSqlLedger(db, cfg, { findModel: () => null });
+
+			expect(await b.spendSince(0, "h1")).toBe(0);
+			await a.record(entry({ id: "a1", slug: "x/m", harnessId: "h1", predictedUsd: 4 }));
+			expect(await b.spendSince(0, "h1")).toBeCloseTo(4, 9);
+
+			await b.record(entry({ id: "b1", slug: "x/m", harnessId: "h1", predictedUsd: 3 }));
+			// $7 between them breaches a $5 cap that neither replica's own share
+			// would have reached.
+			expect(await a.spendSince(0, "h1")).toBeCloseTo(7, 9);
+
+			// Harness scoping still isolates one user's spend from another's.
+			await a.record(entry({ id: "a2", slug: "x/m", harnessId: "h2", predictedUsd: 50 }));
+			expect(await b.spendSince(0, "h1")).toBeCloseTo(7, 9);
+			expect(await b.spendSince(0)).toBeCloseTo(57, 9);
+		});
+
+		test("reported spend beats predicted, and a window excludes older rows", async () => {
+			const { ledger } = await setup(cfgWith());
+			await ledger.record(entry({ id: "w1", slug: "y/m", harnessId: "hw", predictedUsd: 1, reportedUsd: 9 }));
+			await ledger.record(entry({ id: "w2", slug: "y/m", harnessId: "hw", predictedUsd: 2, createdAtMs: Date.now() - 3 * DAY_MS }));
+			expect(await ledger.spendSince(0, "hw")).toBeCloseTo(11, 9);
+			expect(await ledger.spendSince(Date.now() - DAY_MS, "hw")).toBeCloseTo(9, 9);
+			expect(await ledger.conversationSpend("conv-w1")).toBeCloseTo(9, 9);
+		});
+
+		test("trust counts escalations and upstream errors but forgives client aborts", async () => {
+			const { ledger } = await setup(cfgWith());
+			const slug = "t/model";
+			for (let i = 0; i < 6; i++) await ledger.record(entry({ id: `t${i}`, slug, harnessId: "ht" }));
+			await ledger.record(entry({ id: "te1", slug, harnessId: "ht", escalationSignal: "probe_failed" }));
+			await ledger.record(entry({ id: "te2", slug, harnessId: "ht", error: "upstream_5xx: boom" }));
+			// An aborted turn is the client's doing, not the model's: errorKindOf
+			// recovers the kind and ATTRIBUTABLE_ERROR excludes that set
+			// ('aborted', 'auth', 'moderation', 'model_unavailable', 'quota').
+			await ledger.record(entry({ id: "te3", slug, harnessId: "ht", error: "request aborted" }));
+
+			const trust = await ledger.trust(slug, "ht");
+			expect(trust?.attempts).toBe(9);
+			expect(trust?.escalations).toBe(1);
+			expect(trust?.errors).toBe(1);
+			// Numbers, not Postgres' aggregate strings: toTrust does arithmetic on
+			// these, so a string skews the score instead of failing.
+			expect(typeof trust?.attempts).toBe("number");
+			expect(typeof trust?.successRate).toBe("number");
+			expect(trust?.successRate).toBeGreaterThan(0.5);
+			expect(trust?.successRate).toBeLessThan(1);
+
+			const all = await ledger.allTrust();
+            expect(all.find((t) => t.slug === slug)?.attempts).toBe(9);
+		});
+
+		test("signals batch trust and latency for a candidate set", async () => {
+			const { ledger } = await setup(cfgWith({ latencyMinSamples: 1 }));
+			await ledger.record(entry({ id: "s1", slug: "a/one", harnessId: "hs", ttftMs: 100, latencyMs: 1100 }));
+			await ledger.record(entry({ id: "s2", slug: "a/one", harnessId: "hs", ttftMs: 300, latencyMs: 1300 }));
+			// Errored rows carry no usable timing and must not drag the mean.
+			await ledger.record(entry({ id: "s3", slug: "a/one", harnessId: "hs", ttftMs: 9000, latencyMs: 9900, error: "upstream_5xx: x" }));
+			await ledger.record(entry({ id: "s4", slug: "b/two", harnessId: "hs", ttftMs: 40, latencyMs: 540 }));
+
+			const signals = await ledger.signals(["a/one", "b/two", "c/absent"], "hs");
+			expect(signals.get("a/one")?.latency?.samples).toBe(2);
+			expect(signals.get("a/one")?.latency?.ttftMs).toBeCloseTo(200, 6);
+			expect(signals.get("a/one")?.latency?.tokensPerSec).toBeGreaterThan(0);
+			expect(signals.get("b/two")?.trust?.attempts).toBe(1);
+			// A slug the ledger has never seen yields an entry with no signals,
+			// not a missing key: candidate scoring reads it either way.
+			expect(signals.get("c/absent")).toEqual({ trust: null, latency: null });
+			expect(await ledger.latency("b/two", "hs")).not.toBeNull();
+		});
+
+		test("escalation cost needs enough samples before it reports a rate", async () => {
+			const cfg = cfgWith();
+			const { db, ledger } = await setup(cfg);
+			for (let i = 0; i < 4; i++) {
+				await ledger.record(entry({ id: `e${i}`, slug: "e/model", harnessId: "he", attempt: 1, predictedUsd: 1 }));
+			}
+			expect(await ledger.escalationCost(30)).toBeNull();
+
+			for (let i = 4; i < 14; i++) {
+				await ledger.record(entry({ id: `e${i}`, slug: "e/model", harnessId: "he", attempt: 1, predictedUsd: 1 }));
+			}
+			// A fresh handle: the result is memoised per instance for a minute.
+			const fresh = createSqlLedger(db, cfg, { findModel: () => null });
+			const cost = await fresh.escalationCost(30);
+			expect(cost?.samples).toBe(14);
+			// 14 rows × $1 over 14 × 100 prompt tokens. Reads inside the usage
+			// JSON, which yields NULL when the column is stored double-encoded.
+			expect(cost?.usdPerPromptToken).toBeCloseTo(0.01, 9);
+		});
+
+		test("entries round-trip, including the JSON columns", async () => {
+			const { ledger } = await setup(cfgWith());
+			await ledger.record(
+				entry({
+					id: "r1",
+					slug: "r/model",
+					harnessId: "hr",
+					ompSessionId: "sess-1",
+					reasons: ["cheapest", "warm cache"],
+					classifierReasons: ["short prompt"],
+					usage: { promptTokens: 11, completionTokens: 22, cachedTokens: 3, cacheWriteTokens: 4, reasoningTokens: 5, images: 0 },
+					scope: "team/proj",
+					redactions: 0,
+				}),
+			);
+			const recent = await ledger.recentEntries(5);
+			const row = recent.find((e) => e.id === "r1");
+			expect(row?.reasons).toEqual(["cheapest", "warm cache"]);
+			expect(row?.classifierReasons).toEqual(["short prompt"]);
+			expect(row?.usage.promptTokens).toBe(11);
+			expect(row?.usage.cachedTokens).toBe(3);
+			expect(row?.scope).toBe("team/proj");
+			expect(row?.redactions).toBe(0);
+			expect(row?.wasted).toBe(false);
+
+			expect((await ledger.latestForSession("sess-1"))?.id).toBe("r1");
+			expect((await ledger.entriesForSession("sess-1", 3)).length).toBe(1);
+			// A wasted row is excluded from the session view.
+			await ledger.markWasted("r1");
+			expect(await ledger.latestForSession("sess-1")).toBeNull();
+		});
+
+		test("prune deletes past retention, keeps newer rows, and reports the oldest kept", async () => {
+			const { ledger } = await setup(cfgWith());
+			await ledger.record(entry({ id: "p_old", slug: "p/m", harnessId: "hp", predictedUsd: 5, createdAtMs: Date.now() - 10 * DAY_MS }));
+			await ledger.record(entry({ id: "p_new", slug: "p/m", harnessId: "hp", predictedUsd: 7 }));
+			expect(await ledger.spendSince(0, "hp")).toBeCloseTo(12, 9);
+
+			// null and 0 both mean "keep everything", and still report the age.
+			expect((await ledger.prune(null)).deleted).toBe(0);
+			expect((await ledger.prune(0)).oldestKeptMs).not.toBeNull();
+
+			const result = await ledger.prune(1);
+			expect(result.deleted).toBe(1);
+			expect(await ledger.spendSince(0, "hp")).toBeCloseTo(7, 9);
+		});
+
+		test("provider spend matches on the served slug's prefix", async () => {
+			const { ledger } = await setup(cfgWith());
+			await ledger.record(entry({ id: "pv1", slug: "ollama/glm", harnessId: "hv", predictedUsd: 2 }));
+			await ledger.record(entry({ id: "pv2", slug: "openrouter/glm", harnessId: "hv", predictedUsd: 5 }));
+			// Attribution follows served_slug, which is what actually billed.
+			await ledger.record(entry({ id: "pv3", slug: "auto", servedSlug: "ollama/other", harnessId: "hv", predictedUsd: 1 }));
+			expect(await ledger.providerSpendSince("ollama/", 0)).toBeCloseTo(3, 9);
+		});
+
+		test("soft-failure spikes need a rate, a floor of failures, and a worse-than-baseline ratio", async () => {
+			const { ledger } = await setup(cfgWith());
+			const now = Date.now();
+			const recentMs = 15 * 60_000;
+			const baselineMs = 6 * 60 * 60_000;
+			// Baseline: healthy. Recent: mostly failing. Enough of both to clear
+			// SPIKE_MIN_DISPATCHES and SPIKE_MIN_FAILURES.
+			for (let i = 0; i < 20; i++) {
+				await ledger.record(entry({ id: `sb${i}`, slug: "sp/model", createdAtMs: now - recentMs - 60_000 }));
+			}
+			for (let i = 0; i < 6; i++) {
+				await ledger.record(entry({ id: `sr${i}`, slug: "sp/model", createdAtMs: now - 60_000, error: "upstream_5xx: boom" }));
+			}
+			const spikes = await ledger.softFailureSpikes(now, recentMs, baselineMs);
+			const spike = spikes.find((s) => s.slug === "sp/model");
+			expect(spike?.recentFailures).toBe(6);
+			expect(spike?.recentRate).toBeCloseTo(1, 6);
+			expect(spike?.baselineRate).toBeCloseTo(0, 6);
+		});
+
+		test("token calibration accumulates and stays unreported until enough samples", async () => {
+			const { ledger } = await setup(cfgWith());
+			// No pending estimate was registered for these conversations, so
+			// nothing calibrates: the ratio must stay unknown rather than guess.
+			await ledger.record(entry({ id: "c1", slug: "cal/model" }));
+			expect(await ledger.tokenRatio("gpt")).toBeNull();
+		});
+
+		test("blended rate stays null until the window has enough priced samples", async () => {
+			const { ledger } = await setup(cfgWith());
+			// findModel returns null here, so no cost_breakdown is written and the
+			// blend has nothing to apportion — null, not a fabricated rate.
+			await ledger.record(entry({ id: "bl1", slug: "bl/model", reportedUsd: 1 }));
+			expect(await ledger.blendedRate(30)).toBeNull();
+		});
+
+		// Two replicas, one store. Everything below is about a SECOND handle
+		// seeing what the first one wrote, because that is what a cap and a warm
+		// cache depend on once the store stops being a local file.
+		test("a concurrent bootstrap does not lose the race", async () => {
+			// `CREATE TABLE IF NOT EXISTS` is not atomic on Postgres: two replicas
+			// booting together both pass the existence check, and the loser used
+			// to die on the unique index over pg_type. Measured: one of two
+			// replicas started at once exited with "duplicate key value violates
+			// unique constraint pg_type_typname_nsp_index".
+			const url = engine.name === "sqlite" ? `sqlite://${join(tmpdir(), `boot-race-${process.pid}-${Date.now()}.db`)}` : engine.url;
+			const a = openSqlDb(url);
+			const b = openSqlDb(url);
+			try {
+				await Promise.all([migrateStore(a), migrateStore(b)]);
+				// Both handles land on a usable store, not a half-created one.
+				for (const handle of [a, b]) await handle.sql.unsafe("SELECT COUNT(*) FROM ledger");
+			} finally {
+				await a.close();
+				await b.close();
+			}
+		});
+
+		test("a second handle reads the spend and the warm conversation the first one wrote", async () => {
+			// The fixture bootstraps the ledger's own tables; the conversation
+			// store is the other half of the shared state.
+			await migrateStore(db);
+			const writer = createSqlLedger(db, cfgWith(), { findModel: () => null });
+			const writerConvs = createConversationStore(db);
+			const now = Date.now();
+			await writer.record(entry({ id: "sh1", slug: "warm/model", harnessId: "u_a", reportedUsd: 0.25, createdAtMs: now }));
+			const state = await writerConvs.load("shared-conv");
+			state.currentSlug = "warm/model";
+			state.currentTier = "moderate";
+			state.cacheWarmSlug = "warm/model";
+			state.cacheWarmAtMs = now;
+			state.turn = 1;
+			await writerConvs.save(state);
+
+			// A replica that has never seen this conversation or this spend.
+			const reader = createSqlLedger(db, cfgWith(), { findModel: () => null });
+			const readerConvs = createConversationStore(db);
+			expect(await reader.spendSince(0)).toBeCloseTo(0.25, 9);
+			expect(await reader.spendSince(0, "u_a")).toBeCloseTo(0.25, 9);
+			const seen = await readerConvs.load("shared-conv");
+			expect([seen.turn, seen.currentSlug, seen.currentTier, seen.cacheWarmSlug]).toEqual([1, "warm/model", "moderate", "warm/model"]);
+		});
+	});
+}

package/test/mcp-entry.test.ts

@@ -12,7 +12,7 @@ const servers = (p: string): Record<string, unknown> => (read(p).mcpServers as R
 const auth = (p: string): string => (servers(p)[MCP_SERVER_NAME] as { headers: { Authorization: string } }).headers.Authorization;
 
 describe("mergeMcpServers", () => {
-	test("adds the team-context server next to the others and keeps every other key", () => {
+	test("adds the team-context server next to the others and keeps every other key", async () => {
 		const before = JSON.stringify({ $schema: "https://x/mcp-schema.json", mcpServers: { agentdox: { type: "http", url: "http://localhost:3003/mcp" } }, other: 1 });
 		const after = mergeMcpServers(before, "https://team.example/mcp", "amrt_k");
 		expect(after).not.toBeNull();
@@ -26,12 +26,12 @@ describe("mergeMcpServers", () => {
 		expect(after!.endsWith("\n")).toBe(true);
 	});
 
-	test("an empty or missing file becomes a fresh mcpServers document", () => {
+	test("an empty or missing file becomes a fresh mcpServers document", async () => {
 		expect(JSON.parse(mergeMcpServers("", "https://t/mcp", "k")!)).toEqual({ mcpServers: { [MCP_SERVER_NAME]: { type: "http", url: "https://t/mcp", headers: { Authorization: "Bearer k" } } } });
 		expect(JSON.parse(mergeMcpServers("  \n", "https://t/mcp", "k")!)).toHaveProperty("mcpServers");
 	});
 
-	test("is idempotent, removes on null, and leaves a file it cannot parse alone", () => {
+	test("is idempotent, removes on null, and leaves a file it cannot parse alone", async () => {
 		const one = mergeMcpServers("", "https://t/mcp", "k")!;
 		expect(mergeMcpServers(one, "https://t/mcp", "k")).toBeNull(); // unchanged
 		expect(mergeMcpServers(one, "https://t/mcp", "k2")).not.toBeNull(); // a new key rewrites
@@ -54,7 +54,7 @@ describe("connect writes the team MCP endpoint", () => {
 		return { home, agent, env };
 	}
 
-	test("into omp mcp.json and Claude Code ~/.claude.json, only for the harnesses it configured", () => {
+	test("into omp mcp.json and Claude Code ~/.claude.json, only for the harnesses it configured", async () => {
 		const { home, agent, env } = fixture();
 		try {
 			// Pre-existing servers and unrelated settings survive.
@@ -95,7 +95,7 @@ describe("connect writes the team MCP endpoint", () => {
 		}
 	});
 
-	test("a dry run reports the files without writing them; no mcp option leaves them alone", () => {
+	test("a dry run reports the files without writing them; no mcp option leaves them alone", async () => {
 		const { home, agent, env } = fixture();
 		try {
 			const r = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: true, only: ["omp"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });

package/test/migrations.test.ts

@@ -1,16 +1,18 @@
 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 { openDb } from "../src/util/sqlite.ts";
+import { openSqlDb } from "../src/util/sql.ts";
+import { copyFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+
 import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import { createFeedbackStore } from "../src/cost/feedback.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
 import { buildUsageReport } from "../src/cost/report.ts";
 import { buildDailySummary, createKv } from "../src/cost/summary.ts";
 import { exportRows, spendUsdSince } from "../src/cost/views.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:
@@ -27,19 +29,22 @@ const files = readdirSync(FIXTURES).filter((f) => /^router-v\d+\.db$/.test(f)).s
 const CURRENT_VERSION = 19;
 
 describe("schema migrations from every shipped version", () => {
-	test("fixtures exist for the versions that shipped", () => {
+	test("fixtures exist for the versions that shipped", async () => {
 		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`, () => {
+		test(`v${from} → v${CURRENT_VERSION}: opens, migrates, keeps its rows, and every consumer runs`, async () => {
 			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;
+			// `openDb` is the migration path for a SQLite file: it applies the
+			// nineteen versions in order. The shim handle then reads the result.
 			const db = openDb(path);
+			const sdb = openSqlDb(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.
@@ -51,27 +56,28 @@ describe("schema migrations from every shipped version", () => {
 				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);
+				const ledger = createSqlLedger(sdb, cfg, { findModel: () => null });
+				const conversations = createConversationStore(sdb);
+				createFeedbackStore(sdb);
 				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(await ledger.recentEntries(5)).toHaveLength(1);
+				expect(await ledger.trust("fixture-slug")).not.toBeNull();
+				expect(await ledger.softFailureSpikes()).toEqual([]);
+				expect(await ledger.latestForSession("nope")).toBeNull();
+				expect((await conversations.load("fixture-key")).key).toBe("fixture-key");
+				expect((await buildUsageReport(sdb, { windowDays: 3650 })).totals.dispatches).toBe(1);
+				expect((await buildDailySummary(sdb, {})).current.dispatches).toBe(0);
 				// v18: the fixture's row predates `scope`, so it exports under "" and no
 				// context scope claims its spend.
-				expect(exportRows(db, 0, null).map((r) => r.scope)).toEqual([""]);
-				expect(spendUsdSince(db, 0, null, "acme.api")).toBe(0);
-				expect(spendUsdSince(db, 0, null)).toBeGreaterThanOrEqual(0);
-				expect(ledger.prune?.(0)?.deleted).toBe(0);
+				expect((await exportRows(sdb, 0, null)).map((r) => r.scope)).toEqual([""]);
+				expect(await spendUsdSince(sdb, 0, null, "acme.api")).toBe(0);
+				expect(await spendUsdSince(sdb, 0, null)).toBeGreaterThanOrEqual(0);
+				expect((await ledger.prune(0)).deleted).toBe(0);
 				// v19: the fixture's row predates `redactions`, so nothing claims a
 				// redaction happened on it and the report totals it as zero.
-				expect(buildUsageReport(db, { windowDays: 3650 }).totals.redactions).toBe(0);
+				expect((await buildUsageReport(sdb, { windowDays: 3650 })).totals.redactions).toBe(0);
 			} finally {
+				await sdb.close();
 				db.close();
 				try {
 					rmSync(dir, { recursive: true, force: true });
@@ -82,8 +88,8 @@ describe("schema migrations from every shipped version", () => {
 		});
 	}
 
-	test("a fresh database lands on the same version as a migrated one", () => {
-		const db = openDb(":memory:");
+	test("a fresh database lands on the same version as a migrated one", async () => {
+		const db = openDb(join(tmpdir(), `t-migrations.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
 		try {
 			expect((db.query("PRAGMA user_version").get() as { user_version: number }).user_version).toBe(CURRENT_VERSION);
 			// A fresh ledger has the scope column the bootstrap never spells out in CREATE TABLE.

package/test/models-yml.test.ts

@@ -49,7 +49,7 @@ function countOf(text: string, needle: string): number {
 }
 
 describe("renderProviderBlock", () => {
-	test("emits costs in USD per MILLION tokens, not per token", () => {
+	test("emits costs in USD per MILLION tokens, not per token", async () => {
 		const providers = providersOf(`providers:\n${BLOCK.split("\n").map((l) => (l === "" ? "" : `  ${l}`)).join("\n")}\n`);
 		const router = providers["auto-model-router"];
 		expect(typeof router).toBe("object");
@@ -60,17 +60,17 @@ describe("renderProviderBlock", () => {
 		expect(BLOCK).toContain(`input: ${cfg.ledger.fallbackBlend.inputPerMtok}`);
 	});
 
-	test("declares one model per configured profile", () => {
+	test("declares one model per configured profile", async () => {
 		for (const profile of cfg.profiles) expect(BLOCK).toContain(`id: ${profile.id}`);
 	});
 
-	test("advertises a keyless openai-compatible provider", () => {
+	test("advertises a keyless openai-compatible provider", async () => {
 		expect(BLOCK).toContain("api: openai-completions");
 		expect(BLOCK).toContain("auth: none");
 		expect(BLOCK).toContain("/v1");
 	});
 
-	test("with the bridge on, the scope and origin headers name the variables the extension sets", () => {
+	test("with the bridge on, the scope and origin headers name the variables the extension sets", async () => {
 		// The file is machine-wide, so neither can be a literal: omp resolves a
 		// header value that names an env var per request (src/context/scope.ts).
 		const bridged = renderProviderBlock(loadConfig({ overrides: { context: { enabled: true, baseUrl: "http://agentdox:3003", token: "t" } } }), null);
@@ -81,7 +81,7 @@ describe("renderProviderBlock", () => {
 });
 
 describe("spliceProviderBlock", () => {
-	test("preserves every original line and comment", () => {
+	test("preserves every original line and comment", async () => {
 		const result = spliceProviderBlock(EXISTING, BLOCK);
 		expect(result.action).toBe("inserted");
 		const after = result.text.split("\n");
@@ -92,13 +92,13 @@ describe("spliceProviderBlock", () => {
 		expect(result.text).toContain("# model's architectural limit.");
 	});
 
-	test("leaves the pre-existing providers intact and adds ours", () => {
+	test("leaves the pre-existing providers intact and adds ours", async () => {
 		const result = spliceProviderBlock(EXISTING, BLOCK);
 		const providers = providersOf(result.text);
 		expect(Object.keys(providers).sort()).toEqual(["auto-model-router", "fastflowlm", "ollama"]);
 	});
 
-	test("is idempotent: a second run replaces rather than duplicates", () => {
+	test("is idempotent: a second run replaces rather than duplicates", async () => {
 		const once = spliceProviderBlock(EXISTING, BLOCK);
 		const twice = spliceProviderBlock(once.text, BLOCK);
 		expect(twice.action).toBe("replaced");
@@ -108,7 +108,7 @@ describe("spliceProviderBlock", () => {
 		providersOf(twice.text);
 	});
 
-	test("refreshed cost figures replace the old ones in place", () => {
+	test("refreshed cost figures replace the old ones in place", async () => {
 		const first = spliceProviderBlock(EXISTING, renderProviderBlock(cfg, null));
 		const updated = spliceProviderBlock(
 			first.text,
@@ -126,20 +126,20 @@ describe("spliceProviderBlock", () => {
 		providersOf(updated.text);
 	});
 
-	test("adds a providers mapping when the file has none", () => {
+	test("adds a providers mapping when the file has none", async () => {
 		const result = spliceProviderBlock("# just a comment\n", BLOCK);
 		expect(result.text).toContain("# just a comment");
 		expect(countOf(result.text, "providers:")).toBe(1);
 		expect(Object.keys(providersOf(result.text))).toContain("auto-model-router");
 	});
 
-	test("creates a whole file from empty input", () => {
+	test("creates a whole file from empty input", async () => {
 		const result = spliceProviderBlock("", BLOCK);
 		expect(result.action).toBe("created");
 		expect(Object.keys(providersOf(result.text))).toContain("auto-model-router");
 	});
 
-	test("survives a UTF-8 BOM without producing a duplicate providers key", () => {
+	test("survives a UTF-8 BOM without producing a duplicate providers key", async () => {
 		// A BOM made the first line read as "\uFEFFproviders:", so the top-level
 		// key was missed and a second one appended -- which makes omp discard the
 		// entire file.
@@ -150,7 +150,7 @@ describe("spliceProviderBlock", () => {
 		expect(Object.keys(providersOf(result.text)).sort()).toEqual(["auto-model-router", "fastflowlm", "ollama"]);
 	});
 
-	test("preserves CRLF line endings", () => {
+	test("preserves CRLF line endings", async () => {
 		const crlf = EXISTING.replaceAll("\n", "\r\n");
 		const result = spliceProviderBlock(crlf, BLOCK);
 		expect(result.text).toContain("\r\n");
@@ -159,7 +159,7 @@ describe("spliceProviderBlock", () => {
 		providersOf(result.text);
 	});
 
-	test("matches the existing child indentation", () => {
+	test("matches the existing child indentation", async () => {
 		// EXISTING indents providers' children by four spaces; mixing widths
 		// under one mapping is invalid YAML.
 		const result = spliceProviderBlock(EXISTING, BLOCK);
@@ -168,7 +168,7 @@ describe("spliceProviderBlock", () => {
 		expect(begin?.startsWith("    #")).toBe(true);
 	});
 
-	test("a two-space file gets two-space children", () => {
+	test("a two-space file gets two-space children", async () => {
 		const twoSpace = "providers:\n  ollama:\n    auth: none\n";
 		const result = spliceProviderBlock(twoSpace, BLOCK);
 		const begin = result.text.split("\n").find((l) => l.includes(BEGIN_GUARD));
@@ -178,19 +178,19 @@ describe("spliceProviderBlock", () => {
 });
 
 describe("assertUsableModelsYaml", () => {
-	test("accepts a correctly spliced result", () => {
+	test("accepts a correctly spliced result", async () => {
 		expect(() => assertUsableModelsYaml(spliceProviderBlock(EXISTING, BLOCK).text)).not.toThrow();
 	});
 
-	test("rejects a duplicate providers key, which YAML treats as fatal", () => {
+	test("rejects a duplicate providers key, which YAML treats as fatal", async () => {
 		expect(() => assertUsableModelsYaml("providers:\n  a:\n    auth: none\nproviders:\n  b:\n    auth: none\n")).toThrow();
 	});
 
-	test("rejects a file without our provider", () => {
+	test("rejects a file without our provider", async () => {
 		expect(() => assertUsableModelsYaml("providers:\n  ollama:\n    auth: none\n")).toThrow();
 	});
 
-	test("rejects a file with no providers mapping", () => {
+	test("rejects a file with no providers mapping", async () => {
 		expect(() => assertUsableModelsYaml("something: else\n")).toThrow();
 	});
 });