auto-model-router 0.31.0 → 0.32.0

package/test/escalate.test.ts

@@ -57,14 +57,14 @@ function toolDelta(
 }
 
 describe("createProbe", () => {
-	test("valid tool-call JSON commits", () => {
+	test("valid tool-call JSON commits", async () => {
 		const p = createProbe(plan(), req(), ALL_TRIGGERS);
 		expect(p.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }))).toBeNull();
 		const verdict = p.observe(toolDelta(0, { argsDelta: '.ts"}' }));
 		expect(verdict?.action).toBe("commit");
 	});
 
-	test("truncated tool-call JSON at stream end yields malformed_tool_args", () => {
+	test("truncated tool-call JSON at stream end yields malformed_tool_args", async () => {
 		// Via the finish event.
 		const p1 = createProbe(plan(), req(), ALL_TRIGGERS);
 		p1.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }));
@@ -80,7 +80,7 @@ describe("createProbe", () => {
 		expect(v2).toMatchObject({ signal: "malformed_tool_args" });
 	});
 
-	test("a tool call identical to the previous assistant call yields repeat_tool_call", () => {
+	test("a tool call identical to the previous assistant call yields repeat_tool_call", async () => {
 		const history: NormMessage[] = [
 			{ role: "user", text: "read it", images: 0, textBytes: 8, toolCalls: [] },
 			{
@@ -99,7 +99,7 @@ describe("createProbe", () => {
 		expect(verdict).toMatchObject({ signal: "repeat_tool_call" });
 	});
 
-	test("a different tool call is not a repeat", () => {
+	test("a different tool call is not a repeat", async () => {
 		const history: NormMessage[] = [
 			{
 				role: "assistant",
@@ -114,14 +114,14 @@ describe("createProbe", () => {
 		expect(verdict?.action).toBe("commit");
 	});
 
-	test("a disabled plan commits on the first chunk", () => {
+	test("a disabled plan commits on the first chunk", async () => {
 		const p = createProbe(plan({ enabled: false }), req(), ALL_TRIGGERS);
 		const verdict = p.observe(text("anything at all"));
 		expect(verdict?.action).toBe("commit");
 		expect(p.held()).toHaveLength(1);
 	});
 
-	test("a signal absent from triggers never fires", () => {
+	test("a signal absent from triggers never fires", async () => {
 		// Truncated args would be malformed_tool_args, but the trigger is off.
 		const p1 = createProbe(plan(), req(), new Set(["refusal"]));
 		p1.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }));
@@ -135,14 +135,14 @@ describe("createProbe", () => {
 		expect(v2.action).toBe("commit");
 	});
 
-	test("refusal openers escalate as soon as text arrives", () => {
+	test("refusal openers escalate as soon as text arrives", async () => {
 		const p = createProbe(plan(), req(), ALL_TRIGGERS);
 		const verdict = p.observe(text("I'm sorry, but I can't help with that request."));
 		expect(verdict?.action).toBe("escalate");
 		expect(verdict).toMatchObject({ signal: "refusal" });
 	});
 
-	test("a forced tool choice answered with prose yields missing_expected_tool_call", () => {
+	test("a forced tool choice answered with prose yields missing_expected_tool_call", async () => {
 		const tools: NormTool[] = [{ name: "read", description: "read a file", schemaBytes: 42 }];
 		const p = createProbe(plan(), req([], { tools, forcedToolChoice: true }), ALL_TRIGGERS);
 		p.observe(text("Sure, here is some prose instead."));
@@ -151,20 +151,20 @@ describe("createProbe", () => {
 		expect(verdict).toMatchObject({ signal: "missing_expected_tool_call" });
 	});
 
-	test("enough held text commits", () => {
+	test("enough held text commits", async () => {
 		const p = createProbe(plan({ maxTokens: 2 }), req(), ALL_TRIGGERS);
 		const verdict = p.observe(text("this is well over eight characters"));
 		expect(verdict?.action).toBe("commit");
 	});
 
-	test("an empty stop with nothing emitted yields empty_completion", () => {
+	test("an empty stop with nothing emitted yields empty_completion", async () => {
 		const p = createProbe(plan(), req(), ALL_TRIGGERS);
 		const verdict = p.observe(chunk([{ type: "finish", reason: "stop" }]));
 		expect(verdict?.action).toBe("escalate");
 		expect(verdict).toMatchObject({ signal: "empty_completion" });
 	});
 
-	test("a stalled stream escalates at the hold ceiling instead of committing silence", () => {
+	test("a stalled stream escalates at the hold ceiling instead of committing silence", async () => {
 		let t = 0;
 		const p = createProbe(plan({ maxHoldMs: 1_000 }), req(), ALL_TRIGGERS, () => t);
 		expect(p.observe(chunk([]))).toBeNull();
@@ -174,7 +174,7 @@ describe("createProbe", () => {
 		expect(verdict).toMatchObject({ signal: "empty_completion" });
 	});
 
-	test("the hold ceiling still commits when content has arrived", () => {
+	test("the hold ceiling still commits when content has arrived", async () => {
 		let t = 0;
 		const p = createProbe(plan({ maxTokens: 1_000, maxHoldMs: 1_000 }), req(), ALL_TRIGGERS, () => t);
 		expect(p.observe(text("partial answer"))).toBeNull();
@@ -183,7 +183,7 @@ describe("createProbe", () => {
 		expect(verdict?.action).toBe("commit");
 	});
 
-	test("a length finish on prose commits: that is the caller's max_tokens", () => {
+	test("a length finish on prose commits: that is the caller's max_tokens", async () => {
 		// Escalating cannot fix it — the retry runs under the same cap and
 		// truncates in the same place, so it would just bill twice.
 		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
@@ -192,7 +192,7 @@ describe("createProbe", () => {
 		expect(verdict?.action).toBe("commit");
 	});
 
-	test("a length finish that truncated tool-call arguments still escalates", () => {
+	test("a length finish that truncated tool-call arguments still escalates", async () => {
 		// Structurally unusable output: another model may emit a complete call.
 		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
 		expect(p.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }))).toBeNull();
@@ -200,14 +200,14 @@ describe("createProbe", () => {
 		expect(verdict?.action).toBe("escalate");
 	});
 
-	test("a length finish having produced nothing escalates as an empty completion", () => {
+	test("a length finish having produced nothing escalates as an empty completion", async () => {
 		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
 		const verdict = p.observe(chunk([{ type: "finish", reason: "length" }]));
 		expect(verdict?.action).toBe("escalate");
 		if (verdict?.action === "escalate") expect(verdict.signal).toBe("empty_completion");
 	});
 
-	test("reasoning-only output counts as alive at the hold ceiling", () => {
+	test("reasoning-only output counts as alive at the hold ceiling", async () => {
 		// A reasoning model that has emitted only reasoning tokens after the
 		// ceiling is working normally; escalating would discard a healthy paid
 		// generation.
@@ -219,7 +219,7 @@ describe("createProbe", () => {
 		expect(verdict?.action).toBe("commit");
 	});
 
-	test("a stream that ENDS with only reasoning is still hollow", () => {
+	test("a stream that ENDS with only reasoning is still hollow", async () => {
 		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
 		expect(p.observe(chunk([{ type: "reasoning", delta: "thinking" }]))).toBeNull();
 		const verdict = p.verdictOnEnd();

package/test/eval.test.ts

@@ -12,26 +12,26 @@ import type { EvalTask, JudgedTask } from "../src/eval/tasks.ts";
 import { openDb } from "../src/util/sqlite.ts";
 
 describe("grade helpers", () => {
-	test("answerScore matches whole reply, last line, or a standalone token", () => {
+	test("answerScore matches whole reply, last line, or a standalone token", async () => {
 		expect(answerScore("9.9", "9.9")).toBe(1);
 		expect(answerScore("The answer is 9.9", "9.9")).toBe(1);
 		expect(answerScore("reasoning...\n9.9", "9.9")).toBe(1);
 		expect(answerScore("19.99", "9.9")).toBe(0); // not a substring match
 		expect(answerScore("", "9.9")).toBe(0);
 	});
-	test("tokenCoverage is the fraction of tokens present", () => {
+	test("tokenCoverage is the fraction of tokens present", async () => {
 		expect(tokenCoverage("return a + b;", ["a + b"])).toBe(1);
 		expect(tokenCoverage("n * 2", ["n", "*", "2"])).toBe(1);
 		expect(tokenCoverage("n plus two", ["n", "*", "2"])).toBeCloseTo(1 / 3);
 	});
-	test("extractJson tolerates fences and prose; jsonField reads a key", () => {
+	test("extractJson tolerates fences and prose; jsonField reads a key", async () => {
 		expect(extractJson('here: {"answer": 8} ok')).toEqual({ answer: 8 });
 		expect(extractJson("```json\n[2,3,5]\n```")).toEqual([2, 3, 5]);
 		expect(extractJson("no json here")).toBeUndefined();
 		expect(jsonField({ tool: "read_file" }, "tool")).toBe("read_file");
 		expect(jsonField([1, 2], "tool")).toBeUndefined();
 	});
-	test("isRefusalOrEmpty flags empties and refusals", () => {
+	test("isRefusalOrEmpty flags empties and refusals", async () => {
 		expect(isRefusalOrEmpty("")).toBe(true);
 		expect(isRefusalOrEmpty("I cannot help with that")).toBe(true);
 		expect(isRefusalOrEmpty("sure, here")).toBe(false);
@@ -39,7 +39,7 @@ describe("grade helpers", () => {
 });
 
 describe("calibration", () => {
-	test("fitAxis is OLS, needs MIN_ANCHORS points and some spread", () => {
+	test("fitAxis is OLS, needs MIN_ANCHORS points and some spread", async () => {
 		const fit = fitAxis([
 			{ raw: 0.2, aa: 40 },
 			{ raw: 0.5, aa: 60 },
@@ -56,7 +56,7 @@ describe("calibration", () => {
 		expect(fitAxis([{ raw: 0.8, aa: 40 }, { raw: 0.5, aa: 60 }, { raw: 0.2, aa: 80 }])).toBeNull();
 	});
 
-	test("pickAnchors spreads over the score range, skips the target and the unscored", () => {
+	test("pickAnchors spreads over the score range, skips the target and the unscored", async () => {
 		const m = (slug: string, coding: number | undefined, supportsTools = true) => ({ slug, quality: coding === undefined ? {} : { coding }, supportsTools });
 		const catalog = [m("a/10", 10), m("a/30", 30), m("a/50", 50), m("a/70", 70), m("a/90", 90), m("a/target", undefined), m("a/notools", 60, false)];
 		const picked = pickAnchors(catalog, "a/target");
@@ -101,7 +101,7 @@ describe("calibration", () => {
 		expect(many!.byComplexity.easy).toBeUndefined();
 	});
 
-	test("the suite spans complexities, and hard items are not all pinned at the ceiling", () => {
+	test("the suite spans complexities, and hard items are not all pinned at the ceiling", async () => {
 		const bands = new Set(EVAL_TASKS.map((t) => t.complexity ?? "easy"));
 		expect(bands.has("easy")).toBe(true);
 		expect(bands.has("hard")).toBe(true);
@@ -128,7 +128,7 @@ describe("calibration", () => {
 		expect(hard.find((t) => t.id === "coding/regex-backtrack")!.grade("XX\nab\nfalse\nx|y\na[b$]c")).toBe(1);
 	});
 
-	test("fitCalibration + toLocalFeedScores place a target on the AA scale", () => {
+	test("fitCalibration + toLocalFeedScores place a target on the AA scale", async () => {
 		expect(MIN_ANCHORS).toBe(3);
 		const anchors: EvalResult[] = [
 			{ slug: "a/one", axes: { coding: { sum: 0.2, n: 1 }, intelligence: { sum: 0, n: 0 }, agentic: { sum: 0, n: 0 } }, errors: 0, repeats: 1, spread: {}, byComplexity: {}, axesHard: { coding: { sum: 0, n: 0 }, intelligence: { sum: 0, n: 0 }, agentic: { sum: 0, n: 0 } } },
@@ -150,7 +150,7 @@ describe("calibration", () => {
 		expect(local[0]!.intelligence).toBeUndefined(); // axis had no fit, so not emitted
 	});
 
-	test("calibrating on the hard band beats calibrating on everything", () => {
+	test("calibrating on the hard band beats calibrating on everything", async () => {
 		// Three anchors published 20/50/80 apart. On the FULL suite they all score ~0.97
 		// because easy and moderate pin everyone at the ceiling; on the hard band alone they
 		// separate. Same models, same publishing, different x — and only one of them can fit.
@@ -180,7 +180,7 @@ describe("calibration", () => {
 		expect(pooled).toEqual([]);
 	});
 
-	test("a weak fit is refused, not published", () => {
+	test("a weak fit is refused, not published", async () => {
 		// Points with a real but noisy relationship: computable (r >= MIN_R) yet not worth
 		// acting on. `r` and `n` used to be computed and then thrown away.
 		const noisy = [
@@ -252,7 +252,7 @@ describe("local source integration", () => {
 		};
 	}
 
-	test("local fills only where no stronger source has the axis", () => {
+	test("local fills only where no stronger source has the axis", async () => {
 		const catalog = [raw("z-ai/glm-5.3-flash")];
 		const feeds: FeedScore[] = [
 			{ key: "glm-5-3-flash", creator: "z-ai", source: "artificial_analysis", coding: 61 },
@@ -266,7 +266,7 @@ describe("local source integration", () => {
 		expect(result.sources.artificial_analysis).toBe(1);
 	});
 
-	test("saveLocalScores / loadLocalScores round-trip", () => {
+	test("saveLocalScores / loadLocalScores round-trip", async () => {
 		const db = openDb(":memory:");
 		const scores: FeedScore[] = [{ key: "muse-glimmer-30b", creator: "meta", source: "local", coding: 42, agentic: 39 }];
 		saveLocalScores(db, scores, 123);
@@ -276,7 +276,7 @@ describe("local source integration", () => {
 });
 
 describe("llm judge", () => {
-	test("parseScore takes the last standalone 0-10 and scales to 0-1", () => {
+	test("parseScore takes the last standalone 0-10 and scales to 0-1", async () => {
 		expect(parseScore("8")).toBeCloseTo(0.8, 5);
 		expect(parseScore("Score: 10/10")).toBeCloseTo(1, 5);
 		expect(parseScore("I count 3 issues, so 7")).toBeCloseTo(0.7, 5); // last wins

package/test/executable.test.ts

@@ -10,7 +10,7 @@ import { parseRemoteRouter } from "../omp-extension/remote-logic.ts";
 const NL = String.fromCharCode(10);
 
 describe("the single-file member install", () => {
-	test("the embedded package is the install: CLI, harness integrations, runtime deps; no tests, no caches", () => {
+	test("the embedded package is the install: CLI, harness integrations, runtime deps; no tests, no caches", async () => {
 		const pkg = collectPackageFiles(process.cwd());
 		expect(pkg.version).toBe((JSON.parse(readFileSync("package.json", "utf8")) as { version: string }).version);
 		expect(pkg.files["src/index.ts"]).toContain("connect");
@@ -28,7 +28,7 @@ describe("the single-file member install", () => {
 		expect(names.some((n) => /\.d\.ts$/.test(n) && n.startsWith("node_modules/"))).toBe(false);
 	});
 
-	test("targets and file names", () => {
+	test("targets and file names", async () => {
 		expect(isExecutableTarget("linux-x64")).toBe(true);
 		expect(isExecutableTarget("linux-x86")).toBe(false);
 		expect(executableFileName("windows-x64")).toBe("auto-model-router-windows-x64.exe");
@@ -44,7 +44,7 @@ describe("the single-file member install", () => {
 		expect(await readEmbeddedPackage()).toBeNull();
 	});
 
-	test("materializing writes the files once, keyed by content, under the router home", () => {
+	test("materializing writes the files once, keyed by content, under the router home", async () => {
 		const home = mkdtempSync(join(tmpdir(), "amr-mat-"));
 		try {
 			const pkg = { version: "9.9.9", files: { "package.json": `{"version":"9.9.9"}${NL}`, "src/index.ts": `console.log(1)${NL}`, "omp-extension/x.ts": "export {}" } };
@@ -63,7 +63,7 @@ describe("the single-file member install", () => {
 		}
 	});
 
-	test("connect from the executable: it is Claude Code's key helper, goes on PATH, and remote.json names it", () => {
+	test("connect from the executable: it is Claude Code's key helper, goes on PATH, and remote.json names it", async () => {
 		const home = mkdtempSync(join(tmpdir(), "amr-exe-connect-"));
 		const claude = join(home, ".claude");
 		mkdirSync(claude, { recursive: true });
@@ -98,7 +98,7 @@ describe("the single-file member install", () => {
 		expect(seen[0]?.url).toBe("https://team.example/setup/exchange");
 		expect(JSON.parse(seen[0]?.body ?? "{}")).toEqual({ token: "amrs_t", device: "laptop" });
 		const refused = (async () => Response.json({ error: "invalid_token" }, { status: 401 })) as unknown as typeof fetch;
-		await expect(exchangeSetupToken("https://team.example", "amrs_old", "laptop", refused)).rejects.toThrow("refused");
+		(await expect(exchangeSetupToken("https://team.example", "amrs_old", "laptop", refused))).rejects.toThrow("refused");
 	});
 
 	test("the executable builds for this host and knows its version from the embedded package", async () => {
@@ -118,7 +118,7 @@ describe("the single-file member install", () => {
 		}
 	}, 120_000);
 
-	test("the global handle is what marks a compiled process", () => {
+	test("the global handle is what marks a compiled process", async () => {
 		const g = globalThis as Record<string, unknown>;
 		g[EMBEDDED_GLOBAL] = { manifestPath: "/$bunfs/root/manifest.json" };
 		try {

package/test/exploration.test.ts

@@ -103,7 +103,6 @@ function run(opts: {
 		profile: opts.profile ?? PROFILE,
 		state: opts.st ?? state(),
 		snapshot: SNAPSHOT,
-		ledger: null,
 		cfg,
 		nowMs: NOW,
 		...(opts.excludeSlugs === undefined ? {} : { excludeSlugs: opts.excludeSlugs }),
@@ -113,14 +112,14 @@ function run(opts: {
 const ALWAYS = { simple: 1, moderate: 1, hard: 1 };
 
 describe("exploration is opt-in", () => {
-	test("never fires under the shipped defaults", () => {
+	test("never fires under the shipped defaults", async () => {
 		expect(BASE.exploration.enabled).toBe(false);
 		for (const tier of ["simple", "moderate", "hard"] as Tier[]) {
 			expect(run({ tier }).explored).toBeNull();
 		}
 	});
 
-	test("enabled with no rates configured still never fires", () => {
+	test("enabled with no rates configured still never fires", async () => {
 		const cfg = withExploration({ enabled: true, rates: {} });
 		for (const tier of ["simple", "moderate", "hard"] as Tier[]) {
 			expect(run({ tier, cfg }).explored).toBeNull();
@@ -129,20 +128,20 @@ describe("exploration is opt-in", () => {
 });
 
 describe("per-tier rates", () => {
-	test("each tier is governed by its own rate, not one global one", () => {
+	test("each tier is governed by its own rate, not one global one", async () => {
 		const cfg = withExploration({ enabled: true, rates: { simple: 0, moderate: 0, hard: 1 } });
 		expect(run({ tier: "simple", cfg }).explored).toBeNull();
 		expect(run({ tier: "moderate", cfg }).explored).toBeNull();
 		expect(run({ tier: "hard", cfg }).explored).toEqual({ from: "hard", to: "moderate" });
 	});
 
-	test("a tier absent from the rates map is never explored", () => {
+	test("a tier absent from the rates map is never explored", async () => {
 		const cfg = withExploration({ enabled: true, rates: { hard: 1 } });
 		expect(run({ tier: "moderate", cfg }).explored).toBeNull();
 		expect(run({ tier: "hard", cfg }).explored).not.toBeNull();
 	});
 
-	test("the shipped defaults weight expensive tiers far above cheap ones", () => {
+	test("the shipped defaults weight expensive tiers far above cheap ones", async () => {
 		const r = BASE.exploration.rates;
 		expect(r.hard ?? 0).toBeGreaterThan(r.simple ?? 0);
 		expect(r.moderate ?? 0).toBeGreaterThan(r.simple ?? 0);
@@ -152,19 +151,19 @@ describe("per-tier rates", () => {
 describe("exploration drops exactly one tier", () => {
 	const cfg = withExploration({ enabled: true, rates: ALWAYS });
 
-	test("moderate explores down to simple", () => {
+	test("moderate explores down to simple", async () => {
 		expect(run({ tier: "moderate", cfg }).explored).toEqual({ from: "moderate", to: "simple" });
 	});
 
-	test("hard explores down to moderate, never further", () => {
+	test("hard explores down to moderate, never further", async () => {
 		expect(run({ tier: "hard", cfg }).explored).toEqual({ from: "hard", to: "moderate" });
 	});
 
-	test("trivial is the floor and cannot be explored below", () => {
+	test("trivial is the floor and cannot be explored below", async () => {
 		expect(run({ tier: "trivial", cfg }).explored).toBeNull();
 	});
 
-	test("the decision trail says so out loud", () => {
+	test("the decision trail says so out loud", async () => {
 		expect(run({ tier: "moderate", cfg }).reasons.some((r) => r.startsWith("exploration:"))).toBe(true);
 	});
 });
@@ -172,11 +171,11 @@ describe("exploration drops exactly one tier", () => {
 describe("hysteresis holds are explored only once the cache is cold", () => {
 	const cfg = withExploration({ enabled: true, rates: ALWAYS, stickyPolicy: "cold-cache" });
 
-	test("a held tier with a WARM cache is left alone", () => {
+	test("a held tier with a WARM cache is left alone", async () => {
 		expect(run({ tier: "simple", cfg, st: heldState("hard", "warm") }).explored).toBeNull();
 	});
 
-	test("a held tier with a COLD cache is explorable", () => {
+	test("a held tier with a COLD cache is explorable", async () => {
 		// This is the population that carries most of the spend: turns that
 		// reach hard by hold rather than by classification.
 		expect(run({ tier: "simple", cfg, st: heldState("hard", "cold") }).explored).toEqual({
@@ -185,18 +184,18 @@ describe("hysteresis holds are explored only once the cache is cold", () => {
 		});
 	});
 
-	test("the reason names the hold and the cache state, for later analysis", () => {
+	test("the reason names the hold and the cache state, for later analysis", async () => {
 		const d = run({ tier: "simple", cfg, st: heldState("hard", "cold") });
 		expect(d.reasons.some((r) => r.includes("held tier (cold cache)"))).toBe(true);
 	});
 
-	test("stickyPolicy never leaves holds alone entirely", () => {
+	test("stickyPolicy never leaves holds alone entirely", async () => {
 		const off = withExploration({ enabled: true, rates: ALWAYS, stickyPolicy: "never" });
 		expect(run({ tier: "simple", cfg: off, st: heldState("hard", "cold") }).explored).toBeNull();
 		expect(run({ tier: "simple", cfg: off, st: heldState("hard", "warm") }).explored).toBeNull();
 	});
 
-	test("stickyPolicy always reaches held turns even with a live cache", () => {
+	test("stickyPolicy always reaches held turns even with a live cache", async () => {
 		// The only setting that samples the population carrying most of the
 		// spend, at the price of a forfeited cache read.
 		const always = withExploration({ enabled: true, rates: ALWAYS, stickyPolicy: "always" });
@@ -215,16 +214,16 @@ describe("hysteresis holds are explored only once the cache is cold", () => {
 describe("exploration respects the remaining guards", () => {
 	const cfg = withExploration({ enabled: true, rates: ALWAYS });
 
-	test("never routes below the profile floor", () => {
+	test("never routes below the profile floor", async () => {
 		const floored: ProfileConfig = { ...PROFILE, minTier: "moderate" };
 		expect(run({ tier: "moderate", cfg, profile: floored }).explored).toBeNull();
 	});
 
-	test("skips forced escalations, which already proved the cheap tier failed", () => {
+	test("skips forced escalations, which already proved the cheap tier failed", async () => {
 		expect(run({ tier: "moderate", cfg, source: "escalation" }).explored).toBeNull();
 	});
 
-	test("skips failover retries so a second confound is not introduced", () => {
+	test("skips failover retries so a second confound is not introduced", async () => {
 		expect(run({ tier: "moderate", cfg, excludeSlugs: ["vendor/broken"] }).explored).toBeNull();
 	});
 });
@@ -232,7 +231,7 @@ describe("exploration respects the remaining guards", () => {
 describe("exploration is deterministic", () => {
 	const cfg = withExploration({ enabled: true, rates: { simple: 0.5, moderate: 0.5, hard: 0.5 } });
 
-	test("the same turn always draws the same way, so explain can replay it", () => {
+	test("the same turn always draws the same way, so explain can replay it", async () => {
 		for (const text of ["alpha task", "beta task", "gamma task"]) {
 			const first = run({ userText: text, tier: "moderate", cfg });
 			for (let i = 0; i < 5; i++) {
@@ -241,7 +240,7 @@ describe("exploration is deterministic", () => {
 		}
 	});
 
-	test("the draw honours the configured rate across many turns", () => {
+	test("the draw honours the configured rate across many turns", async () => {
 		const cfg25 = withExploration({ enabled: true, rates: { moderate: 0.25 } });
 		let explored = 0;
 		const N = 400;

package/test/failover.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, test } from "bun:test";
+import { fakeLedger } from "./fakes.ts";
 import { createDisabledBridge } from "../src/context/bridge.ts";
 import type { 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,
@@ -245,29 +246,29 @@ function mkRouter(decisions: Decision[]): { router: Router; calls: RouteCall[] }
 	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 };
 }
 
 function mkConversations(): { store: ConversationStore; map: Map<string, ConversationState> } {
 	const map = new Map<string, ConversationState>();
 	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 = {
@@ -290,11 +291,11 @@ function mkConversations(): { store: ConversationStore; map: Map<string, Convers
 			map.set(k, fresh);
 			return fresh;
 		},
-		save: (s) => {
+		save: async (s) => {
 			map.set(s.key, s);
 		},
-		accrue: () => {},
-		prune: () => 0,
+		accrue: async () => {},
+		prune: async () => 0,
 	};
 	return { store, map };
 }
@@ -664,19 +665,19 @@ describe("same-tier failover", () => {
 });
 
 describe("400 classification (review 2026-09-05 follow-up)", () => {
-	test("a 400 naming a model capability limit is retryable, so failover picks a sibling", () => {
+	test("a 400 naming a model capability limit is retryable, so failover picks a sibling", async () => {
 		const e = classifyUpstreamStatus(400, { error: { message: "This model only supports single tool-calls at once!" } });
 		expect(e.kind).toBe("invalid_request");
 		expect(e.retryable).toBe(true);
 	});
 
-	test("a 400 for a malformed request stays non-retryable", () => {
+	test("a 400 for a malformed request stays non-retryable", async () => {
 		const e = classifyUpstreamStatus(400, { error: { message: "messages[3].content: invalid type" } });
 		expect(e.kind).toBe("invalid_request");
 		expect(e.retryable).toBe(false);
 	});
 
-	test("a 400 for context overflow is still context_length", () => {
+	test("a 400 for context overflow is still context_length", async () => {
 		const e = classifyUpstreamStatus(400, { error: { message: "This endpoint's maximum context length is 131072 tokens" } });
 		expect(e.kind).toBe("context_length");
 		expect(e.retryable).toBe(false);

package/test/fakes.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared test doubles for the store-backed interfaces.
+ *
+ * `AsyncLedger` and `ConversationStore` are deliberately TOTAL — a real backend
+ * implements every method, and letting callers guess which half they have is
+ * how a routing signal silently goes missing. That makes a hand-written fake
+ * verbose, so the defaults live here once: a ledger that has observed nothing,
+ * and a conversation store in a Map.
+ */
+
+import type { AsyncLedger, LedgerEntry } from "../src/cost/types.ts";
+import type { ConversationState, ConversationStore } from "../src/router/types.ts";
+
+/** A ledger that knows nothing, with the parts under test overridden. */
+export function fakeLedger(over: Partial<AsyncLedger> = {}): AsyncLedger {
+	return {
+		record: async () => {},
+		conversationSpend: async () => 0,
+		spendSince: async () => 0,
+		blendedRate: async () => null,
+		trust: async () => null,
+		allTrust: async () => [],
+		latency: async () => null,
+		signals: async () => new Map(),
+		cacheReliability: async () => new Map(),
+		escalationCost: async () => null,
+		tokenRatio: async () => null,
+		recentEntries: async () => [],
+		softFailureSpikes: async () => [],
+		providerSpendSince: async () => 0,
+		latestForSession: async () => null,
+		entriesForSession: async () => [],
+		prune: async () => ({ deleted: 0, oldestKeptMs: null }),
+		markWasted: async () => {},
+		...over,
+	};
+}
+
+/** A ledger that records into an array, for asserting what a turn wrote. */
+export function recordingLedger(over: Partial<AsyncLedger> = {}): { ledger: AsyncLedger; entries: LedgerEntry[] } {
+	const entries: LedgerEntry[] = [];
+	return {
+		entries,
+		ledger: fakeLedger({
+			record: async (entry) => {
+				entries.push(entry);
+			},
+			...over,
+		}),
+	};
+}
+
+export function freshState(key: string): ConversationState {
+	return {
+		key,
+		sessionId: `omp-${key}`,
+		turn: 0,
+		currentSlug: null,
+		currentTier: null,
+		stickyUntilTurn: 0,
+		escalations: 0,
+		spentUsd: 0,
+		lastPromptTokens: 0,
+		cacheWarmSlug: null,
+		cacheWarmAtMs: 0,
+		contextVersion: null,
+		contextFetchedAtMs: 0,
+		compactionPlan: null,
+		compactionPlanTokens: 0,
+		upgradeDeferredTier: null,
+		updatedAtMs: 0,
+	};
+}
+
+/**
+ * A conversation store in a Map. `accrue` ADDS, mirroring the SQL the real one
+ * runs: a read-modify-write here would hide the bug that motivated it (a
+ * billed-but-uncommitted dispatch losing its spend).
+ */
+export function fakeConversations(): { store: ConversationStore; map: Map<string, ConversationState> } {
+	const map = new Map<string, ConversationState>();
+	return {
+		map,
+		store: {
+			get: async (key) => map.get(key) ?? null,
+			load: async (key) => {
+				const existing = map.get(key);
+				if (existing !== undefined) return existing;
+				const fresh = freshState(key);
+				map.set(key, fresh);
+				return fresh;
+			},
+			save: async (state) => {
+				map.set(state.key, state);
+			},
+			accrue: async (key, delta) => {
+				const row = map.get(key);
+				if (row === undefined) return;
+				row.spentUsd += delta.spentUsd ?? 0;
+				row.escalations += delta.escalations ?? 0;
+			},
+			prune: async () => 0,
+		},
+	};
+}