auto-model-router 0.2.32 → 0.3.0

package/test/select.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
 import type { CatalogModel, CatalogSnapshot } from "../src/catalog/types.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import { loadConfig } from "../src/config/load.ts";
 import type { ProfileConfig, RouterConfig } from "../src/config/types.ts";
 import type { Ledger } from "../src/cost/types.ts";
@@ -628,6 +629,7 @@ describe("context compaction", () => {
 			enabled: true,
 			budgetTokens: 1_000,
 			floorRatio: 1,
+			replanGrowthRatio: 1,
 			fitToWindow: false,
 			protectRecentTurns: 1,
 			maxToolResultBytes: 100,
@@ -801,7 +803,7 @@ describe("hysteresis.breakHoldOnMechanical", () => {
 	}
 
 	test("off by default, so a hold still pins the tier", () => {
-		expect(BASE.hysteresis.breakHoldOnMechanical).toBe(false);
+		expect(DEFAULT_CONFIG.hysteresis.breakHoldOnMechanical).toBe(false); // SHIPPED default, not the live config.yml (machine-dependent)
 		const { d, features } = decide(continuation(), false);
 		expect(features.isToolResultContinuation).toBe(true);
 		expect(d.tier).toBe("hard");
@@ -846,3 +848,151 @@ describe("hysteresis.breakHoldOnMechanical", () => {
 		expect(d.tier).toBe("moderate");
 	});
 });
+
+describe("hysteresis.switchHorizonTurns (review 2026-09-05 §4)", () => {
+	// Two moderate-eligible models built from raw catalog records: a kimi-shaped
+	// warm model (cheap to READ from cache, dear cold) and a gemini-shaped ranked
+	// winner (dear cold, cheap warm). With a one-turn horizon the cold write on
+	// the winner never pays for itself, so the dear model stays warm forever;
+	// over a run of turns the switch is obviously right.
+	function rawModel(id: string, coding: number, prompt: number, cacheRead: number, cacheWrite: number | null): Record<string, unknown> {
+		const pricing: Record<string, string> = {
+			prompt: String(prompt / 1e6),
+			completion: String((prompt * 4) / 1e6),
+			input_cache_read: String(cacheRead / 1e6),
+		};
+		if (cacheWrite !== null) pricing.input_cache_write = String(cacheWrite / 1e6);
+		return {
+			id,
+			canonical_slug: id,
+			name: id,
+			context_length: 1_000_000,
+			pricing,
+			supported_parameters: ["tools"],
+			architecture: { input_modalities: ["text"], tokenizer: "GPT" },
+			benchmarks: { artificial_analysis: { coding_index: coding, intelligence_index: coding, agentic_index: coding } },
+			created: 1_700_000_000,
+		};
+	}
+	const warmDear = normalizeCatalogModel(rawModel("test/warm-dear", 76.2, 2.55, 0.256, null))!;
+	const winner = normalizeCatalogModel(rawModel("test/winner", 76.0, 0.75, 0.075, 0.04))!;
+	const snap: CatalogSnapshot = { models: [warmDear, winner], fetchedAtMs: Date.now() };
+	const promptTokens = 100_000;
+
+	function decide(horizon: number) {
+		// BASE is the live config.yml, which may have exploration on; a
+		// deterministic exploration draw would route this turn down to `simple`,
+		// where the dear model is over the price ceiling and never compared.
+		const cfg: RouterConfig = {
+			...BASE,
+			exploration: { ...BASE.exploration, enabled: false },
+			hysteresis: { ...BASE.hysteresis, switchMargin: 1.3, switchHorizonTurns: horizon },
+		};
+		const req = request("keep going");
+		const features = extractFeatures(req, promptTokens);
+		return select({
+			req,
+			features,
+			classification: { ...scoreHeuristic(features, cfg), tier: "moderate" },
+			profile: PROFILE,
+			state: state({ currentSlug: "test/warm-dear", currentTier: "moderate", cacheWarmSlug: "test/warm-dear", cacheWarmAtMs: Date.now(), lastPromptTokens: promptTokens }),
+			snapshot: snap,
+			ledger: null,
+			cfg,
+			nowMs: Date.now(),
+		});
+	}
+
+	test("the ranked winner is the cheaper cold model", () => {
+		const d = decide(1);
+		expect(d.considered[0]!.model.slug).toBe("test/winner");
+	});
+
+	test("a one-turn horizon keeps the dear model warm (the shipped behaviour)", () => {
+		const d = decide(1);
+		expect(d.slug).toBe("test/warm-dear");
+		expect(d.sticky).toBe(true);
+		expect(d.reasons.some((r) => r.startsWith("cache: keeping warm test/warm-dear"))).toBe(true);
+	});
+
+	test("amortised over a run of turns, the switch is taken", () => {
+		const d = decide(8);
+		expect(d.slug).toBe("test/winner");
+		expect(d.sticky).toBe(false);
+		expect(d.reasons.some((r) => r.startsWith("cache: switch test/warm-dear → test/winner") && r.includes("over 8 turns"))).toBe(true);
+	});
+});
+
+describe("compaction.replanGrowthRatio (review 2026-09-05 §7)", () => {
+	const TOOL_RESULT = "y".repeat(3000);
+	function turn(n: number): NormRequest {
+		// n completed read/result/"continue" rounds; every result but the newest
+		// sits outside the protected window and is eligible for truncation.
+		const messages: unknown[] = [
+			{ role: "system", content: "You are a coding agent." },
+			{ role: "user", content: "read the files" },
+		];
+		for (let i = 0; i < n; i++) {
+			messages.push({ role: "assistant", content: null, tool_calls: [{ id: `c${i}`, type: "function", function: { name: "read", arguments: `{"path":"f${i}.ts"}` } }] });
+			messages.push({ role: "tool", tool_call_id: `c${i}`, content: TOOL_RESULT });
+			messages.push({ role: "user", content: "continue" });
+		}
+		return parseChatRequest({ model: "auto", tools: TOOLS, messages }, new Headers());
+	}
+	function cfgWith(ratio: number): RouterConfig {
+		return {
+			...BASE,
+			compaction: {
+				enabled: true,
+				budgetTokens: 100, // unreachable: every turn is over budget, as observed live
+				floorRatio: 1,
+				replanGrowthRatio: ratio,
+				fitToWindow: false,
+				protectRecentTurns: 2, // the newest result and its "continue" stay protected; older rounds are eligible
+				maxToolResultBytes: 100,
+				keepHeadBytes: 20,
+				keepTailBytes: 20,
+				elideSupersededReads: false,
+				collapseDuplicateResults: false,
+			},
+		};
+	}
+	function decide(req: NormRequest, cfg: RouterConfig, st: ConversationState, promptTokens: number) {
+		const features = extractFeatures(req, promptTokens);
+		return select({ req, features, classification: scoreHeuristic(features, cfg), profile: PROFILE, state: st, snapshot: SNAPSHOT, ledger: null, cfg, nowMs: Date.now() });
+	}
+
+	test("the plan records the compacted size it was made at", () => {
+		const first = decide(turn(2), cfgWith(1), state(), 4_000);
+		expect(first.compactionPlan.length).toBe(1);
+		expect(first.compactionPlanTokens).toBe(4_000 - first.promptTokensSaved);
+		expect(first.compactionSavedBytes).toBeGreaterThan(0);
+	});
+
+	test("at 1 (shipped) a newly eligible result is compacted on the very next turn", () => {
+		const first = decide(turn(2), cfgWith(1), state(), 4_000);
+		const carried = state({ compactionPlan: first.compactionPlan, compactionPlanTokens: first.compactionPlanTokens });
+		// One more round: the prompt grew ~25%, one more result aged out.
+		const second = decide(turn(3), cfgWith(1), carried, 5_000);
+		expect(second.compactionPlan.length).toBe(2);
+		expect(second.reasons.some((r) => r.includes("(1 carried, 1 new)"))).toBe(true);
+	});
+
+	test("above 1, an existing plan holds until the compacted prompt has grown by the ratio", () => {
+		const first = decide(turn(2), cfgWith(2), state(), 4_000);
+		const carried = state({ compactionPlan: first.compactionPlan, compactionPlanTokens: first.compactionPlanTokens });
+		// The raw prompt grew 25% and the COMPACTED prompt ~60% (the carried
+		// edit saves a smaller share of a bigger prompt) — still under 2x, so
+		// the carried plan is re-applied verbatim and nothing new is added.
+		const held = decide(turn(3), cfgWith(2), carried, 5_000);
+		expect(held.compactionPlan).toEqual(first.compactionPlan);
+		expect(held.compactionPlanTokens).toBe(first.compactionPlanTokens); // growth still accrues against the original size
+		expect(held.reasons.some((r) => r.includes("(1 carried, 0 new)") && r.includes("[re-plan rationed]"))).toBe(true);
+		// Past 2x the plan is extended and the new size is recorded.
+		const grown = decide(turn(3), cfgWith(2), carried, 8_000);
+		expect(grown.compactionPlan.length).toBe(2);
+		expect(grown.compactionPlanTokens).toBe(8_000 - grown.promptTokensSaved);
+		expect(grown.reasons.some((r) => r.includes("[re-plan rationed]"))).toBe(false);
+	});
+});
+

package/test/tier-plan.test.ts

@@ -2,10 +2,11 @@ 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 type { Ledger } from "../src/cost/types.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 { computeTierPlan, countAdmitted, 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";
 
@@ -449,3 +450,160 @@ describe("quality normalization and capability floor (benchmark findings 4/6)",
 		expect(shipped.candidates.every((c) => !c.reasons.some((r) => r.includes("capability floor")))).toBe(true);
 	});
 });
+
+describe("thinness-gated relaxation (review 2026-09-05 §1)", () => {
+	// A WIDE catalog whose weak tail drags every quantile band far below the
+	// configured floors — the shape the key-admitted 347-model catalog has.
+	// Configured coding floors: simple 40, moderate 60, hard 72.
+	const wide = computeTierPlan(
+		models([
+			["w/1", 5, 0.02],
+			["w/2", 10, 0.02],
+			["w/3", 15, 0.03],
+			["w/4", 20, 0.03],
+			["w/5", 25, 0.05],
+			["w/6", 30, 0.05],
+			["w/7", 35, 0.1],
+			["w/8", 45, 0.1],
+			["w/9", 50, 0.2],
+			["w/10", 62, 0.5],
+			["w/11", 70, 0.7],
+			["w/12", 74, 1.0],
+			["w/13", 76, 2.0],
+			["w/14", 78, 5.0],
+		]),
+		BASE,
+	);
+
+	test("the bands sit below the configured floors on a wide catalog", () => {
+		// The premise the gate exists for: unconditional min() would relax here.
+		expect(wide.floors.coding.moderate).toBeLessThan(60);
+		expect(wide.floors.coding.hard).toBeLessThan(72);
+	});
+
+	test("a configured floor that three or more models meet stands as written", () => {
+		expect(effectiveQualityFloor(60, "moderate", "coding", wide)).toBe(60); // 62,70,74,76,78 meet it
+		expect(effectiveQualityFloor(72, "hard", "coding", wide)).toBe(72); // 74,76,78 meet it
+		expect(effectiveQualityFloor(40, "simple", "coding", wide)).toBe(40);
+	});
+
+	test("a floor fewer than three models meet is relaxed to the band", () => {
+		// Only 76 and 78 clear 75: thin, so the hard band applies.
+		expect(effectiveQualityFloor(75, "hard", "coding", wide)).toBe(Math.min(75, wide.floors.coding.hard));
+		// Nothing clears 90: relaxed as before.
+		expect(effectiveQualityFloor(90, "hard", "coding", wide)).toBe(wide.floors.coding.hard);
+	});
+
+	test("countAdmitted counts scores at or above the floor", () => {
+		expect(countAdmitted([10, 20, 30, 40], 25)).toBe(2);
+		expect(countAdmitted([10, 20, 30, 40], 40)).toBe(1);
+		expect(countAdmitted([10, 20, 30, 40], 41)).toBe(0);
+		expect(countAdmitted([10, 20, 30, 40], 0)).toBe(4);
+		expect(countAdmitted([], 0)).toBe(0);
+	});
+
+	test("in candidate selection the wide catalog keeps weak models out of moderate", () => {
+		const req = parseChatRequest(
+			{
+				model: "auto",
+				tools: [{ type: "function", function: { name: "read", description: "Read", parameters: { type: "object", properties: {} } } }],
+				messages: [{ role: "user", content: "refactor the auth module" }],
+			},
+			new Headers(),
+		);
+		const features = extractFeatures(req, 100);
+		const snap = snapshot(
+			models([
+				["w/8", 45, 0.1],
+				["w/9", 50, 0.2],
+				["w/10", 62, 0.5],
+				["w/11", 70, 0.7],
+				["w/12", 74, 1.0],
+			]),
+		);
+		const { candidates, rejected } = buildCandidates({
+			req,
+			features,
+			tier: "moderate",
+			task: "coding",
+			snapshot: snap,
+			ledger: null,
+			cfg: { ...BASE, adaptiveTierFloors: true },
+			expectedCompletionTokens: 512,
+			warmSlug: null,
+		});
+		// 62, 70 and 74 meet the configured 60, so 45 and 50 are excluded even
+		// though the adaptive band would have admitted them.
+		expect(candidates.map((c) => c.model.slug).sort()).toEqual(["w/10", "w/11", "w/12"]);
+		expect(rejected.filter((r) => r.reason === "below_quality_floor").map((r) => r.slug).sort()).toEqual(["w/8", "w/9"]);
+	});
+});
+
+describe("escalation-cost term (review 2026-09-05 §2)", () => {
+	const req = parseChatRequest(
+		{
+			model: "auto",
+			tools: [{ type: "function", function: { name: "read", description: "Read", parameters: { type: "object", properties: {} } } }],
+			messages: [{ role: "user", content: "rename the helper" }],
+		},
+		new Headers(),
+	);
+	const features = extractFeatures(req, 100_000);
+	// Identical price, quality AND success rate (so the trust divisor is
+	// neutral); only the escalation count tells them apart.
+	const snap = snapshot(
+		models([
+			["cheap/flaky", 50, 0.02],
+			["cheap/solid", 50, 0.02],
+		]),
+	);
+	const trustOf = (slug: string) =>
+		slug === "cheap/flaky"
+			? { slug, attempts: 100, escalations: 4, errors: 0, successRate: 0.96, meanCostError: 0 }
+			: { slug, attempts: 100, escalations: 0, errors: 4, successRate: 0.96, meanCostError: 0 };
+	const ledger: Ledger = {
+		record: () => {},
+		conversationSpend: () => 0,
+		spendSince: () => 0,
+		blendedRate: () => null,
+		trust: (slug) => trustOf(slug),
+		allTrust: () => [],
+		latency: () => null,
+		tokenRatio: () => null,
+		recentEntries: () => [],
+	};
+	function build(weight: number, usdPerPromptToken?: number) {
+		return buildCandidates({
+			req,
+			features,
+			tier: "trivial",
+			task: "coding",
+			snapshot: snap,
+			ledger,
+			cfg: { ...BASE, filters: { ...BASE.filters, escalationCostWeight: weight } },
+			expectedCompletionTokens: 512,
+			warmSlug: null,
+			...(usdPerPromptToken === undefined ? {} : { escalationUsdPerPromptToken: usdPerPromptToken }),
+		});
+	}
+
+	test("with the term off, nothing separates them and the tie falls lexically to the flaky model", () => {
+		const { candidates } = build(0, 1e-6);
+		// Same success rate, same trust divisor: escalations are invisible.
+		expect(candidates[0]!.model.slug).toBe("cheap/flaky");
+		expect(candidates[0]!.reasons.some((r) => r.startsWith("escalation risk"))).toBe(false);
+	});
+
+	test("priced at what an escalated retry actually bills, the flaky model loses", () => {
+		const { candidates } = build(1, 1e-6); // $1/Mtok of escalated-retry cost
+		expect(candidates[0]!.model.slug).toBe("cheap/solid");
+		const flaky = candidates.find((c) => c.model.slug === "cheap/flaky")!;
+		expect(flaky.reasons.some((r) => r.startsWith("escalation risk"))).toBe(true);
+	});
+
+	test("inert until the ledger can measure the retry cost", () => {
+		const { candidates } = build(1);
+		expect(candidates[0]!.model.slug).toBe("cheap/flaky");
+	});
+});
+

package/test/toast-logic.test.ts

@@ -5,6 +5,7 @@ import { parse as parseYaml } from "yaml";
 import {
 	DEFAULT_ROUTER_URL,
 	newestId,
+	providerOf,
 	resolveRouterUrl,
 	selectToasts,
 	toToastText,
@@ -186,7 +187,15 @@ describe("toToastText", () => {
 		expect(toToastText(dec({ reportedUsd: null }))).not.toContain("$");
 	});
 
-	test("renders model [tier]", () => {
-		expect(toToastText(dec({ slug: "q/w", tier: "hard", reportedUsd: null }))).toBe("q/w [hard]");
+	test("renders provider · model [tier]", () => {
+		expect(toToastText(dec({ slug: "q/w", tier: "hard", reportedUsd: null }))).toBe("openrouter · q/w [hard]");
+	});
+
+	test("an Ollama slug is labelled with its provider and shown without the prefix", () => {
+		expect(toToastText(dec({ slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", tier: "moderate", reportedUsd: 0.0007 }))).toBe(
+			"ollama · glm-5.3-flash [moderate] · $0.00070",
+		);
+		expect(providerOf("ollama/gpt-oss:120b")).toEqual({ provider: "ollama", model: "gpt-oss:120b" });
+		expect(providerOf("z-ai/glm-5.3-flash")).toEqual({ provider: "openrouter", model: "z-ai/glm-5.3-flash" });
 	});
 });

package/test/tokens.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, test } from "bun:test";
 import { loadConfig } from "../src/config/load.ts";
 import { createLedger } from "../src/cost/ledger.ts";
 import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
-import { DEFAULT_BYTES_PER_TOKEN, estimatePromptTokens, estimateTokens } from "../src/tokens/estimate.ts";
+import { adjustPendingEstimate, DEFAULT_BYTES_PER_TOKEN, estimatePromptTokens, estimateTokens } from "../src/tokens/estimate.ts";
 import { openDb } from "../src/util/sqlite.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 
@@ -167,3 +167,73 @@ describe("estimatePromptTokens", () => {
 		expect(estimatePromptTokens(withImage, "gpt", null)).toBeGreaterThan(estimatePromptTokens(text, "gpt", null) + 500);
 	});
 });
+
+describe("calibration hygiene (review 2026-09-05 §8)", () => {
+	function requestOf(text: string) {
+		return parseChatRequest({ model: "auto", messages: [{ role: "user", content: text }] }, new Headers());
+	}
+
+	test("a provider reporting impossible token counts never calibrates its family", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			const req = requestOf("x".repeat(10_000));
+			for (let i = 0; i < 30; i++) {
+				estimatePromptTokens(req, "qwen3", ledger);
+				// 0.4 bytes/token: ~8x what the bytes imply (seen live from one provider).
+				ledger.record(entry({ conversationKey: req.conversationKey, usage: { ...EMPTY_USAGE, promptTokens: Math.round(req.promptBytes / 0.4) } }));
+			}
+			expect(ledger.tokenRatio("qwen3")).toBeNull();
+			for (let i = 0; i < 30; i++) {
+				estimatePromptTokens(req, "qwen3", ledger);
+				ledger.record(entry({ conversationKey: req.conversationKey, usage: { ...EMPTY_USAGE, promptTokens: Math.round(req.promptBytes / 3.2) } }));
+			}
+			expect(ledger.tokenRatio("qwen3")).toBeCloseTo(3.2, 1);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("adjustPendingEstimate calibrates against the dispatched bytes, not the raw request", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			const req = requestOf("y".repeat(10_000));
+			for (let i = 0; i < 30; i++) {
+				estimatePromptTokens(req, "grok", ledger);
+				// Compaction halved the prompt before dispatch; the upstream billed the half.
+				adjustPendingEstimate(req.conversationKey, req.promptBytes / 2);
+				ledger.record(entry({ conversationKey: req.conversationKey, usage: { ...EMPTY_USAGE, promptTokens: Math.round(req.promptBytes / 2 / 3.5) } }));
+			}
+			// Paired with the raw bytes this would have learned 7.0; the dispatched bytes give the true 3.5.
+			expect(ledger.tokenRatio("grok")).toBeCloseTo(3.5, 1);
+		} finally {
+			db.close();
+		}
+	});
+});
+
+describe("ledger.escalationCost", () => {
+	test("measures what escalated retries bill per prompt token, once enough exist", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			for (let i = 0; i < 9; i++) {
+				ledger.record(entry({ attempt: 1, reportedUsd: 0.02, usage: { ...EMPTY_USAGE, promptTokens: 1_000 } }));
+			}
+			expect(ledger.escalationCost?.(7)).toBeNull(); // 9 < the sample floor
+			ledger.record(entry({ attempt: 1, reportedUsd: 0.02, usage: { ...EMPTY_USAGE, promptTokens: 1_000 } }));
+			// Errored retries carry no usage and are excluded.
+			ledger.record(entry({ attempt: 1, reportedUsd: null, error: "upstream_error: boom", usage: EMPTY_USAGE }));
+			// Memoised: a fresh ledger reads through.
+			const fresh = createLedger(db, cfg);
+			const cost = fresh.escalationCost?.(7);
+			expect(cost).not.toBeNull();
+			expect(cost!.samples).toBe(10);
+			expect(cost!.usdPerPromptToken).toBeCloseTo(0.02 / 1_000, 8);
+		} finally {
+			db.close();
+		}
+	});
+});
+

package/test/trust-attribution.test.ts

@@ -244,11 +244,11 @@ describe("v4 migration", () => {
 		}
 	});
 
-	test("schema is at user_version 14", () => {
+	test("schema is at user_version 16", () => {
 		const db = openDb(":memory:");
 		try {
 			const row = db.query("PRAGMA user_version").get() as { user_version: number };
-			expect(row.user_version).toBe(14);
+			expect(row.user_version).toBe(16);
 		} finally {
 			db.close();
 		}

package/test/turn.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { createDisabledBridge } from "../src/context/bridge.ts";
 import type { ContextBridge, TurnRecord } from "../src/context/types.ts";
-import type { CatalogSource } from "../src/catalog/types.ts";
+import type { CatalogModel, 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 type {
@@ -31,6 +31,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
 		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
 		openrouter: { baseUrl: "https://openrouter.ai/api/v1", apiKey: "", title: "test", timeoutMs: 30_000, catalogTtlMs: 3_600_000, catalogRefreshMs: 0 },
+		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
 		tiers: {
 			trivial: { minQuality: 0, maxInputPerMtok: 0.3, qualityExponent: 0, pin: [] },
@@ -45,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, latencyMinSamples: 20 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator",
@@ -56,6 +57,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
+			mechanicalRetryFactor: 0.2,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {
@@ -68,11 +70,11 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			escalateOnLengthStop: false,
 			...escalation,
 		},
-		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false },
+		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false, switchHorizonTurns: 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, briefChars: 0, recordTurns: false, maxQueue: 64 },
-		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
+		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1 },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
@@ -147,6 +149,8 @@ function mkDecision(tier: Tier, slug: string, probe: Partial<ProbePlan> = {}): D
 		cacheBreakpointMessageIndices: [],
 		compactionPlan: [],
 		promptTokensSaved: 0,
+		compactionSavedBytes: 0,
+		compactionPlanTokens: 0,
 		reasoning: undefined,
 		maxTokens: undefined,
 		stripAssistantReasoning: false,
@@ -403,10 +407,13 @@ describe("runTurn", () => {
 		expect(entries[1]!.attempt).toBe(1);
 		expect(entries[1]!.slug).toBe("better/model");
 
-		// The escalated attempt re-routed one tier up.
-		expect(calls).toHaveLength(2);
+		// A refusal indicts the provider, so a same-tier sibling is probed first;
+		// this fake router only has the simple-tier decision left, which is the
+		// wrong tier, so the turn then escalates one tier up for real.
+		expect(calls).toHaveLength(3);
 		expect(calls[0]).toEqual({ attempt: 0 });
-		expect(calls[1]).toEqual({ attempt: 1, escalateFrom: "trivial" });
+		expect(calls[1]).toEqual({ attempt: 1 });
+		expect(calls[2]).toEqual({ attempt: 1, escalateFrom: "trivial" });
 
 		// The held refusal text never reached the client.
 		expect(textOut(chunks)).toBe("Here is the answer.");
@@ -729,4 +736,114 @@ describe("latency measurement covers the work the router actually does", () => {
 		expect(entries[0]?.ttftMs).not.toBeNull();
 		expect(entries[0]?.ttftMs ?? -1).toBeGreaterThanOrEqual(0);
 	});
+
+	test("a client hang-up AFTER the finish event is a completed turn, not an error", async () => {
+		// Measured live: 1,842 of 2,068 "request aborted" rows carried a finish
+		// reason and full usage — the generation had finished and the client
+		// closed before the trailing [DONE] was read. Recording that as an error
+		// skipped the state save on 12% of turns.
+		const { router } = mkRouter([mkDecision("trivial", "cheap/model", { escalateTo: "simple" })]);
+		const { upstream } = mkUpstream([
+			{
+				kind: "die",
+				chunks: [
+					startChunk("cheap/model"),
+					textChunk("all done here"),
+					finishChunk("stop"),
+					usageChunk({ promptTokens: 120, cachedTokens: 100, completionTokens: 4 }, 0.0004),
+				],
+				error: new UpstreamError("aborted", 0, "request aborted", false),
+			},
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store, map } = mkConversations();
+		const { sink, errors, finishes } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(entries).toHaveLength(1);
+		expect(entries[0]!.error).toBeNull();
+		expect(entries[0]!.wasted).toBe(false);
+		expect(entries[0]!.finishReason).toBe("stop");
+		expect(entries[0]!.reportedUsd).toBe(0.0004);
+		// The turn settled: hysteresis, cache warmth and the turn counter advance.
+		const state = map.get("conv-test")!;
+		expect(state.turn).toBe(1);
+		expect(state.currentSlug).toBe("cheap/model");
+		expect(state.cacheWarmSlug).toBe("cheap/model");
+		expect(state.lastPromptTokens).toBe(120);
+		expect(finishes).toHaveLength(1);
+	});
+
+	test("a client hang-up BEFORE the finish event is still recorded as aborted", async () => {
+		const { router } = mkRouter([mkDecision("trivial", "cheap/model", { escalateTo: "simple", maxTokens: 1 })]);
+		const { upstream } = mkUpstream([
+			{
+				kind: "die",
+				chunks: [startChunk("cheap/model"), textChunk("partial answer that committed")],
+				error: new UpstreamError("aborted", 0, "request aborted", false),
+			},
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store, map } = mkConversations();
+		const { sink, finishes } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(entries).toHaveLength(1);
+		expect(entries[0]!.error).toBe("request aborted");
+		expect(entries[0]!.finishReason).toBeNull();
+		expect(map.get("conv-test")!.turn).toBe(0);
+		expect(finishes).toHaveLength(0);
+	});
+
+
+	test("a provider that reports usage but no cost gets its actual tokens priced at the catalog rate", async () => {
+		// Ollama returns usage without `cost`. Leaving the forecast (assumed 1,024
+		// completion tokens) as the recorded figure overstated a 26-token turn ~3x.
+		const { router } = mkRouter([mkDecision("trivial", "ollama/glm-5.3-flash")]);
+		const { upstream } = mkUpstream([
+			{
+				kind: "chunks",
+				chunks: [startChunk("ollama/glm-5.3-flash"), textChunk("ok"), finishChunk("stop"), usageChunk({ promptTokens: 1_000_000, completionTokens: 1_000_000 }, null)],
+			},
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, finishes } = mkSink();
+		const priced = {
+			...catalog,
+			find: (slug: string) =>
+				slug === "ollama/glm-5.3-flash"
+					? ({
+							slug,
+							provider: "ollama",
+							canonicalSlug: slug,
+							name: slug,
+							contextLength: 1_000_000,
+							supportsTools: true,
+							supportsReasoning: true,
+							reasoningMandatory: false,
+							supportsToolChoice: false,
+							inputModalities: ["text"],
+							price: { prompt: 0.15 / 1e6, completion: 0.5 / 1e6 },
+							priceTiers: [],
+							quality: {},
+							tokenizer: "Other",
+							isFree: false,
+							createdAtMs: 0,
+							author: "ollama",
+						} satisfies CatalogModel)
+					: undefined,
+		};
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog: priced, context: createDisabledBridge() }, new AbortController().signal);
+
+		// 1M prompt tokens at $0.15/M + 1M completion tokens at $0.50/M.
+		expect(entries[0]!.reportedUsd).toBeCloseTo(0.65, 6);
+		expect(entries[0]!.priceModel?.slug).toBe("ollama/glm-5.3-flash");
+		expect(finishes[0]!.reportedUsd).toBeCloseTo(0.65, 6);
+	});
+
 });