auto-model-router 0.2.16 → 0.2.21

package/test/hot-reload.test.ts

@@ -0,0 +1,131 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { readValidatedConfig, watchConfig, type ConfigWatcher } from "../src/config/hot-reload.ts";
+
+const DIR = join(import.meta.dir, ".tmp-hot-reload");
+const CFG = join(DIR, "config.yml");
+
+beforeAll(() => {
+	rmSync(DIR, { recursive: true, force: true });
+	mkdirSync(DIR, { recursive: true });
+});
+afterAll(() => {
+	rmSync(DIR, { recursive: true, force: true });
+});
+
+/** A clone of the shipped defaults serialized as YAML via JSON (the schema accepts JSON). */
+function yamlOf(partial: Record<string, unknown>): string {
+	const lines: string[] = [];
+	for (const [k, v] of Object.entries(partial)) {
+		if (typeof v === "object" && v !== null) {
+			lines.push(`${k}:`);
+			for (const [k2, v2] of Object.entries(v)) {
+				lines.push(`  ${k2}: ${JSON.stringify(v2).replaceAll('"', v2 === true || v2 === false || typeof v2 === "number" ? "" : '"')}`);
+			}
+		} else {
+			lines.push(`${k}: ${JSON.stringify(v)}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+/** Waits out the watcher's debounce. */
+const settle = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 400));
+
+describe("readValidatedConfig", () => {
+	test("accepts a valid partial and merges over defaults (removed knobs revert)", () => {
+		writeFileSync(CFG, yamlOf({ filters: { latencyWeight: 0.5 } }));
+		const result = readValidatedConfig(CFG);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+		expect(result.cfg.filters.latencyWeight).toBe(0.5);
+		// Untouched knobs carry the shipped default, not garbage.
+		expect(result.cfg.filters.contextHeadroom).toBe(DEFAULT_CONFIG.filters.contextHeadroom);
+		// A tier not mentioned in the file keeps its default shape.
+		expect(result.cfg.tiers.simple).toEqual(DEFAULT_CONFIG.tiers.simple);
+	});
+
+	test("rejects a schema violation and names the path", () => {
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: -5 } } }));
+		const result = readValidatedConfig(CFG);
+		expect(result.ok).toBe(false);
+		if (result.ok) return;
+		expect(result.error).toContain("capabilityFloorUsd");
+	});
+
+	test("rejects malformed YAML", () => {
+		writeFileSync(CFG, "filters: [unclosed");
+		const result = readValidatedConfig(CFG);
+		expect(result.ok).toBe(false);
+	});
+
+	test("reports a missing file", () => {
+		const result = readValidatedConfig(join(DIR, "nope.yml"));
+		expect(result.ok).toBe(false);
+	});
+});
+
+describe("watchConfig", () => {
+	const live: RouterConfig = structuredClone(DEFAULT_CONFIG);
+	let watcher: ConfigWatcher | null = null;
+	const reloads: string[][] = [];
+	const errors: string[] = [];
+
+	beforeAll(() => {
+		writeFileSync(CFG, "");
+		watcher = watchConfig(CFG, live, structuredClone(DEFAULT_CONFIG), ["server", "openrouter", "context", "ledger"], {
+			onReload: ({ changed }) => reloads.push(changed),
+			onError: (message) => errors.push(message),
+		});
+	});
+	afterAll(() => watcher?.close());
+
+	test("a valid edit mutates the live object in place, no restart", async () => {
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: 0.35 } } }));
+		await settle();
+		expect(live.tiers.hard.capabilityFloorUsd).toBe(0.35);
+		expect(reloads.flat()).toContain("tiers");
+	});
+
+	test("a second edit replaces the value and reverting restores the default", async () => {
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: 0.65 } } }));
+		await settle();
+		expect(live.tiers.hard.capabilityFloorUsd).toBe(0.65);
+		// Deleting the knob reverts to the shipped default, mirroring a restart.
+		writeFileSync(CFG, yamlOf({ filters: { latencyWeight: 0.4 } }));
+		await settle();
+		expect(live.tiers.hard.capabilityFloorUsd).toBeUndefined();
+		expect(live.filters.latencyWeight).toBe(0.4);
+	});
+
+	test("frozen blocks are pinned: file edits to them cannot reach the live object", async () => {
+		writeFileSync(CFG, yamlOf({ server: { port: 1, host: "10.9.9.9" }, filters: { latencyWeight: 0.3 } }));
+		await settle();
+		expect(live.server.port).toBe(DEFAULT_CONFIG.server.port);
+		expect(live.server.host).toBe(DEFAULT_CONFIG.server.host);
+		// The non-frozen sibling still applied.
+		expect(live.filters.latencyWeight).toBe(0.3);
+	});
+
+	test("an invalid file is rejected and the running config keeps serving", async () => {
+		const before = structuredClone(live.filters);
+		const tierBefore = structuredClone(live.tiers.hard);
+		// capabilityFloorUsd must be strictly positive: -1 is a schema violation.
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: -1 } } }));
+		await settle();
+		expect(errors.length).toBeGreaterThan(0);
+		expect(errors.at(-1)).toContain("capabilityFloorUsd");
+		// The live object keeps the last-good values.
+		expect(live.tiers.hard.capabilityFloorUsd).toBe(tierBefore.capabilityFloorUsd);
+		expect(live.filters.latencyWeight).toBe(before.latencyWeight);
+	});
+	test("close() stops watching: later edits are ignored", async () => {
+		watcher?.close();
+		writeFileSync(CFG, yamlOf({ filters: { latencyWeight: 9.9 } }));
+		await settle();
+		expect(live.filters.latencyWeight).not.toBe(9.9);
+	});
+});

package/test/http-resilience.test.ts

@@ -0,0 +1,58 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { startServer, type StartedServer } from "../src/server/http.ts";
+
+describe("HTTP server resilience against dead streams", () => {
+	let handle: StartedServer;
+	let baseUrl: string;
+
+	beforeAll(() => {
+		const cfg: RouterConfig = {
+			...DEFAULT_CONFIG,
+			server: { host: "127.0.0.1", port: 0 },
+			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
+			context: { ...DEFAULT_CONFIG.context, enabled: false },
+			logLevel: "silent",
+		};
+		handle = startServer(cfg);
+		baseUrl = `http://127.0.0.1:${handle.server.port}`;
+	});
+	afterAll(async () => {
+		await handle.stop();
+	});
+
+	test("server answers /v1/models cleanly initially", async () => {
+		const res = await fetch(`${baseUrl}/v1/models`);
+		expect(res.status).toBe(200);
+		const json = (await res.json()) as { data: unknown[] };
+		expect(Array.isArray(json.data)).toBe(true);
+	});
+
+	test("cancelling a streaming /v1/chat/completions client does not crash the server", async () => {
+		const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				model: "auto",
+				stream: true,
+				messages: [{ role: "user", content: "hello" }],
+			}),
+		});
+
+		// Immediately cancel the reader mid-stream (simulates client disconnect)
+		const reader = res.body?.getReader();
+		expect(reader).toBeDefined();
+		await reader?.cancel("client abruptly dropped");
+
+		// Allow microtasks and I/O ticks to settle without real wall-clock delays
+		await new Promise<void>((resolve) => {
+			setImmediate(() => resolve());
+		});
+		// and answers subsequent requests cleanly.
+		const modelsRes = await fetch(`${baseUrl}/v1/models`);
+		expect(modelsRes.status).toBe(200);
+		const json = (await modelsRes.json()) as { data: unknown[] };
+		expect(Array.isArray(json.data)).toBe(true);
+	});
+});

package/test/tier-plan.test.ts

@@ -2,14 +2,18 @@ import { describe, expect, test } from "bun:test";
 
 import { joinBenchmarks, normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
 import type { CatalogModel, CatalogSnapshot } from "../src/catalog/types.ts";
-import { loadConfig } from "../src/config/load.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import { buildCandidates } from "../src/router/candidates.ts";
 import { extractFeatures } from "../src/router/features.ts";
 import { computeTierPlan, effectivePriceCeiling, effectiveQualityFloor, tierPlanFor } from "../src/router/tier-plan.ts";
 import { TIER_ORDER } from "../src/router/types.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 
-const BASE = loadConfig({});
+// SHIPPED defaults, deliberately NOT loadConfig({}): that reads the developer's
+// live ~/.auto-model-router/config.yml, so an enabled machine-wide knob (e.g.
+// tiers.hard.capabilityFloorUsd during the 0.2.20 rollout) silently changed
+// these expectations and made the suite machine-dependent.
+const BASE = DEFAULT_CONFIG;
 
 /** Raw `/models`-shaped record with a controllable coding score and price. */
 function raw(id: string, coding: number | null, inPerMtok: number): Record<string, unknown> {
@@ -354,3 +358,94 @@ describe("adaptive price ceilings", () => {
 		expect(on.rejected.some((r) => r.slug === "a/4" && r.reason === "over_price_ceiling")).toBe(true);
 	});
 });
+
+describe("quality normalization and capability floor (benchmark findings 4/6)", () => {
+	const req = parseChatRequest(
+		{
+			model: "auto",
+			tools: [{ type: "function", function: { name: "read", description: "Read", parameters: { type: "object", properties: {} } } }],
+			messages: [{ role: "user", content: "implement nested transaction savepoints" }],
+		},
+		new Headers(),
+	);
+	const features = extractFeatures(req, 100);
+
+	// The real catalog's shape: quality in a narrow band, price spanning ~100x.
+	// `hard` has a quality floor of 72, so cheap/1 is deliberately below it —
+	// it must be rejected, and mid/2 is the cheapest ELIGIBLE model, the one
+	// raw quality-per-dollar ranking picks at any sane exponent.
+	const spread = snapshot(
+		models([
+			["cheap/1", 70, 0.05],
+			["mid/2", 74, 1.0],
+			["good/3", 76, 3.0],
+			["best/4", 78, 5.0],
+		]),
+	);
+
+	const run = (tierOverride: Partial<(typeof BASE)["tiers"]["hard"]>) =>
+		buildCandidates({
+			req,
+			features,
+			tier: "hard",
+			task: "coding",
+			snapshot: spread,
+			ledger: null,
+			cfg: { ...BASE, tiers: { ...BASE.tiers, hard: { ...BASE.tiers.hard, ...tierOverride } } },
+			expectedCompletionTokens: 512,
+			warmSlug: null,
+		});
+
+	test("raw scoring at the shipped exponent picks the cheapest ELIGIBLE model", () => {
+		const { candidates, rejected } = run({ qualityExponent: 3 });
+		expect(candidates[0]?.model.slug).toBe("mid/2");
+		// cheap/1 is under the hard floor of 72 and never competes.
+		expect(rejected.some((r) => r.slug === "cheap/1" && r.reason === "below_quality_floor")).toBe(true);
+	});
+
+	test("normalization lets a single-digit exponent buy the best model, which raw cannot", () => {
+		// Raw at the same exponent still cannot reach it: that is the defect.
+		expect(run({ qualityExponent: 12 }).candidates[0]?.model.slug).toBe("mid/2");
+		// Normalised, the same 12 selects the top-quality model.
+		const normalised = run({ qualityExponent: 12, qualityNormalization: true });
+		expect(normalised.candidates[0]?.model.slug).toBe("best/4");
+		expect(normalised.candidates[0]?.reasons.some((r) => r.includes("quality normalised"))).toBe(true);
+	});
+
+	test("normalization is monotone in the exponent: higher never picks a weaker model", () => {
+		let lastQuality = 0;
+		for (const qualityExponent of [1, 4, 8, 12, 20]) {
+			const top = run({ qualityExponent, qualityNormalization: true }).candidates[0];
+			expect(top).toBeDefined();
+			expect(top?.qualityScore ?? 0).toBeGreaterThanOrEqual(lastQuality);
+			lastQuality = top?.qualityScore ?? 0;
+		}
+	});
+
+	test("capability floor takes the best model inside the cap, ignoring the ratio", () => {
+		// mid/2 costs ~$0.0016 and good/3 ~$0.0049, so this cap admits both but
+		// excludes best/4 (~$0.0082). The ranked winner is mid/2 (cheapest).
+		const cap = 0.005;
+		const capped = run({ capabilityFloorUsd: cap });
+		const top = capped.candidates[0];
+		expect(top).toBeDefined();
+		expect(top?.forecast.coldUsd ?? 1).toBeLessThanOrEqual(cap);
+		// It must be the highest-quality affordable one, not the cheapest: good/3.
+		expect(top?.model.slug).toBe("good/3");
+		expect(top?.reasons.some((r) => r.includes("capability floor"))).toBe(true);
+	});
+
+	test("capability floor is strictly an upgrade: an unaffordable cap changes nothing", () => {
+		const base = run({}).candidates.map((c) => c.model.slug);
+		// A cap below every candidate's cost promotes nobody.
+		const tiny = run({ capabilityFloorUsd: 1e-9 }).candidates.map((c) => c.model.slug);
+		expect(tiny).toEqual(base);
+	});
+
+	test("both modes stay inert by default, so shipped behaviour is unchanged", () => {
+		const shipped = run({});
+		expect(shipped.candidates[0]?.model.slug).toBe("mid/2");
+		expect(shipped.candidates.every((c) => !c.reasons.some((r) => r.includes("normalised")))).toBe(true);
+		expect(shipped.candidates.every((c) => !c.reasons.some((r) => r.includes("capability floor")))).toBe(true);
+	});
+});

package/test/turn.test.ts

@@ -70,7 +70,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],

package/test/wire-sink.test.ts

@@ -70,6 +70,37 @@ describe("createStreamingSink", () => {
 			{ error: { message: "boom", type: "server_error", code: "upstream_error" } },
 		]);
 	});
+
+	test("chunk, error, and finish survive a client-cancelled body without throwing", async () => {
+		const { sink, response } = createStreamingSink("auto");
+		const reader = response.body?.getReader();
+		expect(reader).toBeDefined();
+		// Client disconnects mid-stream: reader cancels, controller closes.
+		await reader?.cancel("client closed connection");
+
+		// None of these may throw ERR_INVALID_STATE:
+		expect(() => {
+			sink.chunk(
+				chunk({
+					id: "gen-cancelled",
+					model: "openai/gpt-5.5",
+					choices: [{ index: 0, delta: { content: "trailing" }, finish_reason: null }],
+				}),
+			);
+		}).not.toThrow();
+
+		expect(() => {
+			sink.finish(SUMMARY);
+		}).not.toThrow();
+
+		// Repeated calls (e.g. error after chunk on dead stream) must also stay safe:
+		const { sink: sink2, response: response2 } = createStreamingSink("auto");
+		const reader2 = response2.body?.getReader();
+		await reader2?.cancel();
+		expect(() => {
+			sink2.error({ status: 500, code: "server_error", message: "late failure" });
+		}).not.toThrow();
+	});
 });
 
 describe("createBufferedSink", () => {

package/tools/replay.ts

@@ -26,20 +26,29 @@
  *  - `explorationDraw` keys on `conversationKey:turn`, both recorded, so
  *    exploration reproduces deterministically and cancels out in a diff.
  *
+ * Conversation state is reconstructed from the PRECEDING recorded dispatch in
+ * the same conversation — prior slug, prior tier, cache warmth, cumulative
+ * spend — rather than simulated, so cache-warmth behaviour is exercised. Rows
+ * are replayed chronologically for that reason.
+ *
  * WHAT IT DOES NOT MODEL — read this before trusting a conclusion
  *  - `messages` are not recorded, so compaction cannot be re-planned. Replay
  *    forces `compaction.enabled=false` and feeds the POST-compaction prompt
  *    size (`usage.promptTokens`), i.e. the prompt selection actually saw.
- *  - Conversation state is not recoverable historically (only the current row
- *    survives), so replay uses a neutral state: no sticky tier, no warm cache,
- *    no accumulated spend. Hysteresis, cache-warmth tie-breaks and the
- *    per-conversation budget guard are therefore NOT exercised.
+ *  - `stickyUntilTurn` was never persisted per turn, so the hysteresis hold
+ *    window is absent. This is the main residual gap.
  *  - `requestedReasoning` is the one `Features` field the ledger omits; it
  *    replays as undefined.
+ *  - Module constants are not config, so things like CAP_AUTONOMOUS_LOOP cannot
+ *    be A/B'd via `--set` — only `RouterConfig` paths can.
  *
- * Because of those gaps, the report leads with a FIDELITY figure: how often the
- * baseline variant reproduces the model that actually served. Low fidelity means
- * the unmodelled parts dominate and any delta below is weak evidence.
+ * Because of those gaps the report leads with a FIDELITY figure. Read it with
+ * care: it conflates replay error with genuine code change, since replay always
+ * runs CURRENT code against rows served by whatever code was live then. Measured
+ * on rows served by matching code it is 90% model / 77% tier; across older
+ * history it drops to ~55%, and that drop is the shipped classifier changes
+ * showing up, not the tool being wrong. Isolate a population with `--where` when
+ * measuring one change.
  */
 
 import { Database } from "bun:sqlite";
@@ -106,7 +115,11 @@ function withOverrides(cfg: RouterConfig, sets: readonly string[]): RouterConfig
 			node = child as Record<string, unknown>;
 		}
 		const leaf = path[path.length - 1];
-		if (leaf === undefined || !(leaf in node)) throw new Error(`--set path not found: ${entry}`);
+		if (leaf === undefined) throw new Error(`--set expects a key, got: ${entry}`);
+		// An absent leaf is legitimate and required: optional config fields are
+		// simply missing until set (exactOptionalPropertyTypes), and introducing
+		// one is exactly what a variant does. A wrong PARENT path still throws,
+		// in the walk above, which is what catches typos.
 		node[leaf] = value;
 	}
 	return next;
@@ -124,6 +137,7 @@ interface Row {
 	usage: string;
 	reported_usd: number | null;
 	predicted_usd: number;
+	created_at_ms: number;
 }
 
 /** Rebuilds the classifier input. The ledger stores 20 of 21 Features fields. */
@@ -164,26 +178,48 @@ function requestOf(row: Row, f: Features): NormRequest {
 	};
 }
 
-/** Neutral state: no sticky tier, no warm cache, no prior spend. See header. */
-function stateOf(row: Row): ConversationState {
+/**
+ * Conversation state reconstructed from the PRECEDING recorded dispatch in the
+ * same conversation, not simulated.
+ *
+ * A neutral state cannot validate anything that depends on cache warmth — every
+ * candidate looks cold, so a warm-cache change shows zero effect. But the
+ * ledger does carry what the previous dispatch actually did, so warmth is
+ * recoverable: `cacheWarmSlug` is the slug it served, `lastPromptTokens` its
+ * prompt size. Deriving state from the RECORDED outcome rather than the
+ * replayed one also stops replay error compounding down a conversation.
+ *
+ * Still not modelled: `stickyUntilTurn`, which was never persisted per turn, so
+ * the hysteresis hold window remains absent.
+ */
+function stateOf(row: Row, prior: PriorTurn | undefined): ConversationState {
 	return {
 		key: row.conversation_key,
 		sessionId: `omp-${row.conversation_key}`,
 		turn: row.turn,
-		currentSlug: null,
-		currentTier: null,
+		currentSlug: prior?.slug ?? null,
+		currentTier: (prior?.tier as Tier | undefined) ?? null,
 		stickyUntilTurn: 0,
 		escalations: 0,
-		spentUsd: 0,
-		lastPromptTokens: 0,
-		cacheWarmSlug: null,
-		cacheWarmAtMs: 0,
+		spentUsd: prior?.spentUsd ?? 0,
+		lastPromptTokens: prior?.promptTokens ?? 0,
+		cacheWarmSlug: prior?.cachedTokens !== undefined && prior.cachedTokens > 0 ? prior.slug : null,
+		cacheWarmAtMs: prior?.atMs ?? 0,
 		contextVersion: null,
 		contextFetchedAtMs: 0,
-		updatedAtMs: 0,
+		updatedAtMs: prior?.atMs ?? 0,
 	};
 }
 
+interface PriorTurn {
+	slug: string | null;
+	tier: string;
+	promptTokens: number;
+	cachedTokens: number;
+	spentUsd: number;
+	atMs: number;
+}
+
 /**
  * Re-prices a decision against the tokens the turn ACTUALLY used, via the real
  * `computeCost` so price tiers, the cache split and reasoning/request fees are
@@ -224,14 +260,18 @@ const bySlug = new Map(snapshot.models.map((m) => [m.slug, m]));
 const ledger = createLedger(db, cfgA);
 
 const predicate = args.where === "" ? "" : ` AND (${args.where})`;
-const rows = db
-	.query(
-		`SELECT id, conversation_key, turn, requested_model, harness_id, served_slug, tier, features, usage, reported_usd, predicted_usd
-		 FROM ledger
-		 WHERE features IS NOT NULL AND wasted = 0${predicate}
-		 ORDER BY created_at_ms DESC LIMIT ?`,
-	)
-	.all(args.limit) as Row[];
+// Newest-first to honour --limit, then flipped to chronological so each row can
+// see the dispatch that preceded it in its conversation.
+const rows = (
+	db
+		.query(
+			`SELECT id, conversation_key, turn, requested_model, harness_id, served_slug, tier, features, usage, reported_usd, predicted_usd, created_at_ms
+			 FROM ledger
+			 WHERE features IS NOT NULL AND wasted = 0${predicate}
+			 ORDER BY created_at_ms DESC LIMIT ?`,
+		)
+		.all(args.limit) as Row[]
+).reverse();
 
 if (rows.length === 0) {
 	console.error("no rows matched; widen --where or --limit");
@@ -253,7 +293,7 @@ interface Outcome {
 	usd: number;
 }
 
-function run(cfg: RouterConfig, row: Row, usage: UsageCounts): Outcome {
+function run(cfg: RouterConfig, row: Row, usage: UsageCounts, prior: PriorTurn | undefined): Outcome {
 	const f = featuresOf(row, usage.promptTokens);
 	const req = requestOf(row, f);
 	const decision: Decision = select({
@@ -261,7 +301,7 @@ function run(cfg: RouterConfig, row: Row, usage: UsageCounts): Outcome {
 		features: f,
 		classification: scoreHeuristic(f, cfg),
 		profile: profileOf(cfg, row.requested_model),
-		state: stateOf(row),
+		state: stateOf(row, prior),
 		snapshot,
 		ledger,
 		cfg,
@@ -285,11 +325,24 @@ let comparable = 0;
 const flips: { id: string; tier: string; from: string; to: string; delta: number }[] = [];
 const bump = (m: Map<string, number>, k: string) => m.set(k, (m.get(k) ?? 0) + 1);
 
+// Carries the RECORDED outcome of each conversation's previous dispatch forward,
+// so cache warmth and the prior slug are real rather than assumed absent.
+const priorByConv = new Map<string, PriorTurn>();
+
 for (const row of rows) {
 	const u = JSON.parse(row.usage) as UsageCounts;
 	if (!(u.promptTokens > 0)) continue;
-	const a = run(cfgA, row, u);
-	const b = run(cfgB, row, u);
+	const prior = priorByConv.get(row.conversation_key);
+	const a = run(cfgA, row, u, prior);
+	const b = run(cfgB, row, u, prior);
+	priorByConv.set(row.conversation_key, {
+		slug: row.served_slug,
+		tier: row.tier,
+		promptTokens: u.promptTokens,
+		cachedTokens: u.cachedTokens,
+		spentUsd: (prior?.spentUsd ?? 0) + (row.reported_usd ?? row.predicted_usd),
+		atMs: row.created_at_ms,
+	});
 	bump(tallyA, a.slug);
 	bump(tallyB, b.slug);
 	bump(tierA, a.tier);