auto-model-router 0.31.0 → 0.32.0

package/test/cost.test.ts

@@ -23,12 +23,12 @@ const SONNET = model("anthropic/claude-sonnet-4.5"); // publishes cache prices +
 const ALL = FIXTURE.data.map(normalizeCatalogModel).filter((m): m is CatalogModel => m !== null);
 
 describe("priceAt", () => {
-	test("returns the base price below every override threshold", () => {
+	test("returns the base price below every override threshold", async () => {
 		expect(priceAt(SONNET, 1000).prompt).toBe(SONNET.price.prompt);
 		expect(priceAt(SONNET, 199_999).prompt).toBe(SONNET.price.prompt);
 	});
 
-	test("crosses into the long-context tier at the threshold", () => {
+	test("crosses into the long-context tier at the threshold", async () => {
 		const tier = SONNET.priceTiers[0];
 		expect(tier).toBeDefined();
 		if (tier === undefined) return;
@@ -36,7 +36,7 @@ describe("priceAt", () => {
 		expect(priceAt(SONNET, tier.minPromptTokens + 1).prompt).toBeGreaterThan(SONNET.price.prompt);
 	});
 
-	test("a long conversation is dearer per token than a short one", () => {
+	test("a long conversation is dearer per token than a short one", async () => {
 		// The whole reason override tiers are modelled: ignoring them
 		// underestimates long-session cost by roughly half.
 		const short = computeCost(SONNET, usage({ promptTokens: 50_000, completionTokens: 1000 }));
@@ -48,7 +48,7 @@ describe("priceAt", () => {
 });
 
 describe("computeCost", () => {
-	test("components sum to the reported total", () => {
+	test("components sum to the reported total", async () => {
 		const b = computeCost(
 			SONNET,
 			usage({ promptTokens: 10_000, cachedTokens: 6000, cacheWriteTokens: 1000, completionTokens: 500, reasoningTokens: 200, images: 2 }),
@@ -57,7 +57,7 @@ describe("computeCost", () => {
 		expect(sum).toBeCloseTo(b.total, 12);
 	});
 
-	test("prompt_tokens already includes cached tokens, so they are not billed twice", () => {
+	test("prompt_tokens already includes cached tokens, so they are not billed twice", async () => {
 		// 10k prompt of which 10k cached must cost far less than 10k fresh,
 		// and must not be billed as 20k.
 		const allFresh = computeCost(SONNET, usage({ promptTokens: 10_000 }));
@@ -70,7 +70,7 @@ describe("computeCost", () => {
 		expect(allCached.cacheRead).toBeCloseTo(10_000 * cacheRead, 12);
 	});
 
-	test("cache reads are cheaper than fresh prompt tokens wherever published", () => {
+	test("cache reads are cheaper than fresh prompt tokens wherever published", async () => {
 		let checked = 0;
 		for (const m of ALL) {
 			const read = m.price.cacheRead;
@@ -83,7 +83,7 @@ describe("computeCost", () => {
 		expect(checked).toBeGreaterThan(0);
 	});
 
-	test("reasoning tokens are a subset of completion tokens and never double-billed", () => {
+	test("reasoning tokens are a subset of completion tokens and never double-billed", async () => {
 		const withReasoning = computeCost(SONNET, usage({ completionTokens: 1000, reasoningTokens: 400 }));
 		const withoutReasoning = computeCost(SONNET, usage({ completionTokens: 1000 }));
 		// Sonnet publishes no separate reasoning rate, so 1000 completion tokens
@@ -94,14 +94,14 @@ describe("computeCost", () => {
 		expect(withReasoning.total).toBeLessThan(inflated.total);
 	});
 
-	test("zero usage costs nothing beyond any flat per-request fee", () => {
+	test("zero usage costs nothing beyond any flat per-request fee", async () => {
 		const b = computeCost(SONNET, EMPTY_USAGE);
 		expect(b.total).toBe(b.request);
 	});
 });
 
 describe("forecast", () => {
-	test("cold is never cheaper than expected, for every model in the catalog", () => {
+	test("cold is never cheaper than expected, for every model in the catalog", async () => {
 		// A budget guard checks the cold number, so this ordering is load-bearing:
 		// several models publish a cache-write rate BELOW their prompt rate, so
 		// the honest worst case is the max of "no cache" and "full cache write".
@@ -113,14 +113,14 @@ describe("forecast", () => {
 		}
 	});
 
-	test("a higher assumed cache hit rate lowers the expected cost", () => {
+	test("a higher assumed cache hit rate lowers the expected cost", async () => {
 		const cold = forecast(SONNET, { promptTokens: 50_000, completionTokens: 500, cacheHitRate: 0, images: 0 });
 		const warm = forecast(SONNET, { promptTokens: 50_000, completionTokens: 500, cacheHitRate: 0.9, images: 0 });
 		expect(warm.expectedUsd).toBeLessThan(cold.expectedUsd);
 		expect(warm.assumedCacheHitRate).toBeCloseTo(0.9, 12);
 	});
 
-	test("records the assumptions it was given", () => {
+	test("records the assumptions it was given", async () => {
 		const f = forecast(SONNET, { promptTokens: 1234, completionTokens: 567, cacheHitRate: 0.25, images: 3 });
 		expect(f.slug).toBe(SONNET.slug);
 		expect(f.assumedPromptTokens).toBe(1234);
@@ -128,7 +128,7 @@ describe("forecast", () => {
 		expect(f.expectedUsd).toBeGreaterThan(0);
 	});
 
-	test("a cheap model forecasts below an expensive one for identical work", () => {
+	test("a cheap model forecasts below an expensive one for identical work", async () => {
 		const cheap = model("openai/gpt-5-nano");
 		const dear = model("openai/gpt-5-pro");
 		const args = { promptTokens: 20_000, completionTokens: 1000, cacheHitRate: 0, images: 0 };

package/test/digest.test.ts

@@ -1,15 +1,20 @@
 import { describe, expect, test } from "bun:test";
+import type { AsyncLedger } from "../src/cost/types.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";
 
 import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
 import type { CatalogModel, CatalogSnapshot, CatalogSource } from "../src/catalog/types.ts";
 import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import type { RouterConfig } from "../src/config/types.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
 import type { LedgerEntry } from "../src/cost/types.ts";
 import { createDigester, digestApplies, digestMarker } from "../src/server/digest.ts";
 import type { UpstreamClient } from "../src/upstream/types.ts";
 import { createLogger } from "../src/util/log.ts";
-import { openDb } from "../src/util/sqlite.ts";
 import { digestToast, parsePolicy, shouldSend, textOf } from "../omp-extension/digest-logic.ts";
 
 /**
@@ -37,7 +42,7 @@ function cfgWith(over: Partial<RouterConfig["digest"]> = {}): RouterConfig {
 	return cfg;
 }
 
-function seedSession(ledger: ReturnType<typeof createLedger>, tier: string): void {
+async function seedSession(ledger: AsyncLedger, tier: string): Promise<void> {
 	const e: LedgerEntry = {
 		id: crypto.randomUUID(),
 		createdAtMs: Date.now(),
@@ -72,7 +77,7 @@ function seedSession(ledger: ReturnType<typeof createLedger>, tier: string): voi
 		error: null,
 		promptTokensSaved: 0,
 	};
-	ledger.record(e);
+	await ledger.record(e);
 }
 
 function fakeUpstream(reply: (body: Record<string, unknown>) => string, costUsd: number | null = 0.0004): { upstream: UpstreamClient; calls: Record<string, unknown>[] } {
@@ -95,7 +100,7 @@ const BIG = Array.from({ length: 400 }, (_, i) => `${i + 1}: export const value$
 
 describe("digestApplies", () => {
 	const d = { ...DEFAULT_CONFIG.digest, enabled: true, minBytes: 100, maxBytes: 1000 };
-	test("gates on switch, error, tool, size and session tier", () => {
+	test("gates on switch, error, tool, size and session tier", async () => {
 		expect(digestApplies({ ...d, enabled: false }, "read", 500, false, "hard").ok).toBe(false);
 		expect(digestApplies(d, "read", 500, true, "hard").ok).toBe(false);
 		expect(digestApplies(d, "edit", 500, false, "hard").ok).toBe(false);
@@ -111,9 +116,10 @@ describe("digestApplies", () => {
 describe("createDigester", () => {
 	test("condenses a large read for a hard-tier session on a cheap model and records a ledger row", async () => {
 		const cfg = cfgWith();
-		const db = openDb(":memory:");
-		const ledger = createLedger(db, cfg);
-		seedSession(ledger, "hard");
+		const db = openSqlDb(join(tmpdir(), `t-digest.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
+		const ledger = createSqlLedger(db, cfg, { findModel: () => null });
+		await seedSession(ledger, "hard");
 		const { upstream, calls } = fakeUpstream(() => "Omitted 380 trivial constants.\n1: export const value0 = 0;\n...");
 		const d = createDigester({ cfg, catalog, ledger, upstream, log });
 		const r = await d.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: { path: "src/values.ts" }, content: BIG, query: "find value0" });
@@ -129,44 +135,47 @@ describe("createDigester", () => {
 		expect(catalog.find(call.model as string)?.price.prompt).toBeLessThanOrEqual(cfg.tiers.simple.maxInputPerMtok! / 1e6);
 		expect(JSON.stringify(call.messages)).toContain("Task: find value0");
 		// A ledger row under requestedModel "digest" with the served model and its cost.
-		const rows = ledger.recentEntries(10).filter((e) => e.requestedModel === "digest");
+		const rows = (await ledger.recentEntries(10)).filter((e) => e.requestedModel === "digest");
 		expect(rows).toHaveLength(1);
 		expect(rows[0]!.slug).toBe(call.model as string);
 		expect(rows[0]!.reportedUsd).toBeCloseTo(0.0004, 6);
 		expect(rows[0]!.ompSessionId).toBe("omp-1");
-		db.close();
+		await db.close();
 	});
 
 	test("declines below the session tier, over the cost guard, when the model fails, or when nothing shrinks", async () => {
-		const db = openDb(":memory:");
+		const db = openSqlDb(join(tmpdir(), `t-digest.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
 		const cfg = cfgWith();
-		const ledger = createLedger(db, cfg);
-		seedSession(ledger, "simple");
+		const ledger = createSqlLedger(db, cfg, { findModel: () => null });
+		await seedSession(ledger, "simple");
 		const cheap = createDigester({ cfg, catalog, ledger, upstream: fakeUpstream(() => "short").upstream, log });
 		expect(await cheap.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: expect.stringContaining("below digest.fromTier") });
 
-		const db2 = openDb(":memory:");
+		const db2 = openSqlDb(join(tmpdir(), `t-digest.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db2);
 		const strict = cfgWith({ maxCostUsd: 0 });
-		const ledger2 = createLedger(db2, strict);
-		seedSession(ledger2, "hard");
+		const ledger2 = createSqlLedger(db2, strict, { findModel: () => null });
+		await seedSession(ledger2, "hard");
 		expect(await createDigester({ cfg: strict, catalog, ledger: ledger2, upstream: fakeUpstream(() => "x").upstream, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: expect.stringContaining("exceeds digest.maxCostUsd") });
 
 		const failing: UpstreamClient = { ...fakeUpstream(() => "x").upstream, complete: () => Promise.reject(new Error("boom")) };
 		expect(await createDigester({ cfg, catalog, ledger: ledger2, upstream: failing, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: "digest model failed: boom" });
 		// The failed attempt is still a ledger row, with the error.
-		expect(ledger2.recentEntries(5).find((e) => e.requestedModel === "digest")?.error).toBe("boom");
+		expect((await ledger2.recentEntries(5)).find((e) => e.requestedModel === "digest")?.error).toBe("boom");
 
 		const same = createDigester({ cfg, catalog, ledger: ledger2, upstream: fakeUpstream(() => BIG).upstream, log });
 		expect(await same.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: "digest did not shrink the output" });
-		db.close();
+		await db.close();
 		db2.close();
 	});
 
 	test("a compaction-sourced digest is gated on compaction.digestToolResults and judges the given tier", async () => {
 		const cfg = cfgWith({ enabled: false });
 		cfg.compaction.digestToolResults = true;
-		const db = openDb(":memory:");
-		const ledger = createLedger(db, cfg);
+		const db = openSqlDb(join(tmpdir(), `t-digest.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
+		const ledger = createSqlLedger(db, cfg, { findModel: () => null });
 		// No session rows at all: the tier comes from the request.
 		const { upstream, calls } = fakeUpstream(() => "Condensed.");
 		const d = createDigester({ cfg, catalog, ledger, upstream, log });
@@ -178,63 +187,65 @@ describe("createDigester", () => {
 		const r = await d.digest({ ...base, tier: "hard", source: "compaction" });
 		expect(r.digested).toBe(true);
 		expect(calls).toHaveLength(1);
-		expect(ledger.recentEntries(5).find((e) => e.requestedModel === "digest")?.reasons[0]).toContain("digest (compaction)");
+		expect((await ledger.recentEntries(5)).find((e) => e.requestedModel === "digest")?.reasons[0]).toContain("digest (compaction)");
 		cfg.compaction.digestToolResults = false;
 		expect(await d.digest({ ...base, tier: "hard", source: "compaction" })).toMatchObject({ digested: false });
-		db.close();
+		await db.close();
 	});
 
 	test("a later call of the same tool with the same primary argument marks the digest wasted", async () => {
 		const cfg = cfgWith();
-		const db = openDb(":memory:");
-		const ledger = createLedger(db, cfg);
-		seedSession(ledger, "hard");
+		const db = openSqlDb(join(tmpdir(), `t-digest.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
+		const ledger = createSqlLedger(db, cfg, { findModel: () => null });
+		await seedSession(ledger, "hard");
 		const dg = createDigester({ cfg, catalog, ledger, upstream: fakeUpstream(() => "Condensed.").upstream, log });
 		const r = await dg.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: { path: "src/a.ts", offset: 1 }, content: BIG, query: "" });
 		expect(r.digested).toBe(true);
-		const row = () => ledger.recentEntries(10).find((e) => e.requestedModel === "digest")!;
-		expect(row().wasted).toBe(false);
+		const row = async (): Promise<LedgerEntry> => (await ledger.recentEntries(10)).find((e) => e.requestedModel === "digest")!;
+		expect((await row()).wasted).toBe(false);
 		// A different file, a different tool, another session: no match.
-		expect(dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/b.ts"}' }, { name: "grep", argsJson: '{"pattern":"src/a.ts"}' }])).toBe(0);
-		expect(dg.noteToolCalls("omp-2", [{ name: "read", argsJson: '{"path":"src/a.ts"}' }])).toBe(0);
-		expect(row().wasted).toBe(false);
+		expect(await dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/b.ts"}' }, { name: "grep", argsJson: '{"pattern":"src/a.ts"}' }])).toBe(0);
+		expect(await dg.noteToolCalls("omp-2", [{ name: "read", argsJson: '{"path":"src/a.ts"}' }])).toBe(0);
+		expect((await row()).wasted).toBe(false);
 		// The next request carries the call that PRODUCED the digest in its last assistant message: not a re-run.
-		expect(dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/a.ts","offset":1}' }])).toBe(0);
-		expect(row().wasted).toBe(false);
+		expect(await dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/a.ts","offset":1}' }])).toBe(0);
+		expect((await row()).wasted).toBe(false);
 		// The same read again (case-insensitive tool name, any other args): the agent wanted the full output.
-		expect(dg.noteToolCalls("omp-1", [{ name: "Read", argsJson: '{"path":"src/a.ts","limit":50}' }])).toBe(1);
-		expect(row().wasted).toBe(true);
+		expect(await dg.noteToolCalls("omp-1", [{ name: "Read", argsJson: '{"path":"src/a.ts","limit":50}' }])).toBe(1);
+		expect((await row()).wasted).toBe(true);
 		// Marked once; a third read does not count again.
-		expect(dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/a.ts"}' }])).toBe(0);
-		db.close();
+		expect(await dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/a.ts"}' }])).toBe(0);
+		await db.close();
 	});
 
 	test("a pinned digest model is used as-is", async () => {
 		const pinned = MODELS.find((m) => m.price.prompt > 0)!.slug;
 		const cfg = cfgWith({ model: pinned });
-		const db = openDb(":memory:");
-		const ledger = createLedger(db, cfg);
-		seedSession(ledger, "hard");
+		const db = openSqlDb(join(tmpdir(), `t-digest.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
+		const ledger = createSqlLedger(db, cfg, { findModel: () => null });
+		await seedSession(ledger, "hard");
 		const { upstream, calls } = fakeUpstream(() => "digest");
 		await createDigester({ cfg, catalog, ledger, upstream, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "grep", input: { pattern: "x" }, content: BIG, query: "" });
 		expect(calls[0]?.model as string).toBe(pinned);
-		db.close();
+		await db.close();
 	});
 });
 
 describe("digest marker and extension logic", () => {
-	test("the marker names the tool, sizes, model and how to get the full output", () => {
+	test("the marker names the tool, sizes, model and how to get the full output", async () => {
 		expect(digestMarker("grep", { pattern: "retry" }, "z-ai/glm-5.3-flash", 48_000, 3_000)).toBe(
 			'[digest: grep output 48,000 bytes → 3,000 chars by z-ai/glm-5.3-flash. Full output: re-run grep {"pattern":"retry"}]',
 		);
 	});
 
-	test("textOf joins text parts and flags images", () => {
+	test("textOf joins text parts and flags images", async () => {
 		expect(textOf([{ type: "text", text: "a" }, { type: "text", text: "b" }])).toEqual({ text: "a\nb", hasImage: false });
 		expect(textOf([{ type: "image" }, { type: "text", text: "a" }])).toEqual({ text: "a", hasImage: true });
 	});
 
-	test("shouldSend applies the client-side gate; parsePolicy is defensive", () => {
+	test("shouldSend applies the client-side gate; parsePolicy is defensive", async () => {
 		const p = parsePolicy({ enabled: true, minBytes: 10, maxBytes: 100, tools: ["Read", "grep"], fromTier: "hard" });
 		expect(p.tools).toEqual(["read", "grep"]);
 		expect(shouldSend(p, "read", false, "x".repeat(50), false)).toBe(true);
@@ -248,7 +259,7 @@ describe("digest marker and extension logic", () => {
 		expect(parsePolicy({ enabled: true }).minBytes).toBe(12_000);
 	});
 
-	test("digestToast is one readable line", () => {
+	test("digestToast is one readable line", async () => {
 		expect(digestToast("read", 48 * 1024, 3 * 1024, "ollama/glm-5.3-flash", 0.00042)).toBe("digested read 48KB → 3KB via glm-5.3-flash ($0.0004)");
 	});
 });

package/test/embed-lifecycle.test.ts

@@ -124,7 +124,7 @@ afterAll(async () => {
 });
 
 describe("embedded router: port selection", () => {
-	test("adopts the port models.yml advertises, so omp's pre-resolved handle is valid", () => {
+	test("adopts the port models.yml advertises, so omp's pre-resolved handle is valid", async () => {
 		expect(portOfLatestRegistration()).toBe(advertised);
 	});
 
@@ -132,13 +132,13 @@ describe("embedded router: port selection", () => {
 		expect(await alive(advertised)).toBe(true);
 	});
 
-	test("does NOT write its port into models.yml", () => {
+	test("does NOT write its port into models.yml", async () => {
 		// Persisting an ephemeral port makes it authoritative for the NEXT
 		// session's startup resolution, which is where the dead handle came from.
 		expect(readFileSync(modelsYmlPath, "utf8")).toBe(modelsYmlBefore);
 	});
 
-	test("publishes the port for subagents and the toast", () => {
+	test("publishes the port for subagents and the toast", async () => {
 		const portFile = join(home, "embed.port");
 		expect(existsSync(portFile)).toBe(true);
 		expect(readFileSync(portFile, "utf8").trim()).toBe(String(advertised));
@@ -146,7 +146,7 @@ describe("embedded router: port selection", () => {
 });
 
 describe("embedded router: lifetime", () => {
-	test("registers NO session_shutdown teardown", () => {
+	test("registers NO session_shutdown teardown", async () => {
 		// omp fires that from a throwaway host during provider refresh, so a
 		// teardown there kills a router the live session is still using.
 		expect(handlers.get("session_shutdown") ?? []).toHaveLength(0);
@@ -165,7 +165,7 @@ describe("embedded router: lifetime", () => {
 		expect(await alive(advertised)).toBe(true);
 	});
 
-	test("each session still gets its own registration, so per-session tagging survives reuse", () => {
+	test("each session still gets its own registration, so per-session tagging survives reuse", async () => {
 		expect(registrations.length).toBeGreaterThanOrEqual(2);
 	});
 });

package/test/embed-logic.test.ts

@@ -18,17 +18,17 @@ import {
 } from "../omp-extension/embed-logic.ts";
 
 describe("resolveEmbedPort", () => {
-	test("returns 0 (let the OS assign a free port) when nothing is configured", () => {
+	test("returns 0 (let the OS assign a free port) when nothing is configured", async () => {
 		expect(resolveEmbedPort(undefined)).toBe(0);
 		expect(resolveEmbedPort("")).toBe(0);
 	});
 
-	test("uses an explicit valid env port verbatim", () => {
+	test("uses an explicit valid env port verbatim", async () => {
 		expect(resolveEmbedPort("8812")).toBe(8812);
 		expect(resolveEmbedPort("0")).toBe(0);
 	});
 
-	test("falls back to 0 on junk or out-of-range values", () => {
+	test("falls back to 0 on junk or out-of-range values", async () => {
 		expect(resolveEmbedPort("notaport")).toBe(0);
 		expect(resolveEmbedPort("-1")).toBe(0);
 		expect(resolveEmbedPort("70000")).toBe(0);
@@ -37,20 +37,20 @@ describe("resolveEmbedPort", () => {
 	// A stable port is what keeps omp's PRE-extension model resolution correct:
 	// it reads models.yml before this extension can bind and rewrite it, so an
 	// ephemeral port leaves that block naming the previous session's dead port.
-	test("uses the configured server.port when no env override is set", () => {
+	test("uses the configured server.port when no env override is set", async () => {
 		expect(resolveEmbedPort(undefined, 8788)).toBe(8788);
 		expect(resolveEmbedPort("", 8788)).toBe(8788);
 	});
 
-	test("the env var wins over the configured port", () => {
+	test("the env var wins over the configured port", async () => {
 		expect(resolveEmbedPort("8812", 8788)).toBe(8812);
 	});
 
-	test("an explicit env 0 wins, so an ephemeral port stays requestable", () => {
+	test("an explicit env 0 wins, so an ephemeral port stays requestable", async () => {
 		expect(resolveEmbedPort("0", 8788)).toBe(0);
 	});
 
-	test("ignores a nonsense configured port rather than binding it", () => {
+	test("ignores a nonsense configured port rather than binding it", async () => {
 		expect(resolveEmbedPort(undefined, 0)).toBe(0);
 		expect(resolveEmbedPort(undefined, -5)).toBe(0);
 		expect(resolveEmbedPort(undefined, 70_000)).toBe(0);
@@ -73,16 +73,16 @@ describe("modelsYmlPort", () => {
           name: Auto (auto-model-router)
 `;
 
-	test("reads the advertised port out of a real block", () => {
+	test("reads the advertised port out of a real block", async () => {
 		expect(modelsYmlPort(REAL)).toBe(58724);
 	});
 
-	test("returns null when our provider block is absent", () => {
+	test("returns null when our provider block is absent", async () => {
 		expect(modelsYmlPort("providers:\n    openrouter:\n      baseUrl: https://openrouter.ai/api/v1\n")).toBeNull();
 		expect(modelsYmlPort("")).toBeNull();
 	});
 
-	test("is not fooled by another provider's baseUrl appearing first", () => {
+	test("is not fooled by another provider's baseUrl appearing first", async () => {
 		const mixed = `providers:
     llama.cpp:
       baseUrl: http://127.0.0.1:8080/v1
@@ -92,7 +92,7 @@ describe("modelsYmlPort", () => {
 		expect(modelsYmlPort(mixed)).toBe(8788);
 	});
 
-	test("returns null when the block carries no parseable url", () => {
+	test("returns null when the block carries no parseable url", async () => {
 		expect(modelsYmlPort("providers:\n    auto-model-router:\n      api: openai-completions\n")).toBeNull();
 	});
 });
@@ -107,14 +107,14 @@ describe("embed port file", () => {
 		if (dir) rmSync(dir, { recursive: true, force: true });
 	});
 
-	test("round-trips the bound port", () => {
+	test("round-trips the bound port", async () => {
 		const p = embedPortPath(dir);
 		expect(p).toBe(join(dir, EMBED_PORT_FILE));
 		writeEmbedPort(p, 45678);
 		expect(readEmbedPort(p)).toBe(45678);
 	});
 
-	test("returns null for a missing or malformed file", () => {
+	test("returns null for a missing or malformed file", async () => {
 		expect(readEmbedPort(embedPortPath(join(dir, "absent")))).toBeNull();
 		writeEmbedPort(embedPortPath(dir), -5);
 		expect(readEmbedPort(embedPortPath(dir))).toBeNull();
@@ -135,7 +135,7 @@ describe("buildProviderConfig", () => {
 		ledger: { fallbackBlend: { inputPerMtok: 0.2, outputPerMtok: 0.8 } },
 	};
 
-	test("builds a provider config against the actual bound port", () => {
+	test("builds a provider config against the actual bound port", async () => {
 		const c: EmbedConfig = buildProviderConfig(45678, base);
 		expect(c.baseUrl).toBe("http://127.0.0.1:45678/v1");
 		expect(c.port).toBe(45678);
@@ -145,41 +145,41 @@ describe("buildProviderConfig", () => {
 		expect(c.models[0]).toMatchObject({ id: "auto", contextWindow: 400_000, maxTokens: 32_000 });
 	});
 
-	test("converts cost to USD-per-million-token and applies cache multipliers", () => {
+	test("converts cost to USD-per-million-token and applies cache multipliers", async () => {
 		const c: EmbedConfig = buildProviderConfig(45678, base);
 		// input 0.2, output 0.8, cacheRead = 0.2*0.1 = 0.02, cacheWrite = 0.2*1.25 = 0.25
 		expect(c.models[0]!.cost).toEqual({ input: 0.2, output: 0.8, cacheRead: 0.02, cacheWrite: 0.25 });
 	});
 
-	test("normalizes a wildcard listen host to loopback", () => {
+	test("normalizes a wildcard listen host to loopback", async () => {
 		const c: EmbedConfig = buildProviderConfig(45678, { ...base, server: { host: "0.0.0.0" } });
 		expect(c.baseUrl).toBe("http://127.0.0.1:45678/v1");
 	});
 
-	test("carries the harness id through when configured", () => {
+	test("carries the harness id through when configured", async () => {
 		const c: EmbedConfig = buildProviderConfig(45678, { ...base, server: { host: "127.0.0.1", harnessId: "prod-a" } });
 		expect(c.harnessId).toBe("prod-a");
 	});
 });
 
 describe("embed constants", () => {
-	test("provider id and dummy key stay stable", () => {
+	test("provider id and dummy key stay stable", async () => {
 		expect(EMBED_PROVIDER_ID).toBe("auto-model-router");
 	});
-	test("port file name is stable", () => {
+	test("port file name is stable", async () => {
 		expect(EMBED_PORT_FILE).toBe("embed.port");
 	});
 });
 
 describe("agentdox scope", () => {
-	test("derives a slug from the workspace basename", () => {
+	test("derives a slug from the workspace basename", async () => {
 		expect(deriveAgentdoxScope("E:/projects/Ashlands/Ashlands")).toBe("ashlands");
 		expect(deriveAgentdoxScope("/home/drew/omp-router")).toBe("omp-router");
 		expect(deriveAgentdoxScope("E:\\projects\\My Game\\")).toBe("my-game");
 		expect(deriveAgentdoxScope("")).toBe("");
 	});
 
-	test("the workspace derivation wins over the scope-agnostic defaultScope", () => {
+	test("the workspace derivation wins over the scope-agnostic defaultScope", async () => {
 		// Regression: one router install serves every project on the machine, so a
 		// global `defaultScope` overriding the derivation made an ashlands session
 		// ship `X-Agentdox-Scope: omp-router` — wrong context injected, turns
@@ -198,7 +198,7 @@ describe("agentdox scope", () => {
 		expect(fallback.agentdoxScope).toBe("pinned");
 	});
 
-	test("no scope header when the bridge is off", () => {
+	test("no scope header when the bridge is off", async () => {
 		const cfg = {
 			server: { host: "127.0.0.1" },
 			profiles: [],
@@ -219,7 +219,7 @@ describe("workspace origin", () => {
 		rmSync(root, { recursive: true, force: true });
 	});
 
-	test("a plain repository: the remote from .git/config, also from a subdirectory", () => {
+	test("a plain repository: the remote from .git/config, also from a subdirectory", async () => {
 		const repo = join(root, "repo");
 		mkdirSync(join(repo, ".git"), { recursive: true });
 		writeFileSync(join(repo, ".git", "config"), CONFIG);
@@ -230,7 +230,7 @@ describe("workspace origin", () => {
 		expect(deriveAgentdoxScope(repo)).toBe("repo");
 	});
 
-	test("a worktree: .git is a file naming the git dir, whose shared config is one hop further", () => {
+	test("a worktree: .git is a file naming the git dir, whose shared config is one hop further", async () => {
 		// The main checkout holds the config; the worktree's own dir only points at it.
 		const main = join(root, "main");
 		mkdirSync(join(main, ".git", "worktrees", "wt"), { recursive: true });
@@ -249,7 +249,7 @@ describe("workspace origin", () => {
 		expect(deriveWorkspaceOrigin(join(sub, "lib"))).toBe("github.com/org/lib");
 	});
 
-	test("no remote, a local remote, no repository, or nothing at all: no fingerprint, never a throw", () => {
+	test("no remote, a local remote, no repository, or nothing at all: no fingerprint, never a throw", async () => {
 		const bare = join(root, "bare");
 		mkdirSync(join(bare, ".git"), { recursive: true });
 		writeFileSync(join(bare, ".git", "config"), "[core]\n\tbare = false\n");
@@ -278,7 +278,7 @@ describe("workspace origin", () => {
 		expect(deriveWorkspaceOrigin("/x/repo", () => '[remote "upstream"]\n\turl = https://github.com/other/thing.git\n')).toBe("");
 	});
 
-	test("buildProviderConfig carries the origin beside the scope, only where the scope goes", () => {
+	test("buildProviderConfig carries the origin beside the scope, only where the scope goes", async () => {
 		const base = {
 			server: { host: "127.0.0.1" },
 			profiles: [],