auto-model-router 0.4.1 → 0.4.3

package/test/controls.test.ts

@@ -236,3 +236,37 @@ describe("subagent profile", () => {
 		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
 	});
 });
+
+describe("digest endpoints", () => {
+	let handle: StartedServer;
+	let baseUrl = "";
+	beforeAll(() => {
+		const cfg: RouterConfig = {
+			...structuredClone(DEFAULT_CONFIG),
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
+			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
+			logLevel: "silent",
+		};
+		cfg.digest = { ...cfg.digest, enabled: true, minBytes: 10 };
+		handle = startServer(cfg);
+		baseUrl = `http://127.0.0.1:${handle.server.port}`;
+	});
+	afterAll(async () => {
+		await handle.stop();
+	});
+
+	test("policy reflects the config; a digest for a session with no turns is declined, a bad body rejected", async () => {
+		const policy = (await (await fetch(`${baseUrl}/v1/router/digest/policy`)).json()) as { enabled: boolean; minBytes: number; tools: string[] };
+		expect(policy.enabled).toBe(true);
+		expect(policy.minBytes).toBe(10);
+		expect(policy.tools).toContain("read");
+		const bad = await fetch(`${baseUrl}/v1/router/digest`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ toolName: "read" }) });
+		expect(bad.status).toBe(400);
+		const res = await fetch(`${baseUrl}/v1/router/digest`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ ompSessionId: "never", toolName: "read", input: {}, content: "x".repeat(100), query: "q" }),
+		});
+		expect((await res.json()) as unknown).toMatchObject({ digested: false, reason: "no routed turn in this session yet" });
+	});
+});

package/test/digest.test.ts

@@ -0,0 +1,229 @@
+import { describe, expect, test } from "bun:test";
+
+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 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";
+
+/**
+ * The tool-result digest: gates (tool, size, error, session tier, cost),
+ * model choice from the cheap tier, the marker that keeps the full output
+ * reachable, the ledger row every digest leaves, and the extension's
+ * client-side checks.
+ */
+
+const FIXTURE = (await Bun.file("test/fixtures/openrouter-models.json").json()) as { data: unknown[] };
+const MODELS: CatalogModel[] = FIXTURE.data.map(normalizeCatalogModel).filter((m): m is CatalogModel => m !== null);
+const SNAPSHOT: CatalogSnapshot = { models: MODELS, fetchedAtMs: Date.now() };
+const catalog: CatalogSource = {
+	get: async () => SNAPSHOT,
+	refresh: async () => SNAPSHOT,
+	peek: () => SNAPSHOT,
+	find: (slug) => MODELS.find((m) => m.slug === slug),
+};
+const log = createLogger("silent");
+
+function cfgWith(over: Partial<RouterConfig["digest"]> = {}): RouterConfig {
+	const cfg = structuredClone(DEFAULT_CONFIG);
+	cfg.ledger.path = ":memory:";
+	cfg.digest = { ...cfg.digest, enabled: true, minBytes: 100, ...over };
+	return cfg;
+}
+
+function seedSession(ledger: ReturnType<typeof createLedger>, tier: string): void {
+	const e: LedgerEntry = {
+		id: crypto.randomUUID(),
+		createdAtMs: Date.now(),
+		conversationKey: "k",
+		sessionId: "s",
+		turn: 3,
+		requestedModel: "auto",
+		harnessId: "",
+		ompSessionId: "omp-1",
+		slug: "x/y",
+		servedSlug: "x/y",
+		tier,
+		classificationSource: "heuristic",
+		reasons: [],
+		features: null,
+		score: null,
+		confidence: null,
+		task: null,
+		classifierReasons: null,
+		exploredFrom: null,
+		holdArm: null,
+		predictedUsd: 0.01,
+		reportedUsd: 0.01,
+		usage: { promptTokens: 100, cachedTokens: 0, cacheWriteTokens: 0, completionTokens: 10, reasoningTokens: 0, images: 0 },
+		attempt: 0,
+		escalationSignal: null,
+		latencyMs: 100,
+		ttftMs: 50,
+		finishReason: "stop",
+		wasted: false,
+		upstreamGenerationId: null,
+		error: null,
+		promptTokensSaved: 0,
+	};
+	ledger.record(e);
+}
+
+function fakeUpstream(reply: (body: Record<string, unknown>) => string, costUsd: number | null = 0.0004): { upstream: UpstreamClient; calls: Record<string, unknown>[] } {
+	const calls: Record<string, unknown>[] = [];
+	return {
+		calls,
+		upstream: {
+			dispatch: () => Promise.reject(new Error("not used")),
+			complete: async (body) => {
+				calls.push(body);
+				return { text: reply(body), costUsd };
+			},
+			fetchModels: () => Promise.resolve([]),
+			fetchModelsForUser: () => Promise.resolve([]),
+		},
+	};
+}
+
+const BIG = Array.from({ length: 400 }, (_, i) => `${i + 1}: export const value${i} = ${i};`).join("\n");
+
+describe("digestApplies", () => {
+	const d = { ...DEFAULT_CONFIG.digest, enabled: true, minBytes: 100, maxBytes: 1000 };
+	test("gates on switch, error, tool, size and session tier", () => {
+		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);
+		expect(digestApplies(d, "read", 50, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 5000, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 500, false, null).ok).toBe(false);
+		expect(digestApplies(d, "read", 500, false, "simple").ok).toBe(false); // below fromTier moderate
+		expect(digestApplies(d, "read", 500, false, "moderate").ok).toBe(true);
+		expect(digestApplies(d, "READ", 500, false, "hard").ok).toBe(true);
+	});
+});
+
+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 { 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" });
+		expect(r.digested).toBe(true);
+		if (!r.digested) return;
+		expect(r.text.startsWith("[digest: read output")).toBe(true);
+		expect(r.text).toContain("re-run read {\"path\":\"src/values.ts\"} (offset/limit for a range)");
+		expect(r.text).toContain("Omitted 380 trivial constants.");
+		expect(r.usd).toBeCloseTo(0.0004, 6);
+		// The cheap tier picked the model; the call carried the task and the raw output.
+		const call = calls[0]!;
+		expect(typeof call.model).toBe("string");
+		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");
+		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();
+	});
+
+	test("declines below the session tier, over the cost guard, when the model fails, or when nothing shrinks", async () => {
+		const db = openDb(":memory:");
+		const cfg = cfgWith();
+		const ledger = createLedger(db, cfg);
+		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 strict = cfgWith({ maxCostUsd: 0 });
+		const ledger2 = createLedger(db2, strict);
+		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");
+
+		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();
+		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);
+		// No session rows at all: the tier comes from the request.
+		const { upstream, calls } = fakeUpstream(() => "Condensed.");
+		const d = createDigester({ cfg, catalog, ledger, upstream, log });
+		const base = { ompSessionId: "omp-9", harnessId: "", toolName: "read", input: { path: "x.ts" }, content: BIG, query: "q" };
+		// digest.enabled is off, so the tool_result path declines...
+		expect(await d.digest(base)).toMatchObject({ digested: false, reason: expect.stringContaining("disabled") });
+		// ...but compaction only needs compaction.digestToolResults, plus a tier at or above fromTier.
+		expect(await d.digest({ ...base, tier: "simple", source: "compaction" })).toMatchObject({ digested: false, reason: expect.stringContaining("below digest.fromTier") });
+		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)");
+		cfg.compaction.digestToolResults = false;
+		expect(await d.digest({ ...base, tier: "hard", source: "compaction" })).toMatchObject({ digested: false });
+		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 { 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();
+	});
+});
+
+describe("digest marker and extension logic", () => {
+	test("the marker names the tool, sizes, model and how to get the full output", () => {
+		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", () => {
+		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", () => {
+		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);
+		expect(shouldSend(p, "read", true, "x".repeat(50), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(50), true)).toBe(false);
+		expect(shouldSend(p, "edit", false, "x".repeat(50), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(5), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(500), false)).toBe(false);
+		expect(parsePolicy({ enabled: false }).enabled).toBe(false);
+		expect(parsePolicy("nope").enabled).toBe(false);
+		expect(parsePolicy({ enabled: true }).minBytes).toBe(12_000);
+	});
+
+	test("digestToast is one readable line", () => {
+		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

@@ -29,7 +29,7 @@ import type { ExtensionAPI, ExtensionContext, ProviderRegistration } from "@oh-m
  */
 
 const registrations: { id: string; baseUrl: string }[] = [];
-const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => void | Promise<void>)[]>();
+const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => unknown)[]>();
 
 const pi: ExtensionAPI = {
 	setLabel: () => {},

package/test/failover.test.ts

@@ -46,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, feedbackWeight: 0, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",
@@ -74,9 +74,10 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		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, replanGrowthRatio: 1 },
+		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, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
-		report: { baselines: [] },
+		report: { baselines: [], dailySummary: false },
+		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
 		adaptiveTierFloors: true,

package/test/learned.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { auc, FEATURE_NAMES, learnedVector, predictRisk, trainLogistic, type LearnedModel } from "../src/router/learned.ts";
+import { auc, FEATURE_NAMES, LEARNED_MODEL_VERSION, learnedRiskName, learnedVector, loadLearnedModel, predictRisk, resetLearnedModels, trainLogistic, type LearnedModel } from "../src/router/learned.ts";
 
 /**
  * The learned escalation-risk model: a deterministic logistic regression that
@@ -59,3 +59,23 @@ describe("trainLogistic", () => {
 		expect(() => trainLogistic([], [])).toThrow();
 	});
 });
+
+describe("learned label", () => {
+	test("a feedback-labelled model loads with its label and names its risk p(bad)", async () => {
+		const d = FEATURE_NAMES.length;
+		const base: LearnedModel = { version: LEARNED_MODEL_VERSION, trainedAtMs: 0, rows: 100, positives: 10, names: [...FEATURE_NAMES], means: new Array(d).fill(0), stds: new Array(d).fill(1), weights: new Array(d).fill(0), bias: 0, auc: 0.5 };
+		expect(learnedRiskName(base)).toBe("escalate");
+		expect(learnedRiskName({ ...base, label: "feedback" })).toBe("bad");
+		const path = `${import.meta.dir}/../.tmp-learned-feedback.json`;
+		await Bun.write(path, JSON.stringify({ ...base, label: "feedback" }));
+		try {
+			resetLearnedModels();
+			const loaded = await loadLearnedModel(path);
+			expect(loaded?.label).toBe("feedback");
+			expect(learnedRiskName(loaded!)).toBe("bad");
+		} finally {
+			resetLearnedModels();
+			await Bun.file(path).delete();
+		}
+	});
+});

package/test/report-hub.test.ts

@@ -78,6 +78,9 @@ function report(over: Partial<UsageReport> = {}): UsageReport {
 			cacheEstimated: false,
 			subagentDispatches: 0,
 			subagentSpendUsd: 0,
+			digests: 0,
+			digestSpendUsd: 0,
+			digestInputTokens: 0,
 		},
 		providers: [row("openrouter", 2), row("ollama", 1)],
 		models: [

package/test/report-logic.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { fetchReport, parseReportArgs, renderStatus, type HealthSnapshot } from "../omp-extension/report-logic.ts";
+import { fetchReport, parseReportArgs, renderSoftFailureSpikes, renderStatus, type HealthSnapshot } from "../omp-extension/report-logic.ts";
 
 describe("parseReportArgs", () => {
 	test("defaults to 7 days scoped to the harness", () => {
@@ -71,8 +71,11 @@ describe("renderStatus", () => {
 				costBias: { configured: 0.1, effective: 0.1, biasUntilUsage: 0.9 },
 			},
 			catalog: { models: 240, ageMs: 5 * 60_000, keyScoped: true, shrink: { fromModels: 300, toModels: 120, atMs: now } },
+			softFailures: { recentMs: 3_600_000, baselineDays: 7, spikes: [{ slug: "z-ai/glm-5.3", recentDispatches: 12, recentFailures: 5, recentRate: 5 / 12, baselineDispatches: 340, baselineRate: 0.08 }] },
 		};
 		const text = renderStatus("http://127.0.0.1:8788", h, now);
+		expect(text).toContain("soft failures SPIKING (1):");
+		expect(text).toContain("  z-ai/glm-5.3: 42% of 12 failed in the last 1h (7d baseline 8% of 340)");
 		expect(text).toContain("configured (omp)");
 		expect(text).toContain("240 models");
 		expect(text).toContain("refreshed 5m ago");
@@ -86,6 +89,13 @@ describe("renderStatus", () => {
 		expect(text).toContain("recording turns");
 	});
 
+	test("reports a quiet hour and omits the line for routers that predate the check", () => {
+		expect(renderStatus("http://h", { status: "ok", softFailures: { spikes: [] } })).toContain("soft failures: no model spiking in the last hour");
+		expect(renderStatus("http://h", { status: "ok" })).not.toContain("soft failures");
+		expect(renderSoftFailureSpikes(null)).toEqual([]);
+		expect(renderSoftFailureSpikes([{ slug: "a/b", recentRate: 0.5, recentDispatches: 6 }], 30 * 60_000, 7)).toEqual(["a/b: 50% of 6 failed in the last 30m (7d baseline 0% of 0)"]);
+	});
+
 	test("degrades cleanly when sections are absent", () => {
 		const text = renderStatus("http://h", { status: "ok", apiKeyConfigured: false });
 		expect(text).toContain("key MISSING");

package/test/report.test.ts

@@ -227,6 +227,9 @@ describe("buildUsageReport", () => {
 			cacheEstimated: false,
 			subagentDispatches: 0,
 			subagentSpendUsd: 0,
+			digests: 0,
+			digestSpendUsd: 0,
+			digestInputTokens: 0,
 		});
 		expect(r.providers).toEqual([]);
 		expect(r.models).toEqual([]);

package/test/select.test.ts

@@ -637,7 +637,7 @@ describe("context compaction", () => {
 			keepHeadBytes: 20,
 			keepTailBytes: 20,
 			elideSupersededReads: true,
-			collapseDuplicateResults: true,
+			collapseDuplicateResults: true, digestToolResults: false, digestMaxPerTurn: 2,
 		},
 	};
 
@@ -954,7 +954,7 @@ describe("compaction.replanGrowthRatio (review 2026-09-05 §7)", () => {
 				keepHeadBytes: 20,
 				keepTailBytes: 20,
 				elideSupersededReads: false,
-				collapseDuplicateResults: false,
+				collapseDuplicateResults: false, digestToolResults: false, digestMaxPerTurn: 2,
 			},
 		};
 	}

package/test/summary.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, test } from "bun:test";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { createLedger } from "../src/cost/ledger.ts";
+import { buildDailySummary, countTierChanges, createKv, DAILY_SUMMARY_INTERVAL_MS, markSummaryShown, renderDailySummary, summaryDue, summaryHasNews } from "../src/cost/summary.ts";
+import type { LedgerEntry } from "../src/cost/types.ts";
+import { openDb } from "../src/util/sqlite.ts";
+import { fetchSummary } from "../omp-extension/report-logic.ts";
+
+/**
+ * The daily summary: the last 24h against the day before, top models, tier
+ * moves, the once-a-day gate in router_kv, and the text the transcript gets.
+ */
+
+const HOUR = 3_600_000;
+const NOW = Date.UTC(2026, 8, 7, 9, 0, 0);
+
+function entry(over: Partial<LedgerEntry>): LedgerEntry {
+	return {
+		id: crypto.randomUUID(),
+		createdAtMs: NOW - HOUR,
+		conversationKey: "k",
+		sessionId: "s",
+		turn: 1,
+		requestedModel: "auto",
+		harnessId: "",
+		ompSessionId: "",
+		slug: "vendor/model",
+		servedSlug: "vendor/model",
+		tier: "simple",
+		classificationSource: "heuristic",
+		reasons: [],
+		features: null,
+		score: null,
+		confidence: null,
+		task: null,
+		classifierReasons: null,
+		exploredFrom: null,
+		holdArm: null,
+		predictedUsd: 0.01,
+		reportedUsd: 0.01,
+		usage: { promptTokens: 1000, cachedTokens: 500, cacheWriteTokens: 0, completionTokens: 100, reasoningTokens: 0, images: 0 },
+		attempt: 0,
+		escalationSignal: null,
+		latencyMs: 1_100,
+		ttftMs: 100,
+		finishReason: "stop",
+		wasted: false,
+		upstreamGenerationId: null,
+		error: null,
+		promptTokensSaved: null,
+		...over,
+	} as LedgerEntry;
+}
+
+function seeded() {
+	const cfg = structuredClone(DEFAULT_CONFIG);
+	cfg.ledger.path = ":memory:";
+	const db = openDb(":memory:");
+	const ledger = createLedger(db, cfg);
+	return { db, ledger };
+}
+
+describe("buildDailySummary", () => {
+	test("compares the last 24h with the day before and names the top models and tier moves", () => {
+		const { db, ledger } = seeded();
+		try {
+			// Yesterday: one conversation climbing simple → hard, then dropping to moderate; a second model.
+			ledger.record(entry({ createdAtMs: NOW - 5 * HOUR, tier: "simple", turn: 1 }));
+			ledger.record(entry({ createdAtMs: NOW - 4 * HOUR, tier: "hard", turn: 2, slug: "vendor/big", servedSlug: "vendor/big", reportedUsd: 0.5 }));
+			ledger.record(entry({ createdAtMs: NOW - 3 * HOUR, tier: "moderate", turn: 3, escalationSignal: "empty_completion", wasted: true }));
+			ledger.record(entry({ createdAtMs: NOW - 3 * HOUR + 1, tier: "moderate", turn: 3, attempt: 1 }));
+			ledger.record(entry({ createdAtMs: NOW - 2 * HOUR, requestedModel: "digest", slug: "vendor/tiny", servedSlug: "vendor/tiny", conversationKey: "d", reportedUsd: 0.001 }));
+			// The day before: pricier.
+			for (let i = 0; i < 4; i++) ledger.record(entry({ createdAtMs: NOW - 30 * HOUR - i, conversationKey: "old", reportedUsd: 0.4 }));
+			const s = buildDailySummary(db, { nowMs: NOW, baselines: [{ slug: "anthropic/claude-opus-5", prompt: 15e-6, completion: 75e-6, cacheRead: 1.5e-6 }] });
+			expect(s.current.dispatches).toBe(5);
+			expect(s.current.spendUsd).toBeCloseTo(0.531, 6);
+			expect(s.current.escalations).toBe(1);
+			expect(s.current.digests).toBe(1);
+			expect(s.current.modelSwitches).toBe(2);
+			expect(s.previous.dispatches).toBe(4);
+			expect(s.previous.spendUsd).toBeCloseTo(1.6, 6);
+			expect(s.topModels[0]).toMatchObject({ slug: "vendor/big", dispatches: 1 });
+			expect(s.topModels[0]!.share).toBeCloseTo(0.5 / 0.531, 3);
+			expect(s.tierChanges).toEqual({ up: 1, down: 1 });
+			expect(s.baseline?.slug).toBe("anthropic/claude-opus-5");
+			expect(summaryHasNews(s)).toBe(true);
+
+			const text = renderDailySummary({ ...s, spikes: [{ slug: "vendor/big", recentDispatches: 8, recentFailures: 4, recentRate: 0.5, baselineDispatches: 90, baselineFailures: 3, baselineRate: 3 / 90 }], ollama: { plan: "pro", usedUsd: 25.2, creditsUsd: 60, runwayDays: 23.4 } });
+			expect(text).toContain("auto-model-router daily summary — last 24h (all harnesses)");
+			expect(text).toContain("spend $0.531 (prev 24h $1.60, −67%) · 5 turns · 2 conversations · $0.106/turn");
+			expect(text).toContain("cache hit 50% · 1 escalations · 0 errors · 2 model switches (1 tier up, 1 down)");
+			expect(text).toContain("top models: vendor/big $0.500 (94%, 1 turns)");
+			// Tiny seeded turns cost more than Opus would have at list price: the honest branch renders.
+			expect(text).toContain("cost 574% MORE than anthropic/claude-opus-5 ($0.079 at list)");
+			expect(renderDailySummary({ ...s, baseline: { slug: "anthropic/claude-opus-5", usd: 2.5, savedShare: 0.7876 } })).toContain("saved 79% vs anthropic/claude-opus-5 ($2.50 at list)");
+			expect(text).toContain("1 digests for $0.001");
+			expect(text).toContain("soft failures SPIKING (1):\n  vendor/big: 50% of 8 failed in the last 1h (7d baseline 3% of 90)");
+			expect(text).toContain("ollama: pro plan $25.20 of $60 · ~23 days of credits left");
+		} finally {
+			db.close();
+		}
+	});
+
+	test("an empty day renders as such and carries no news unless a model is spiking", () => {
+		const { db } = seeded();
+		try {
+			const s = buildDailySummary(db, { nowMs: NOW });
+			expect(summaryHasNews(s)).toBe(false);
+			const text = renderDailySummary(s);
+			expect(text).toContain("no routed turns in the last 24h");
+			expect(text).toContain("soft failures: no model spiking in the last hour");
+			expect(text).not.toContain("ollama:");
+			expect(summaryHasNews({ ...s, spikes: [{ slug: "a/b", recentDispatches: 5, recentFailures: 3, recentRate: 0.6, baselineDispatches: 0, baselineFailures: 0, baselineRate: 0 }] })).toBe(true);
+			expect(countTierChanges(db, 0, "")).toEqual({ up: 0, down: 0 });
+		} finally {
+			db.close();
+		}
+	});
+
+	test("harness scope narrows both windows", () => {
+		const { db, ledger } = seeded();
+		try {
+			ledger.record(entry({ harnessId: "a" }));
+			ledger.record(entry({ harnessId: "b", reportedUsd: 5 }));
+			expect(buildDailySummary(db, { nowMs: NOW, harnessId: "a" }).current).toMatchObject({ dispatches: 1, spendUsd: 0.01 });
+			expect(buildDailySummary(db, { nowMs: NOW }).current.dispatches).toBe(2);
+		} finally {
+			db.close();
+		}
+	});
+});
+
+describe("once-a-day gate", () => {
+	test("router_kv marks the summary shown per harness for 20h, surviving a reopen", () => {
+		const db = openDb(":memory:");
+		try {
+			const kv = createKv(db);
+			expect(summaryDue(kv, "", NOW)).toBe(true);
+			markSummaryShown(kv, "", NOW);
+			expect(summaryDue(kv, "", NOW + HOUR)).toBe(false);
+			expect(summaryDue(kv, "other", NOW + HOUR)).toBe(true);
+			expect(summaryDue(kv, "", NOW + DAILY_SUMMARY_INTERVAL_MS)).toBe(true);
+			// Same table, fresh handle: the marker is durable.
+			expect(summaryDue(createKv(db), "", NOW + HOUR)).toBe(false);
+			kv.set("k", "v1");
+			kv.set("k", "v2");
+			expect(kv.get("k")).toBe("v2");
+			expect(kv.get("missing")).toBeNull();
+		} finally {
+			db.close();
+		}
+	});
+});
+
+describe("fetchSummary", () => {
+	test("passes harness and auto through and surfaces the router's verdict", async () => {
+		const calls: string[] = [];
+		const fetchImpl = async (url: string): Promise<Response> => {
+			calls.push(url);
+			return new Response(JSON.stringify({ due: false, reason: "posted in the last 20h", summary: null }), { status: 200 });
+		};
+		const r = await fetchSummary("http://h", "omp", true, {}, fetchImpl);
+		expect(r).toEqual({ due: false, reason: "posted in the last 20h", summary: null });
+		expect(calls).toEqual(["http://h/v1/router/summary?harness=omp&auto=1"]);
+		await fetchSummary("http://h", "", false, {}, fetchImpl);
+		expect(calls[1]).toBe("http://h/v1/router/summary");
+		await expect(fetchSummary("http://h", "", false, {}, async () => new Response("no", { status: 503 }))).rejects.toThrow("router returned 503");
+	});
+});

package/test/tokens.test.ts

@@ -237,3 +237,47 @@ describe("ledger.escalationCost", () => {
 	});
 });
 
+
+describe("ledger.softFailureSpikes", () => {
+	test("flags a model whose last-hour failure rate is a spike against its own 7-day baseline", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			const now = 1_800_000_000_000;
+			const H = 3_600_000;
+			// Baseline: 100 dispatches over the prior week at 5% soft failures.
+			for (let i = 0; i < 100; i++) {
+				ledger.record(entry({ createdAtMs: now - 2 * H - i * 60 * 60_000, escalationSignal: i % 20 === 0 ? "empty_completion" : null, wasted: i % 20 === 0 }));
+			}
+			// Last hour: 10 dispatches, 4 soft failures (40%): a spike.
+			for (let i = 0; i < 10; i++) {
+				ledger.record(entry({ createdAtMs: now - 5 * 60_000 - i * 60_000, escalationSignal: i < 4 ? "repeat_tool_call" : null, wasted: i < 4 }));
+			}
+			// A second model with plenty of failures but a matching baseline is not spiking.
+			for (let i = 0; i < 100; i++) {
+				ledger.record(entry({ slug: "x/steady", servedSlug: "x/steady", createdAtMs: now - 2 * H - i * 60 * 60_000, error: i % 2 === 0 ? "upstream_error: 502" : null }));
+			}
+			for (let i = 0; i < 10; i++) {
+				ledger.record(entry({ slug: "x/steady", servedSlug: "x/steady", createdAtMs: now - 5 * 60_000 - i * 60_000, error: i % 2 === 0 ? "upstream_error: 502" : null }));
+			}
+			// Aborted and quota errors are not attributable; digest rows are side calls.
+			for (let i = 0; i < 10; i++) {
+				ledger.record(entry({ slug: "x/aborted", servedSlug: "x/aborted", createdAtMs: now - 5 * 60_000 - i * 60_000, error: "aborted: client closed" }));
+				ledger.record(entry({ slug: "x/digest", servedSlug: "x/digest", requestedModel: "digest", createdAtMs: now - 5 * 60_000 - i * 60_000, error: "upstream_error: 500" }));
+			}
+			const spikes = ledger.softFailureSpikes?.(now) ?? [];
+			expect(spikes.map((s) => s.slug)).toEqual(["openai/gpt-5-mini"]);
+			const s = spikes[0]!;
+			expect(s.recentDispatches).toBe(10);
+			expect(s.recentFailures).toBe(4);
+			expect(s.recentRate).toBeCloseTo(0.4, 6);
+			expect(s.baselineDispatches).toBe(100);
+			expect(s.baselineFailures).toBe(5);
+			expect(s.baselineRate).toBeCloseTo(0.05, 6);
+			// Too few recent dispatches: nothing spikes, however high the rate.
+			expect(ledger.softFailureSpikes?.(now, 3 * 60_000)).toEqual([]);
+		} finally {
+			db.close();
+		}
+	});
+});