auto-model-router 0.31.0 → 0.32.0

package/test/cache-control.test.ts

@@ -43,19 +43,19 @@ function loop(turns: number): NormRequest {
 }
 
 describe("planCacheBreakpoints", () => {
-	test("marks the tail so the next turn can read this turn's whole prompt", () => {
+	test("marks the tail so the next turn can read this turn's whole prompt", async () => {
 		const req = loop(12);
 		const picks = planCacheBreakpoints(req, MODEL, cfg());
 		expect(picks).toContain(req.messages.length - 1);
 	});
 
-	test("marks the system prefix", () => {
+	test("marks the system prefix", async () => {
 		const req = loop(12);
 		const picks = planCacheBreakpoints(req, MODEL, cfg());
 		expect(picks).toContain(0);
 	});
 
-	test("mid-history boundaries are stable as the conversation grows", () => {
+	test("mid-history boundaries are stable as the conversation grows", async () => {
 		// Uncapped so the comparison is about placement, not slot eviction.
 		const uncapped = cfg({ maxBreakpoints: 64, milestoneTokens: 4_000 });
 		const mid = (turns: number): number[] => {
@@ -72,7 +72,7 @@ describe("planCacheBreakpoints", () => {
 		}
 	});
 
-	test("boundaries are spaced by the milestone size, not by message position", () => {
+	test("boundaries are spaced by the milestone size, not by message position", async () => {
 		const req = loop(30);
 		const tail = req.messages.length - 1;
 		const coarse = planCacheBreakpoints(req, MODEL, cfg({ maxBreakpoints: 64, milestoneTokens: 20_000 })).filter(
@@ -84,13 +84,13 @@ describe("planCacheBreakpoints", () => {
 		expect(fine.length).toBeGreaterThan(coarse.length);
 	});
 
-	test("keeps the system prefix and the tail when slots are scarce", () => {
+	test("keeps the system prefix and the tail when slots are scarce", async () => {
 		const req = loop(30);
 		const picks = planCacheBreakpoints(req, MODEL, cfg({ maxBreakpoints: 2, milestoneTokens: 4_000 }));
 		expect(picks).toEqual([0, req.messages.length - 1]);
 	});
 
-	test("milestones follow post-compaction sizes", () => {
+	test("milestones follow post-compaction sizes", async () => {
 		const req = loop(30);
 		const tail = req.messages.length - 1;
 		const plan = planCompaction(req.messages, { ...BASE.compaction, enabled: true }, req.promptBytes * 0.3, req.promptBytes);
@@ -103,7 +103,7 @@ describe("planCacheBreakpoints", () => {
 		expect(Math.min(...compacted)).toBeGreaterThan(Math.min(...raw));
 	});
 
-	test("injects nothing below the minimum prompt size, or when disabled", () => {
+	test("injects nothing below the minimum prompt size, or when disabled", async () => {
 		const small = parseChatRequest({ model: "auto", messages: [{ role: "user", content: "hi" }] }, new Headers());
 		expect(planCacheBreakpoints(small, MODEL, cfg())).toEqual([]);
 		expect(planCacheBreakpoints(loop(12), MODEL, cfg({ injectBreakpoints: false }))).toEqual([]);

package/test/cache-estimate.test.ts

@@ -15,18 +15,18 @@ const base = (over: Partial<UsageCounts> = {}): UsageCounts => ({ ...EMPTY_USAGE
 const ctx = { previousSlug: "ollama/glm", previousPromptTokens: 100_000, previousAtMs: 1_000_000, servedSlug: "ollama/glm", nowMs: 1_060_000, cacheWarmTtlMs: 300_000 };
 
 describe("estimateUnreportedCache", () => {
-	test("same model within the TTL: the previous prompt is the cached prefix, flagged as estimated", () => {
+	test("same model within the TTL: the previous prompt is the cached prefix, flagged as estimated", async () => {
 		const out = estimateUnreportedCache(base(), ctx);
 		expect(out.cachedTokens).toBe(100_000);
 		expect(out.cachedEstimated).toBe(true);
 		expect(out.promptTokens).toBe(120_000);
 	});
 
-	test("a shorter prompt than the previous one caps the cached count at the prompt", () => {
+	test("a shorter prompt than the previous one caps the cached count at the prompt", async () => {
 		expect(estimateUnreportedCache(base({ promptTokens: 40_000 }), ctx).cachedTokens).toBe(40_000);
 	});
 
-	test("first turn, model switch, or idle past the TTL count as cold", () => {
+	test("first turn, model switch, or idle past the TTL count as cold", async () => {
 		expect(estimateUnreportedCache(base(), { ...ctx, previousSlug: null }).cachedTokens).toBe(0);
 		expect(estimateUnreportedCache(base(), { ...ctx, previousSlug: "ollama/other" }).cachedTokens).toBe(0);
 		expect(estimateUnreportedCache(base(), { ...ctx, nowMs: ctx.previousAtMs + 300_001 }).cachedTokens).toBe(0);
@@ -34,14 +34,14 @@ describe("estimateUnreportedCache", () => {
 		expect(estimateUnreportedCache(base(), { ...ctx, cacheWarmTtlMs: 0 }).cachedTokens).toBe(0);
 	});
 
-	test("provider-reported cache counts are never overwritten", () => {
+	test("provider-reported cache counts are never overwritten", async () => {
 		const reported = base({ cachedTokens: 5_000 });
 		expect(estimateUnreportedCache(reported, ctx)).toBe(reported);
 		const written = base({ cacheWriteTokens: 5_000 });
 		expect(estimateUnreportedCache(written, ctx)).toBe(written);
 	});
 
-	test("no prompt tokens: nothing to estimate", () => {
+	test("no prompt tokens: nothing to estimate", async () => {
 		const empty = base({ promptTokens: 0 });
 		expect(estimateUnreportedCache(empty, ctx)).toBe(empty);
 	});

package/test/catalog-view.test.ts

@@ -63,7 +63,7 @@ const served = () => null;
 const bySlug = (view: CatalogView): Map<string, CatalogViewModel> => new Map(view.models.map((m) => [m.slug, m]));
 
 describe("catalogView", () => {
-	test("sorted by slug, prices per million, vendor per slug, and no verdict without a policy", () => {
+	test("sorted by slug, prices per million, vendor per slug, and no verdict without a policy", async () => {
 		const view = catalogView({ models: MODELS, fetchedAtMs: 123, unserved: served });
 		expect(view.fetchedAtMs).toBe(123);
 		expect(view.models.map((m) => m.slug)).toEqual([...MODELS.map((m) => m.slug)].sort());
@@ -91,7 +91,7 @@ describe("catalogView", () => {
 		expect(bySlug(view).get("azure-eu/gpt-4o-deploy")!.price).toEqual({ prompt: 2.5, completion: 10, cacheRead: 1.25 });
 	});
 
-	test("vendor: the namespace before the first slash; a named upstream's model id may carry its own", () => {
+	test("vendor: the namespace before the first slash; a named upstream's model id may carry its own", async () => {
 		expect(vendorOf({ slug: "anthropic/claude-sonnet-5", provider: "openrouter" })).toBe("anthropic");
 		expect(vendorOf({ slug: "ollama/glm-5.3-flash", provider: "ollama" })).toBe("ollama");
 		expect(vendorOf({ slug: "vllm/meta-llama/Llama-3", provider: "vllm" })).toBe("meta-llama");
@@ -101,7 +101,7 @@ describe("catalogView", () => {
 		expect(view.get("azure-eu/gpt-4o-deploy")!.vendor).toBe("azure-eu");
 	});
 
-	test("an empty policy still judges: the router's own filters and the upstream's state", () => {
+	test("an empty policy still judges: the router's own filters and the upstream's state", async () => {
 		const unserved = (p: string) => (p === "azure-eu" ? "upstream azure-eu is disabled" : null);
 		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters: DEFAULT_CONFIG.filters }, unserved }));
 		expect(view.get("openai/gpt-5")).toMatchObject({ admitted: true });
@@ -118,7 +118,7 @@ describe("catalogView", () => {
 		expect(open.get("tencent/translator")!.admitted).toBe(true);
 	});
 
-	test("allow list, deny glob and pin, in the order a turn applies them", () => {
+	test("allow list, deny glob and pin, in the order a turn applies them", async () => {
 		const filters = { ...DEFAULT_CONFIG.filters, allow: ["anthropic/*", "vllm/*"], deny: ["*haiku*"] };
 		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters }, unserved: served }));
 		expect(view.get("openai/gpt-5")).toMatchObject({ admitted: false, reason: "not in the allow list" });

package/test/catalog.test.ts

@@ -12,7 +12,7 @@ function rawFor(slug: string): unknown {
 }
 
 describe("normalizeCatalogModel", () => {
-	test("survives every record in the real catalog without throwing", () => {
+	test("survives every record in the real catalog without throwing", async () => {
 		let normalized = 0;
 		for (const raw of RAW) {
 			const model = normalizeCatalogModel(raw);
@@ -22,7 +22,7 @@ describe("normalizeCatalogModel", () => {
 		expect(normalized).toBeGreaterThan(RAW.length * 0.9);
 	});
 
-	test("every normalized model has strictly positive prompt and completion prices", () => {
+	test("every normalized model has strictly positive prompt and completion prices", async () => {
 		for (const raw of RAW) {
 			const model = normalizeCatalogModel(raw);
 			if (model === null) continue;
@@ -33,7 +33,7 @@ describe("normalizeCatalogModel", () => {
 		}
 	});
 
-	test("rejects the openrouter meta-routers, whose -1 pricing means unknown", () => {
+	test("rejects the openrouter meta-routers, whose -1 pricing means unknown", async () => {
 		// Routing to another router is both out of scope and uncostable: a -1
 		// price would otherwise be read as free and win every tier outright.
 		for (const slug of ["openrouter/auto", "openrouter/pareto-code", "openrouter/fusion"]) {
@@ -41,7 +41,7 @@ describe("normalizeCatalogModel", () => {
 		}
 	});
 
-	test("does not mistake unknown (-1) pricing for free pricing", () => {
+	test("does not mistake unknown (-1) pricing for free pricing", async () => {
 		const free = normalizeCatalogModel(rawFor("openai/gpt-oss-20b:free"));
 		expect(free).not.toBeNull();
 		expect(free?.isFree).toBe(true);
@@ -49,7 +49,7 @@ describe("normalizeCatalogModel", () => {
 		expect(normalizeCatalogModel(rawFor("openrouter/auto"))).toBeNull();
 	});
 
-	test("preserves published quality scores and never imputes missing ones", () => {
+	test("preserves published quality scores and never imputes missing ones", async () => {
 		const scoredInFixture = RAW.filter(
 			(m) =>
 				typeof m === "object" &&
@@ -74,7 +74,7 @@ describe("normalizeCatalogModel", () => {
 		expect(unscored).toBeGreaterThan(0);
 	});
 
-	test("reads long-context override tiers, sorted ascending", () => {
+	test("reads long-context override tiers, sorted ascending", async () => {
 		const sonnet = normalizeCatalogModel(rawFor("anthropic/claude-sonnet-4.5"));
 		expect(sonnet).not.toBeNull();
 		expect(sonnet?.priceTiers.length).toBeGreaterThan(0);
@@ -91,7 +91,7 @@ describe("normalizeCatalogModel", () => {
 		expect(first?.price.prompt).toBeGreaterThan(sonnet?.price.prompt ?? 0);
 	});
 
-	test("an override tier inherits components it does not restate", () => {
+	test("an override tier inherits components it does not restate", async () => {
 		for (const raw of RAW) {
 			const model = normalizeCatalogModel(raw);
 			if (model === null || model.priceTiers.length === 0) continue;
@@ -103,7 +103,7 @@ describe("normalizeCatalogModel", () => {
 		}
 	});
 
-	test("strips the floating-alias marker from the author segment", () => {
+	test("strips the floating-alias marker from the author segment", async () => {
 		const alias = normalizeCatalogModel(rawFor("~x-ai/grok-latest"));
 		expect(alias).not.toBeNull();
 		expect(alias?.author).toBe("x-ai");
@@ -111,7 +111,7 @@ describe("normalizeCatalogModel", () => {
 		expect(alias?.slug.startsWith("~")).toBe(true);
 	});
 
-	test("derives capability flags from supported_parameters", () => {
+	test("derives capability flags from supported_parameters", async () => {
 		const sonnet = normalizeCatalogModel(rawFor("anthropic/claude-sonnet-4.5"));
 		expect(sonnet?.supportsTools).toBe(true);
 		expect(sonnet?.supportsToolChoice).toBe(true);
@@ -122,7 +122,7 @@ describe("normalizeCatalogModel", () => {
 		expect(toolless?.supportsTools).toBe(false);
 	});
 
-	test("rejects records missing the fields routing depends on", () => {
+	test("rejects records missing the fields routing depends on", async () => {
 		expect(normalizeCatalogModel({})).toBeNull();
 		expect(normalizeCatalogModel(null)).toBeNull();
 		expect(normalizeCatalogModel({ id: "x/y" })).toBeNull();
@@ -220,7 +220,7 @@ describe("createCatalog key-scoped availability", () => {
 		const db = openDb(":memory:");
 		const catalog = createCatalog(cfg, upstream, db);
 
-		await expect(catalog.get()).rejects.toThrow("Unauthorized");
+		(await expect(catalog.get())).rejects.toThrow("Unauthorized");
 		db.close();
 	});
 

package/test/classify.test.ts

@@ -104,7 +104,7 @@ function scriptedUpstream(behaviour: () => Promise<CompletionResult>): UpstreamC
 
 const tierIdx = (t: Tier): number => TIER_ORDER.indexOf(t);
 describe("scoreHeuristic", () => {
-	test("a mechanical tool-result continuation scores cheaper than a fresh architecture question", () => {
+	test("a mechanical tool-result continuation scores cheaper than a fresh architecture question", async () => {
 		// The single most valuable signal in agent traffic: most turns are
 		// post-tool-result continuations, and they do not need a frontier model.
 		const continuation = scoreHeuristic(
@@ -135,7 +135,7 @@ describe("scoreHeuristic", () => {
 		expect(tierIdx(continuation.tier)).toBeLessThan(tierIdx(architecture.tier));
 	});
 
-	test("a failing tool result raises the tier above a clean one", () => {
+	test("a failing tool result raises the tier above a clean one", async () => {
 		const clean = scoreHeuristic(
 			featuresFor([
 				SYSTEM,
@@ -165,7 +165,7 @@ describe("scoreHeuristic", () => {
 		expect(failed.score).toBeGreaterThan(clean.score);
 	});
 
-	test("a requested high reasoning effort raises the score", () => {
+	test("a requested high reasoning effort raises the score", async () => {
 		const plain = scoreHeuristic(featuresFor([SYSTEM, { role: "user", content: "tidy this up" }]), BASE);
 		const thinking = scoreHeuristic(
 			extractFeatures(
@@ -180,7 +180,7 @@ describe("scoreHeuristic", () => {
 		expect(thinking.score).toBeGreaterThan(plain.score);
 	});
 
-	test("the reasoning weight is configurable, so a session-wide level can be discounted", () => {
+	test("the reasoning weight is configurable, so a session-wide level can be discounted", async () => {
 		// A harness that pins one reasoning level for a whole session turns this
 		// "signal" into a constant that lifts every turn's score. Measured live:
 		// the level never changed within 111 of 115 conversations, and 64 of 119
@@ -205,11 +205,11 @@ describe("scoreHeuristic", () => {
 		expect(discounted.reasons.some((r) => /requested reasoning/.test(r))).toBe(false);
 	});
 
-	test("ships with the historical weights, so enabling a discount is opt-in", () => {
+	test("ships with the historical weights, so enabling a discount is opt-in", async () => {
 		expect(DEFAULT_CONFIG.classifier.reasoningWeights).toEqual({ medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 });
 	});
 
-	test("always produces a bounded score, a real tier, and its reasoning", () => {
+	test("always produces a bounded score, a real tier, and its reasoning", async () => {
 		const c = scoreHeuristic(featuresFor([SYSTEM, { role: "user", content: "hello" }]), BASE);
 		expect(c.score).toBeGreaterThanOrEqual(0);
 		expect(c.score).toBeLessThanOrEqual(1);
@@ -220,12 +220,12 @@ describe("scoreHeuristic", () => {
 		expect(c.confidence).toBeLessThanOrEqual(1);
 	});
 
-	test("a shallow tool-result continuation stays trivial", () => {
+	test("a shallow tool-result continuation stays trivial", async () => {
 		const shallow = scoreHeuristic(contFeatures(2), BASE);
 		expect(shallow.tier).toBe("trivial");
 	});
 
-	test("a sustained autonomous loop climbs out of trivial", () => {
+	test("a sustained autonomous loop climbs out of trivial", async () => {
 		// The failure mode this fixes: a long coding loop pinned to the cheapest
 		// tier for dozens of turns because agentic complexity never accumulated.
 		const shallow = scoreHeuristic(contFeatures(2), BASE);
@@ -234,7 +234,7 @@ describe("scoreHeuristic", () => {
 		expect(deep.tier).not.toBe("trivial");
 	});
 
-	test("score increases monotonically with loop depth past the agentic threshold", () => {
+	test("score increases monotonically with loop depth past the agentic threshold", async () => {
 		const depths = [4, 6, 8, 10, 15, 20, 30];
 		let prev = -1;
 		for (const d of depths) {
@@ -244,7 +244,7 @@ describe("scoreHeuristic", () => {
 		}
 	});
 
-	test("pure loop depth never reaches hard on its own, however runaway", () => {
+	test("pure loop depth never reaches hard on its own, however runaway", async () => {
 		// A sustained-but-not-runaway loop tops out in moderate: the calibrated
 		// ramp ceiling for ordinary deep work.
 		const midRange = scoreHeuristic(contFeatures(30), BASE);
@@ -264,7 +264,7 @@ describe("scoreHeuristic", () => {
 		expect(scoreHeuristic(contFeatures(400), BASE).tier).toBe("moderate");
 	});
 
-	test("a circular tool call on a FRESH turn escalates to hard", () => {
+	test("a circular tool call on a FRESH turn escalates to hard", async () => {
 		// Off a continuation the stuck signal keeps full weight: the user is
 		// watching a live loop and a pricier model may actually break it.
 		const deepCircular = scoreHeuristic(
@@ -274,7 +274,7 @@ describe("scoreHeuristic", () => {
 		expect(deepCircular.tier).toBe("hard");
 	});
 
-	test("a circular tool call on a mechanical continuation is damped, not hard", () => {
+	test("a circular tool call on a mechanical continuation is damped, not hard", async () => {
 		// Measured: hard escalations on circular calls never shortened the loop
 		// (chain means identical, 5.74 turns, hard vs moderate). 22 of 27 such
 		// hard turns were mechanical continuations paying up to 6x for nothing.
@@ -285,7 +285,7 @@ describe("scoreHeuristic", () => {
 		expect(retry.score - plain.score).toBeCloseTo(BASE.classifier.mechanicalRetryFactor * 0.24, 5);
 	});
 
-	test("a failing tool result on a deep loop is at least simple", () => {
+	test("a failing tool result on a deep loop is at least simple", async () => {
 		// Was 'at least moderate' before the mechanical-retry damp: the flat
 		// +0.26 pushed deep mechanical retry loops into hard. A damped retry
 		// still clears trivial.
@@ -293,7 +293,7 @@ describe("scoreHeuristic", () => {
 		expect(tierIdx(deepAndFailing.tier)).toBeGreaterThanOrEqual(tierIdx("simple"));
 	});
 
-	test("a failed-tool retry on a mechanical continuation is damped, not hard", () => {
+	test("a failed-tool retry on a mechanical continuation is damped, not hard", async () => {
 		// A retry after a failed tool call is the most mechanical turn there is;
 		// the flat +0.26 let automated retry loops buy the hard tier ($7.02 of one
 		// measured day vs $0.19 for the same rows as moderate picks). The
@@ -313,14 +313,14 @@ describe("scoreHeuristic", () => {
 });
 
 describe("pickQualityAxis", () => {
-	test("tools imply the coding axis, plain chat the chat axis", () => {
+	test("tools imply the coding axis, plain chat the chat axis", async () => {
 		expect(pickQualityAxis(featuresFor([SYSTEM, { role: "user", content: "fix it" }]), BASE)).toBe(BASE.classifier.toolAxis);
 		expect(pickQualityAxis(featuresFor([SYSTEM, { role: "user", content: "hello" }], []), BASE)).toBe(
 			BASE.classifier.chatAxis,
 		);
 	});
 
-	test("a deep tool loop switches to the agentic axis", () => {
+	test("a deep tool loop switches to the agentic axis", async () => {
 		const deep = featuresFor([
 			SYSTEM,
 			{ role: "user", content: "go" },
@@ -395,12 +395,12 @@ describe("classify", () => {
 });
 
 describe("classifyTask", () => {
-	test("image input is a vision task", () => {
+	test("image input is a vision task", async () => {
 		const f = featuresFor([SYSTEM, { role: "user", content: [{ type: "image_url", image_url: { url: "data:image/png;base64,xxx" } }] }], []);
 		expect(classifyTask(f)).toBe("vision");
 	});
 
-	test("a stale image on a tool continuation is coding, not vision", () => {
+	test("a stale image on a tool continuation is coding, not vision", async () => {
 		const f = featuresFor(
 			[
 				SYSTEM,
@@ -421,7 +421,7 @@ describe("classifyTask", () => {
 		expect(classifyTask(f)).toBe("coding");
 	});
 
-	test("a freshly supplied image mid-loop is vision", () => {
+	test("a freshly supplied image mid-loop is vision", async () => {
 		const f = featuresFor(
 			[
 				SYSTEM,
@@ -442,26 +442,26 @@ describe("classifyTask", () => {
 		expect(classifyTask(f)).toBe("vision");
 	});
 
-	test("code blocks and diffs are coding tasks", () => {
+	test("code blocks and diffs are coding tasks", async () => {
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "```ts\nconst x = 1;\n```" }], []))).toBe("coding");
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "diff --git a/x b/x\n@@ -1 +1 @@\n-old\n+new" }], []))).toBe("coding");
 	});
 
-	test("tools offered is a coding task", () => {
+	test("tools offered is a coding task", async () => {
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "read the file" }], TOOLS))).toBe("coding");
 	});
 
-	test("bare chat with no tools or code is a chat task", () => {
+	test("bare chat with no tools or code is a chat task", async () => {
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "hello, how are you?" }], []))).toBe("chat");
 	});
 
-	test("design/architecture prose is a documentation task", () => {
+	test("design/architecture prose is a documentation task", async () => {
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "explain the architecture of the system" }], []))).toBe("documentation");
 	});
 });
 
 describe("classifier.readOnlyToolWeight", () => {
-	test("subtracts only when enabled and the tail is a read-only loop", () => {
+	test("subtracts only when enabled and the tail is a read-only loop", async () => {
 		const base = { ...featuresFor([{ role: "user", content: "look" }]), isToolResultContinuation: true, readOnlyToolTail: true };
 		const off = scoreHeuristic(base, DEFAULT_CONFIG);
 		const cfg = structuredClone(DEFAULT_CONFIG);

package/test/compaction.test.ts

@@ -34,12 +34,12 @@ const PAD: NormMessage[] = [asst("z1", "bash", '{"command":"ls"}'), toolMsg("z1"
 const big = (marker: string): string => `${marker}:${"x".repeat(200)}`;
 
 describe("planCompaction", () => {
-	test("is a no-op when disabled", () => {
+	test("is a no-op when disabled", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		expect(planCompaction(msgs, { ...CFG, enabled: false }, 0, 10_000).edits).toEqual([]);
 	});
 
-	test("truncates a large stale tool result, protecting recent turns", () => {
+	test("truncates a large stale tool result, protecting recent turns", async () => {
 		const msgs = [
 			user("go"),
 			asst("c1", "read", '{"path":"a.ts"}'),
@@ -54,7 +54,7 @@ describe("planCompaction", () => {
 		expect(edits[0]?.mode).toBe("truncate");
 	});
 
-	test("collapses byte-identical duplicate results, keeping the last", () => {
+	test("collapses byte-identical duplicate results, keeping the last", async () => {
 		const msgs = [
 			user("go"),
 			asst("c1", "read", '{"path":"a.ts"}'),
@@ -69,7 +69,7 @@ describe("planCompaction", () => {
 		expect(edits[0]?.mode).toBe("stub");
 	});
 
-	test("elides a read superseded by a newer call to the same resource", () => {
+	test("elides a read superseded by a newer call to the same resource", async () => {
 		const msgs = [
 			user("go"),
 			asst("c1", "read", '{"path":"a.ts"}'),
@@ -83,7 +83,7 @@ describe("planCompaction", () => {
 		expect(edits[0]?.mode).toBe("stub");
 	});
 
-	test("different resources are not superseded", () => {
+	test("different resources are not superseded", async () => {
 		const msgs = [
 			user("go"),
 			asst("c1", "read", '{"path":"a.ts"}'),
@@ -95,7 +95,7 @@ describe("planCompaction", () => {
 		expect(planCompaction(msgs, CFG, 10_000, 10_000).edits).toEqual([]);
 	});
 
-	test("is deterministic and idempotent on stable input", () => {
+	test("is deterministic and idempotent on stable input", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("OLD")), ...PAD];
 		const a = planCompaction(msgs, CFG, 1, 10_000);
 		const b = planCompaction(msgs, CFG, 1, 10_000);
@@ -106,7 +106,7 @@ describe("planCompaction", () => {
 	// bytes for the rest of the conversation, and every later edit lands AFTER
 	// it. Anything else rewrites already-cached history and forces a full
 	// re-read of the prefix on the next turn.
-	test("the edit set only ever extends forward as the conversation grows", () => {
+	test("the edit set only ever extends forward as the conversation grows", async () => {
 		// Sizes GROW with age-descending order (newest results are the biggest), so
 		// a size-ordered planner selects newest-first and its later additions move
 		// BACKWARD into already-cached history. Equal-sized results would make
@@ -154,7 +154,7 @@ describe("renderUpstreamBody applies compaction", () => {
 		stripAssistantReasoning: false,
 	};
 
-	test("truncates content in place with a recoverable breadcrumb, preserving pairing", () => {
+	test("truncates content in place with a recoverable breadcrumb, preserving pairing", async () => {
 		const raw = [
 			{ role: "user", content: "go" },
 			{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: "{}" } }] },
@@ -173,7 +173,7 @@ describe("renderUpstreamBody applies compaction", () => {
 		expect(content as string).toEndWith("TAIL");
 	});
 
-	test("stub replaces the whole content with a breadcrumb", () => {
+	test("stub replaces the whole content with a breadcrumb", async () => {
 		const raw = [
 			{ role: "user", content: "go" },
 			{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: "{}" } }] },
@@ -191,20 +191,20 @@ describe("plan byte-stability across turns", () => {
 	// invalidates everything after it. So an edit, once dispatched, must be
 	// re-emitted identically on every later turn — which means the planner has
 	// to be told what it already did rather than re-deriving it.
-	test("edits carry their original byte length for persistence", () => {
+	test("edits carry their original byte length for persistence", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
 		expect(edits).toHaveLength(1);
 		expect(edits[0]?.bytes).toBe(Buffer.byteLength(big("A")));
 	});
 
-	test("validatePlan keeps edits whose target is byte-identical and role-correct", () => {
+	test("validatePlan keeps edits whose target is byte-identical and role-correct", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
 		expect(validatePlan(edits, msgs)).toEqual(edits);
 	});
 
-	test("validatePlan drops edits when history changed under them", () => {
+	test("validatePlan drops edits when history changed under them", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
 		// Client re-wrote history: the tool result is a different length now.
@@ -212,14 +212,14 @@ describe("plan byte-stability across turns", () => {
 		expect(validatePlan(edits, rewritten)).toEqual([]);
 	});
 
-	test("validatePlan drops edits that fall off the message array", () => {
+	test("validatePlan drops edits that fall off the message array", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
 		// Conversation compacted away client-side: index 2 no longer exists.
 		expect(validatePlan(edits, [user("go"), ...PAD.slice(1)])).toEqual([]);
 	});
 
-	test("a carried plan produces identical edits to a fresh plan over the same bytes", () => {
+	test("a carried plan produces identical edits to a fresh plan over the same bytes", async () => {
 		// Determinism contract: re-planning over unchanged bytes re-derives the
 		// persisted plan, so the merge in select.ts is a no-op, not a rewrite.
 		const msgs = [
@@ -235,7 +235,7 @@ describe("plan byte-stability across turns", () => {
 		expect(again.edits).toEqual(first.edits);
 	});
 
-	test("a carried edit is re-emitted verbatim even when nothing new is eligible", () => {
+	test("a carried edit is re-emitted verbatim even when nothing new is eligible", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		const carried = planCompaction(msgs, CFG, 1, 10_000).edits;
 		// Target already met, so a stateless planner would emit nothing at all.
@@ -244,7 +244,7 @@ describe("plan byte-stability across turns", () => {
 		expect(next.savedBytes).toBeGreaterThan(0);
 	});
 
-	test("carried savings count toward the target, so the planner only adds what is still needed", () => {
+	test("carried savings count toward the target, so the planner only adds what is still needed", async () => {
 		const msgs = [
 			user("go"),
 			asst("c1", "read", '{"path":"a.ts"}'),
@@ -262,7 +262,7 @@ describe("plan byte-stability across turns", () => {
 		expect(next.edits.map((e) => e.index)).toEqual(carried.map((e) => e.index));
 	});
 
-	test("a carried edit is never re-planned into a different shape", () => {
+	test("a carried edit is never re-planned into a different shape", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		// Carried as a stub; a fresh plan would have chosen truncate.
 		const carried = [{ index: 2, mode: "stub" as const, keepHead: 0, keepTail: 0, note: "carried", bytes: Buffer.byteLength(big("A")) }];
@@ -276,7 +276,7 @@ describe("summarising compaction (edit.digest)", () => {
 	const MUT = { slug: "x/y", fallbacks: [], sessionId: "s", cacheBreakpointMessageIndices: [], reasoning: undefined, maxTokens: undefined, stripAssistantReasoning: false };
 	const DIGEST = "[digest: read output 208 bytes → 40 chars by cheap/model. Full output: re-run read {}]\nA: two hundred x's.";
 
-	test("a digested edit replaces the content with the digest, whatever its mode", () => {
+	test("a digested edit replaces the content with the digest, whatever its mode", async () => {
 		const raw = [
 			{ role: "user", content: "go" },
 			{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: "{}" } }] },
@@ -289,13 +289,13 @@ describe("summarising compaction (edit.digest)", () => {
 		}
 	});
 
-	test("compactedBytes sizes a digested edit by its digest, never above the original", () => {
+	test("compactedBytes sizes a digested edit by its digest, never above the original", async () => {
 		const plain = { index: 2, mode: "truncate" as const, keepHead: 10, keepTail: 10, note: "n", bytes: 5_000 };
 		expect(compactedBytes(5_000, { ...plain, digest: DIGEST })).toBe(Buffer.byteLength(DIGEST));
 		expect(compactedBytes(5_000, { ...plain, digest: "y".repeat(9_000) })).toBe(5_000);
 	});
 
-	test("the digest survives validation and a re-plan, so the bytes stay stable", () => {
+	test("the digest survives validation and a re-plan, so the bytes stay stable", async () => {
 		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
 		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
 		const digested = edits.map((e) => ({ ...e, digest: DIGEST }));