auto-model-router 0.30.3 → 0.32.0

package/test/context-bridge.test.ts

@@ -1,11 +1,15 @@
 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 { type AgentDoxClient, type AssembleLayers, type AssembleLimits, createAgentDoxClient } from "../src/context/agentdox.ts";
 import { createContextBridge } from "../src/context/bridge.ts";
 import { createContextStore } from "../src/context/store.ts";
 import type { ContextResolveInput, TurnRecord } from "../src/context/types.ts";
 import { createLogger } from "../src/util/log.ts";
-import { openDb } from "../src/util/sqlite.ts";
 import { injectForTest } from "./helpers/inject.ts";
 
 const log = createLogger("silent");
@@ -49,8 +53,11 @@ function mkClient(prompt = "MEMORY: player digs in 3/4 top-down"): FakeClient {
 
 type BridgeOpts = Parameters<typeof createContextBridge>[0];
 
-function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
-	const db = openDb(":memory:");
+async function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
+	// A file: the shim cannot share `:memory:` between handles. Awaited, so the
+	// tables exist before the bridge's first read rather than racing it.
+	const db = openSqlDb(join(tmpdir(), `ctxbridge-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
 	const opts: BridgeOpts = {
 		client,
 		store: createContextStore(db),
@@ -89,7 +96,7 @@ function input(over: Partial<ContextResolveInput> = {}): ContextResolveInput {
 describe("context bridge refresh policy", () => {
 	test("recent sessions ride only on a conversation's first block; refreshes ask for none", async () => {
 		const client = mkClient();
-		const { bridge } = mkBridge(client, { sessionLimit: 6 });
+		const { bridge } = await mkBridge(client, { sessionLimit: 6 });
 		await bridge.resolve(input({ firstFetch: true }));
 		expect(client.lastLimits?.sessionLimit).toBe(6);
 		// A refresh (model switch) on a conversation that already had a block.
@@ -100,7 +107,7 @@ describe("context bridge refresh policy", () => {
 
 	test("fetches on the first turn, then pins without re-fetching", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const first = await bridge.resolve(input());
 			expect(first).not.toBeNull();
@@ -126,7 +133,7 @@ describe("context bridge refresh policy", () => {
 		// The REST endpoint also ignores snake_case limit keys, which silently reads
 		// as unbounded, so pin that all four limits actually reach the client.
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client, { memoryLimit: 5, docsLimit: 1, sessionLimit: 2, briefChars: 9000 });
+		const { bridge, db } = await mkBridge(client, { memoryLimit: 5, docsLimit: 1, sessionLimit: 2, briefChars: 9000 });
 		try {
 			await bridge.resolve(input());
 			expect(client.lastLimits).toEqual({ memoryLimit: 5, docsLimit: 1, sessionLimit: 2, briefChars: 9000 });
@@ -137,7 +144,7 @@ describe("context bridge refresh policy", () => {
 
 	test("refreshes when the model switches, because the cache is already forfeit", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const first = await bridge.resolve(input());
 			await bridge.resolve(
@@ -155,7 +162,7 @@ describe("context bridge refresh policy", () => {
 
 	test("refreshes on a retry", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const first = await bridge.resolve(input());
 			await bridge.resolve(
@@ -173,7 +180,7 @@ describe("context bridge refresh policy", () => {
 
 	test("refreshes once the staleness TTL elapses", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client, { maxStalenessMs: 1_000 });
+		const { bridge, db } = await mkBridge(client, { maxStalenessMs: 1_000 });
 		try {
 			const first = await bridge.resolve(input());
 			await bridge.resolve(input({ pinnedVersion: first?.version ?? null, pinnedFetchedAtMs: Date.now() - 5_000 }));
@@ -185,7 +192,7 @@ describe("context bridge refresh policy", () => {
 
 	test("version is a content hash, so an unchanged re-assembly keeps the cache warm", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const first = await bridge.resolve(input());
 			// Force a refetch; agentdox returns byte-identical content.
@@ -206,7 +213,7 @@ describe("context bridge refresh policy", () => {
 
 	test("changed content yields a new version", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const first = await bridge.resolve(input());
 			client.prompt = "MEMORY: player digs in 3/4 top-down; hard edges only";
@@ -225,7 +232,7 @@ describe("context bridge refresh policy", () => {
 
 	test("an unreachable agentdox keeps serving the pinned block", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const first = await bridge.resolve(input());
 			client.assemble = async () => null; // agentdox goes down
@@ -244,7 +251,7 @@ describe("context bridge refresh policy", () => {
 
 	test("an empty scope is inert", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			expect(await bridge.resolve(input({ scope: "" }))).toBeNull();
 			expect(client.assembleCalls).toBe(0);
@@ -255,7 +262,10 @@ describe("context bridge refresh policy", () => {
 
 	test("blocks survive a restart, so the same bytes are re-injected", async () => {
 		const client = mkClient();
-		const db = openDb(":memory:");
+		// A file, and migrated BEFORE the bridge reads: `void migrateStore(...)`
+		// raced the first query and the table did not exist yet.
+		const db = openSqlDb(join(tmpdir(), `ctxbridge-restart-${process.pid}-${Date.now()}.db`));
+		await migrateStore(db);
 		try {
 			const opts: BridgeOpts = {
 				client,
@@ -271,9 +281,9 @@ describe("context bridge refresh policy", () => {
 				recordTurns: true,
 				maxQueue: 64,
 			};
-			const first = await createContextBridge(opts).resolve(input());
+			const first = await (await createContextBridge(opts)).resolve(input());
 			// A "restart": brand-new bridge over the same store.
-			const after = await createContextBridge(opts).resolve(
+			const after = await (await createContextBridge(opts)).resolve(
 				input({ pinnedVersion: first?.version ?? null, pinnedFetchedAtMs: first?.fetchedAtMs ?? 0 }),
 			);
 			expect(after?.block).toBe(first?.block ?? "");
@@ -287,7 +297,7 @@ describe("context bridge refresh policy", () => {
 describe("context bridge write-back", () => {
 	test("creates one session per conversation and attributes the model", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			bridge.recordTurn({
 				scope: "ashlands",
@@ -325,7 +335,7 @@ describe("context bridge write-back", () => {
 
 	test("recordTurns=false writes nothing", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client, { recordTurns: false });
+		const { bridge, db } = await mkBridge(client, { recordTurns: false });
 		try {
 			bridge.recordTurn({
 				scope: "ashlands",
@@ -362,7 +372,7 @@ describe("context bridge write-back", () => {
 
 	test("a tool loop records one turn, not one record per dispatch", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			// One user-visible turn: five tool round-trips, then the synthesis.
 			// Every dispatch carries the SAME unchanged user text — recording per
@@ -391,7 +401,7 @@ describe("context bridge write-back", () => {
 
 	test("a tool loop still running writes nothing", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			bridge.recordTurn(mkRecord({ assistantText: "let me look", turnEnded: false }));
 			await bridge.flush();
@@ -406,7 +416,7 @@ describe("context bridge write-back", () => {
 
 	test("interleaved conversations buffer independently", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			bridge.recordTurn(mkRecord({ conversationKey: "k1", assistantText: "k1 narration", turnEnded: false }));
 			bridge.recordTurn(mkRecord({ conversationKey: "k2", assistantText: "k2 narration", turnEnded: false }));
@@ -425,7 +435,7 @@ describe("context bridge write-back", () => {
 
 	test("a silent turn still records the user message", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			bridge.recordTurn(mkRecord({ assistantText: "", turnEnded: true }));
 			await bridge.flush();
@@ -444,7 +454,7 @@ describe("context layers a team names (project memory, phase one)", () => {
 	// layers in headers and the member in the harness id.
 	test("resolve passes the group, personal and user layers to assemble; a lone router passes empties", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			await bridge.resolve(input({ group: "group.g1", personal: "ashlands.u.u1", user: "u1" }));
 			expect(client.lastLayers).toEqual({ group: "group.g1", personal: "ashlands.u.u1", user: "u1" });
@@ -464,7 +474,7 @@ describe("context layers a team names (project memory, phase one)", () => {
 		// agentdox filter the project's recent tail to that harness, dropping
 		// every pre-0.16 message and every other harness's turns.
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			await bridge.resolve(input({ user: "claude-code" }));
 			expect(client.lastLayers).toEqual({ group: "", personal: "", user: "" });
@@ -475,7 +485,7 @@ describe("context layers a team names (project memory, phase one)", () => {
 
 	test("layers: false sends none, whatever the request names", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client, { layers: false });
+		const { bridge, db } = await mkBridge(client, { layers: false });
 		try {
 			const pin = await bridge.resolve(input({ group: "group.g1", personal: "ashlands.u.u1", user: "u1" }));
 			expect(pin).not.toBeNull();
@@ -490,7 +500,7 @@ describe("context layers a team names (project memory, phase one)", () => {
 		// The version is a hash of the block's content, so two members' blocks
 		// never share a version even in one scope; the shared store keys on it.
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const ada = await bridge.resolve(input({ conversationKey: "ada", personal: "ashlands.u.ada", user: "ada" }));
 			const bob = await bridge.resolve(input({ conversationKey: "bob", personal: "ashlands.u.bob", user: "bob" }));
@@ -509,7 +519,7 @@ describe("context layers a team names (project memory, phase one)", () => {
 
 	test("the recorded turn carries user:<harnessId> on both messages only when the harness is set", async () => {
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client);
+		const { bridge, db } = await mkBridge(client);
 		try {
 			const rec = {
 				scope: "ashlands",
@@ -569,7 +579,7 @@ describe("context layers a team names (project memory, phase one)", () => {
 });
 
 describe("context injection into the wire body", () => {
-	test("appends to the last system message, leaving breakpoint indices valid", () => {
+	test("appends to the last system message, leaving breakpoint indices valid", async () => {
 		const body = {
 			model: "auto",
 			messages: [
@@ -589,7 +599,7 @@ describe("context injection into the wire body", () => {
 		expect(text).toContain("cache_control");
 	});
 
-	test("prepends a system message and shifts breakpoints when there is none", () => {
+	test("prepends a system message and shifts breakpoints when there is none", async () => {
 		const body = { model: "auto", messages: [{ role: "user", content: "hi" }] };
 		const out = injectForTest(body, "BLOCK", [0]);
 		const msgs = out.messages as Record<string, unknown>[];
@@ -600,7 +610,7 @@ describe("context injection into the wire body", () => {
 		expect(JSON.stringify(msgs[1]?.content ?? "")).toContain("cache_control");
 	});
 
-	test("no contextBlock leaves the body untouched", () => {
+	test("no contextBlock leaves the body untouched", async () => {
 		const body = {
 			model: "auto",
 			messages: [

package/test/context-prune.test.ts

@@ -2,7 +2,11 @@ import { describe, expect, test } from "bun:test";
 
 import { createContextStore } from "../src/context/store.ts";
 import { createConversationStore } from "../src/router/state.ts";
-import { openDb } from "../src/util/sqlite.ts";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { migrateStore } from "../src/util/schema.ts";
+import { openSqlDb } from "../src/util/sql.ts";
 
 /**
  * `context_blocks` is content-addressed and shared between conversations, so
@@ -19,66 +23,69 @@ import { openDb } from "../src/util/sqlite.ts";
 describe("context block prune", () => {
 	const HOUR = 3_600_000;
 
-	function seed() {
-		const db = openDb(":memory:");
+	async function seed() {
+		// A file: the shim cannot share `:memory:` between handles, and both
+		// stores here read the same tables.
+		const db = openSqlDb(join(tmpdir(), `ctxprune-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+		await migrateStore(db);
 		const blocks = createContextStore(db);
 		const conversations = createConversationStore(db);
 		const now = Date.now();
 
-		blocks.put("scope", { version: "old-pinned", block: "A", fetchedAtMs: now - 5 * HOUR });
-		blocks.put("scope", { version: "old-orphan", block: "B", fetchedAtMs: now - 5 * HOUR });
-		blocks.put("scope", { version: "fresh-orphan", block: "C", fetchedAtMs: now });
+		await blocks.put("scope", { version: "old-pinned", block: "A", fetchedAtMs: now - 5 * HOUR });
+		await blocks.put("scope", { version: "old-orphan", block: "B", fetchedAtMs: now - 5 * HOUR });
+		await blocks.put("scope", { version: "fresh-orphan", block: "C", fetchedAtMs: now });
 
 		// One live conversation still pins `old-pinned`.
-		const state = conversations.load("conv-1");
+		const state = await conversations.load("conv-1");
 		state.contextVersion = "old-pinned";
 		state.contextFetchedAtMs = now - 5 * HOUR;
-		conversations.save(state);
+		await conversations.save(state);
 
 		return { db, blocks };
 	}
 
-	test("drops an old block that nothing references", () => {
-		const { db, blocks } = seed();
-		expect(blocks.prune(HOUR)).toBe(1);
-		expect(blocks.get("old-orphan")).toBeNull();
-		db.close();
+	test("drops an old block that nothing references", async () => {
+		const { db, blocks } = await seed();
+		expect(await blocks.prune(HOUR)).toBe(1);
+		expect(await blocks.get("old-orphan")).toBeNull();
+		await db.close();
 	});
 
-	test("keeps an old block a conversation still pins", () => {
-		const { db, blocks } = seed();
-		blocks.prune(HOUR);
+	test("keeps an old block a conversation still pins", async () => {
+		const { db, blocks } = await seed();
+		await blocks.prune(HOUR);
 		// Deleting this one would cost that conversation its warm prefix.
-		expect(blocks.get("old-pinned")?.block).toBe("A");
-		db.close();
+		expect((await blocks.get("old-pinned"))?.block).toBe("A");
+		await db.close();
 	});
 
-	test("keeps a block younger than the age cutoff", () => {
-		const { db, blocks } = seed();
-		blocks.prune(HOUR);
-		expect(blocks.get("fresh-orphan")?.block).toBe("C");
-		db.close();
+	test("keeps a block younger than the age cutoff", async () => {
+		const { db, blocks } = await seed();
+		await blocks.prune(HOUR);
+		expect((await blocks.get("fresh-orphan"))?.block).toBe("C");
+		await db.close();
 	});
 
-	test("is a no-op once the unreferenced blocks are gone", () => {
-		const { db, blocks } = seed();
-		expect(blocks.prune(HOUR)).toBe(1);
-		expect(blocks.prune(HOUR)).toBe(0);
-		db.close();
+	test("is a no-op once the unreferenced blocks are gone", async () => {
+		const { db, blocks } = await seed();
+		expect(await blocks.prune(HOUR)).toBe(1);
+		expect(await blocks.prune(HOUR)).toBe(0);
+		await db.close();
 	});
 
-	test("reclaims a block as soon as its last pin is dropped", () => {
-		const { db, blocks } = seed();
+	test("reclaims a block as soon as its last pin is dropped", async () => {
+		const { db, blocks } = await seed();
 		const conversations = createConversationStore(db);
 		// The conversation moves to a new context version (a refresh), which is
 		// what leaves the old block orphaned in production.
-		const state = conversations.load("conv-1");
+		const state = await conversations.load("conv-1");
 		state.contextVersion = "fresh-orphan";
-		conversations.save(state);
+		await conversations.save(state);
 
-		expect(blocks.prune(HOUR)).toBe(2); // old-pinned is now unreferenced too
-		expect(blocks.get("old-pinned")).toBeNull();
-		expect(blocks.get("fresh-orphan")?.block).toBe("C");
-		db.close();
+		expect(await blocks.prune(HOUR)).toBe(2); // old-pinned is now unreferenced too
+		expect(await blocks.get("old-pinned")).toBeNull();
+		expect((await blocks.get("fresh-orphan"))?.block).toBe("C");
+		await db.close();
 	});
 });

package/test/context-query.test.ts

@@ -11,30 +11,30 @@ import { MAX_QUERY_CHARS, relevanceQuery, userContent } from "../src/context/que
 const msg = (role: "user" | "assistant" | "system" | "tool", text: string) => ({ role, text }) as never;
 
 describe("userContent", () => {
-	test("strips wrapper elements and keeps the user's words", () => {
+	test("strips wrapper elements and keeps the user's words", async () => {
 		expect(userContent("<system-reminder>\n5 todo items still open.\n</system-reminder>\nplease fix the water tests")).toBe("please fix the water tests");
 		expect(userContent("<recap>User stepped away; returning.</recap>")).toBe("");
 		expect(userContent("<system-notice>Background job bg_43 completed.</system-notice>")).toBe("");
 	});
 
-	test("an unclosed wrapper at the start is all machinery", () => {
+	test("an unclosed wrapper at the start is all machinery", async () => {
 		expect(userContent("<chat>\nassistant said things\nuser said things")).toBe("");
 		expect(userContent("<system-reminder>Today: 2026-09-07")).toBe("");
 	});
 
-	test("auto-generated stubs are not content", () => {
+	test("auto-generated stubs are not content", async () => {
 		expect(userContent("Attached image(s) from tool result:")).toBe("");
 		expect(userContent("(no output)")).toBe("");
 		expect(userContent("continue")).toBe("");
 	});
 
-	test("ordinary text passes through with whitespace collapsed", () => {
+	test("ordinary text passes through with whitespace collapsed", async () => {
 		expect(userContent("  why does   the\n\nrouter pick glm?  ")).toBe("why does the router pick glm?");
 	});
 });
 
 describe("relevanceQuery", () => {
-	test("takes the last user message with real content, skipping wrapper-only turns", () => {
+	test("takes the last user message with real content, skipping wrapper-only turns", async () => {
 		const req = {
 			messages: [
 				msg("system", "You are omp."),
@@ -48,19 +48,19 @@ describe("relevanceQuery", () => {
 		expect(relevanceQuery(req)).toBe("add a /router command with reports");
 	});
 
-	test("prefers the newest real ask over the opening one", () => {
+	test("prefers the newest real ask over the opening one", async () => {
 		const req = { messages: [msg("user", "first ask"), msg("assistant", "ok"), msg("user", "<recap>x</recap> now fix the report window")] };
 		expect(relevanceQuery(req)).toBe("now fix the report window");
 	});
 
-	test("caps long asks so the block header stays a line", () => {
+	test("caps long asks so the block header stays a line", async () => {
 		const long = "x".repeat(5_000);
 		const q = relevanceQuery({ messages: [msg("user", long)] });
 		expect(q.length).toBe(MAX_QUERY_CHARS);
 		expect(q.endsWith("…")).toBe(true);
 	});
 
-	test("nothing usable yields an empty query", () => {
+	test("nothing usable yields an empty query", async () => {
 		expect(relevanceQuery({ messages: [msg("user", "<chat>\nlog"), msg("assistant", "hi")] })).toBe("");
 		expect(relevanceQuery({ messages: [] })).toBe("");
 	});

package/test/controls.test.ts

@@ -1,15 +1,18 @@
 import { afterAll, beforeAll, 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 type { RouterConfig } from "../src/config/types.ts";
 import { createFeedbackStore } from "../src/cost/feedback.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
 import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
 import { startServer, type StartedServer } from "../src/server/http.ts";
-import { resolveProfile } from "../src/router/index.ts";
+import { pinForRequestedModel, resolveProfile } from "../src/router/index.ts";
 import { ollamaRunway } from "../src/server/http.ts";
 import { createSessionOverrides, OVERRIDE_TTL_MS } from "../src/server/overrides.ts";
-import { openDb } from "../src/util/sqlite.ts";
 import { describeOverride, parseOverrideArgs, renderWhy, type WhyEntry } from "../omp-extension/report-logic.ts";
 
 /**
@@ -19,7 +22,7 @@ import { describeOverride, parseOverrideArgs, renderWhy, type WhyEntry } from ".
  */
 
 describe("session overrides", () => {
-	test("set, read, count down, clear, and expire", () => {
+	test("set, read, count down, clear, and expire", async () => {
 		const o = createSessionOverrides();
 		const now = Date.now();
 		expect(o.get("s1")).toBeNull();
@@ -44,7 +47,7 @@ describe("session overrides", () => {
 		expect(o.get("")).toBeNull();
 	});
 
-	test("clearing both fields reads as no override", () => {
+	test("clearing both fields reads as no override", async () => {
 		const o = createSessionOverrides();
 		o.set("s", { tier: "hard" });
 		o.set("s", { tier: null });
@@ -92,27 +95,29 @@ describe("feedback store", () => {
 		} as LedgerEntry;
 	}
 
-	test("records verdicts against the session's newest kept turn and counts them by model", () => {
-		const db = openDb(":memory:");
+	test("records verdicts against the session's newest kept turn and counts them by model", async () => {
+		const db = openSqlDb(join(tmpdir(), `t-controls.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
 		const cfg = structuredClone(DEFAULT_CONFIG);
 		cfg.ledger.path = ":memory:";
-		const ledger = createLedger(db, cfg);
+		const ledger = createSqlLedger(db, cfg, { findModel: () => null });
 		const fb = createFeedbackStore(db);
-		ledger.record(entry({ createdAtMs: 1_000, slug: "a/m", servedSlug: "a/m" }));
-		ledger.record(entry({ createdAtMs: 2_000, slug: "b/m", servedSlug: "b/m", wasted: true })); // a wasted probe is never "the turn"
-		ledger.record(entry({ createdAtMs: 3_000, slug: "c/m", servedSlug: "c/m" }));
-		ledger.record(entry({ createdAtMs: 4_000, ompSessionId: "omp-2", slug: "d/m", servedSlug: "d/m" }));
-		const latest = ledger.latestForSession!("omp-1")!;
-		expect(latest.servedSlug).toBe("c/m");
-		expect(ledger.entriesForSession!("omp-1", 10).map((e) => e.servedSlug)).toEqual(["c/m", "a/m"]);
-		expect(ledger.latestForSession!("")).toBeNull();
+		await ledger.record(entry({ createdAtMs: 1_000, slug: "a/m", servedSlug: "a/m" }));
+		await ledger.record(entry({ createdAtMs: 2_000, slug: "b/m", servedSlug: "b/m", wasted: true })); // a wasted probe is never "the turn"
+		await ledger.record(entry({ createdAtMs: 3_000, slug: "c/m", servedSlug: "c/m" }));
+		await ledger.record(entry({ createdAtMs: 4_000, ompSessionId: "omp-2", slug: "d/m", servedSlug: "d/m" }));
+		const latest = await ledger.latestForSession("omp-1");
+		expect(latest?.servedSlug).toBe("c/m");
+		expect((await ledger.entriesForSession("omp-1", 10)).map((e) => e.servedSlug)).toEqual(["c/m", "a/m"]);
+		expect(await ledger.latestForSession("")).toBeNull();
 
-		fb.record({ ledgerId: latest.id, ompSessionId: "omp-1", slug: "c/m", tier: "simple", verdict: "bad", note: "wrong file" }, 5_000);
-		fb.record({ ledgerId: latest.id, ompSessionId: "omp-1", slug: "c/m", tier: "simple", verdict: "good", note: "" }, 6_000);
-		expect(fb.forLedgerId(latest.id).map((f) => f.verdict)).toEqual(["good", "bad"]);
-		expect([...fb.countsBySlug(0).entries()]).toEqual([["c/m", { good: 1, bad: 1 }]]);
-		expect(fb.countsBySlug(5_500).get("c/m")).toEqual({ good: 1, bad: 0 });
-		db.close();
+		const ledgerId = latest?.id ?? "";
+		await fb.record({ ledgerId, ompSessionId: "omp-1", slug: "c/m", tier: "simple", verdict: "bad", note: "wrong file" }, 5_000);
+		await fb.record({ ledgerId, ompSessionId: "omp-1", slug: "c/m", tier: "simple", verdict: "good", note: "" }, 6_000);
+		expect((await fb.forLedgerId(ledgerId)).map((f) => f.verdict)).toEqual(["good", "bad"]);
+		expect([...(await fb.countsBySlug(0)).entries()]).toEqual([["c/m", { good: 1, bad: 1 }]]);
+		expect((await fb.countsBySlug(5_500)).get("c/m")).toEqual({ good: 1, bad: 0 });
+		await db.close();
 	});
 });
 
@@ -184,7 +189,7 @@ describe("/router why and override parsing", () => {
 		feedback: [{ verdict: "bad", note: "edited the wrong file", createdAtMs: 1_000_500 }],
 	};
 
-	test("renderWhy names the model, tier, confidence, cost, cache, trail and feedback", () => {
+	test("renderWhy names the model, tier, confidence, cost, cache, trail and feedback", async () => {
 		const text = renderWhy(entry, 1_060_000);
 		expect(text).toContain("turn 12 · 1m ago · ollama · ollama/glm-5.3-flash (asked z-ai/glm-5.3-flash) [moderate]");
 		expect(text).toContain("classified moderate by heuristic at 42% confidence · task coding");
@@ -194,7 +199,7 @@ describe("/router why and override parsing", () => {
 		expect(text).toContain("  - bad: edited the wrong file");
 	});
 
-	test("parseOverrideArgs handles pin, tier with turns, off, and errors", () => {
+	test("parseOverrideArgs handles pin, tier with turns, off, and errors", async () => {
 		expect(parseOverrideArgs("pin", "ollama/glm-5.3-flash")).toEqual({ kind: "pin", slug: "ollama/glm-5.3-flash" });
 		expect(parseOverrideArgs("pin", "off")).toEqual({ kind: "pin", slug: null });
 		expect(parseOverrideArgs("pin", "")).toEqual({ kind: "show" });
@@ -205,7 +210,7 @@ describe("/router why and override parsing", () => {
 		expect(parseOverrideArgs("tier", "hard x").kind).toBe("error");
 	});
 
-	test("describeOverride summarises what is in force", () => {
+	test("describeOverride summarises what is in force", async () => {
 		expect(describeOverride(null)).toBe("no override on this session");
 		expect(describeOverride({ slug: "a/b", tier: "hard", turnsLeft: 1 })).toBe("pinned to a/b, tier forced to hard · 1 turn left");
 		expect(describeOverride({ slug: null, tier: "simple", turnsLeft: 0 })).toBe("tier forced to simple · until cleared");
@@ -213,7 +218,7 @@ describe("/router why and override parsing", () => {
 });
 
 describe("ollamaRunway", () => {
-	test("days of credits left at the calibrated weekly burn", () => {
+	test("days of credits left at the calibrated weekly burn", async () => {
 		const r = ollamaRunway({ usedUsd: 6.3, creditsUsd: 60 }, 7, 1.25)!;
 		expect(r.dailyBurnUsd).toBeCloseTo(1.25, 6);
 		expect(r.creditsLeftUsd).toBeCloseTo(53.7, 6);
@@ -224,7 +229,7 @@ describe("ollamaRunway", () => {
 });
 
 describe("subagent profile", () => {
-	test("a subagent asking for the default profile is routed under server.subagentProfile; explicit profiles are honoured", () => {
+	test("a subagent asking for the default profile is routed under server.subagentProfile; explicit profiles are honoured", async () => {
 		const cfg = structuredClone(DEFAULT_CONFIG);
 		expect(resolveProfile(cfg, "auto", true).id).toBe("auto-sub");
 		expect(resolveProfile(cfg, "auto", false).id).toBe("auto");
@@ -237,6 +242,28 @@ describe("subagent profile", () => {
 	});
 });
 
+describe("requested model", () => {
+	test("a catalog slug pins, a profile does not, and an unknown name is refused rather than substituted", async () => {
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		const slugs = ["deepseek/deepseek-v4.1-flash", "ollama/deepseek-v4.1-flash"];
+		// A profile id routes normally: nothing is pinned.
+		expect(pinForRequestedModel(cfg, slugs, "auto", "auto")).toBeUndefined();
+		expect(pinForRequestedModel(cfg, slugs, "auto-cheap", "auto-model-router/auto-cheap")).toBeUndefined();
+		// A real slug is honoured as a pin, and the vendor prefix decides which
+		// one: the stripped name alone is ambiguous between these two.
+		expect(pinForRequestedModel(cfg, slugs, "deepseek-v4.1-flash", "deepseek/deepseek-v4.1-flash")).toBe(
+			"deepseek/deepseek-v4.1-flash",
+		);
+		expect(pinForRequestedModel(cfg, slugs, "deepseek-v4.1-flash", "ollama/deepseek-v4.1-flash")).toBe(
+			"ollama/deepseek-v4.1-flash",
+		);
+		// Neither a profile nor a slug: refused. Silently routing `auto` here is
+		// what billed a caller for glm-5.3-flash after it asked for v4.1-flash.
+		expect(() => pinForRequestedModel(cfg, slugs, "deepseek-v4.1-flash", "deepseek-v4.1-flash")).toThrow();
+		expect(() => pinForRequestedModel(cfg, slugs, "nope", "vendor/nope")).toThrow();
+	});
+});
+
 describe("digest endpoints", () => {
 	let handle: StartedServer;
 	let baseUrl = "";