auto-model-router 0.4.2 → 0.4.3

package/src/wire/openai/request.ts

@@ -199,6 +199,10 @@ function applyCompaction(messages: Record<string, unknown>[], edits: readonly Co
 		if (msg === undefined) continue;
 		const content = msg.content;
 		if (typeof content !== "string") continue;
+		if (edit.digest !== undefined) {
+			msg.content = edit.digest;
+			continue;
+		}
 		if (edit.mode === "stub") {
 			msg.content = `[omp-router: ${edit.note} elided to save context; re-run the tool to restore]`;
 			continue;

package/src/wire/types.ts

@@ -158,6 +158,13 @@ export interface CompactionEdit {
 	 * the edit instead of corrupting the prompt.
 	 */
 	bytes: number;
+	/**
+	 * A cheap-model digest of the original content (marker line first), set
+	 * by summarising compaction. When present it replaces the content outright
+	 * instead of the head/tail or stub breadcrumb, and persists with the plan
+	 * so the dispatched bytes stay identical turn to turn.
+	 */
+	digest?: string;
 }
 
 export type FinishReason = "stop" | "length" | "tool_calls" | "content_filter" | "error";

package/test/compaction.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import type { CompactionConfig } from "../src/config/types.ts";
-import { planCompaction, validatePlan } from "../src/router/compaction.ts";
+import { compactedBytes, planCompaction, validatePlan } from "../src/router/compaction.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 import type { NormMessage } from "../src/wire/types.ts";
 
@@ -16,7 +16,7 @@ const CFG: CompactionConfig = {
 	keepHeadBytes: 10,
 	keepTailBytes: 10,
 	elideSupersededReads: true,
-	collapseDuplicateResults: true,
+	collapseDuplicateResults: true, digestToolResults: false, digestMaxPerTurn: 2,
 };
 
 function user(text: string): NormMessage {
@@ -78,7 +78,7 @@ describe("planCompaction", () => {
 			toolMsg("c2", "read", big("V2")), // different content, same path → supersedes c1
 			...PAD,
 		];
-		const { edits } = planCompaction(msgs, { ...CFG, collapseDuplicateResults: false }, 10_000, 10_000);
+		const { edits } = planCompaction(msgs, { ...CFG, collapseDuplicateResults: false, digestToolResults: false, digestMaxPerTurn: 2, }, 10_000, 10_000);
 		expect(edits.map((e) => e.index)).toEqual([2]);
 		expect(edits[0]?.mode).toBe("stub");
 	});
@@ -270,3 +270,40 @@ describe("plan byte-stability across turns", () => {
 		expect(next.edits.filter((e) => e.index === 2)).toEqual(carried);
 	});
 });
+
+describe("summarising compaction (edit.digest)", () => {
+	const bodyWith = (messages: unknown[]): Record<string, unknown> => ({ model: "auto", messages });
+	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", () => {
+		const raw = [
+			{ role: "user", content: "go" },
+			{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: "{}" } }] },
+			{ role: "tool", tool_call_id: "c1", content: "HEAD" + "x".repeat(500) + "TAIL" },
+		];
+		const req = parseChatRequest(bodyWith(raw), new Headers());
+		for (const mode of ["truncate", "stub"] as const) {
+			const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode, keepHead: 4, keepTail: 4, note: "large read result", bytes: 508, digest: DIGEST }] });
+			expect((out.messages as { content: string }[])[2]?.content).toBe(DIGEST);
+		}
+	});
+
+	test("compactedBytes sizes a digested edit by its digest, never above the original", () => {
+		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", () => {
+		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 }));
+		expect(validatePlan(digested, msgs)[0]?.digest).toBe(DIGEST);
+		const replanned = planCompaction(msgs, CFG, 1, 10_000, validatePlan(digested, msgs));
+		expect(replanned.edits).toHaveLength(1);
+		expect(replanned.edits[0]?.digest).toBe(DIGEST);
+		// Savings count the digest's size, not the head+tail the plain edit would have kept.
+		expect(replanned.savedBytes).toBe(Buffer.byteLength(big("A")) - Buffer.byteLength(DIGEST));
+	});
+});

package/test/digest.test.ts

@@ -162,6 +162,28 @@ describe("createDigester", () => {
 		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 });

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,9 @@ 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 },

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-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/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();
+		}
+	});
+});

package/test/trust-attribution.test.ts

@@ -463,3 +463,40 @@ describe("feedback in trust", () => {
 		db.close();
 	});
 });
+
+describe("task-scoped feedback (filters.feedbackByTask)", () => {
+	test("a verdict counts only for its task type; an untasked verdict counts everywhere", () => {
+		const db = openDb(":memory:");
+		try {
+			const c = structuredClone(cfg);
+			c.filters.feedbackWeight = 3;
+			c.filters.feedbackByTask = true;
+			const ledger = createLedger(db, c);
+			const fb = createFeedbackStore(db);
+			for (let i = 0; i < 10; i++) ledger.record(entry({ error: null, task: "coding" }));
+			const prose = entry({ error: null, task: "documentation" });
+			ledger.record(prose);
+			const untasked = entry({ error: null, task: null });
+			ledger.record(untasked);
+			fb.record({ ledgerId: prose.id, ompSessionId: "s", slug: "vendor/model", tier: "simple", verdict: "bad", note: "" });
+			// 12 clean attempts, weight 3, one bad verdict on a documentation turn.
+			const pooled = (12 - 0 + 1) / (12 + 2);
+			const withBad = (15 - 3 + 1) / (15 + 2);
+			expect(ledger.trust("vendor/model", undefined, "coding")!.successRate).toBeCloseTo(pooled, 9);
+			expect(ledger.trust("vendor/model", undefined, "documentation")!.successRate).toBeCloseTo(withBad, 9);
+			// No task given (allTrust, reports): pooled behaviour, the verdict counts.
+			expect(ledger.trust("vendor/model")!.successRate).toBeCloseTo(withBad, 9);
+			expect(ledger.allTrust()[0]!.successRate).toBeCloseTo(withBad, 9);
+			// signals() honours the task the same way.
+			expect(ledger.signals?.(["vendor/model"], undefined, "coding").get("vendor/model")!.trust!.successRate).toBeCloseTo(pooled, 9);
+			// A verdict on a turn that recorded no task counts for every task.
+			fb.record({ ledgerId: untasked.id, ompSessionId: "s", slug: "vendor/model", tier: "simple", verdict: "bad", note: "" });
+			expect(ledger.trust("vendor/model", undefined, "coding")!.successRate).toBeCloseTo(withBad, 9);
+			// Off: task is ignored and every verdict pools.
+			c.filters.feedbackByTask = false;
+			expect(ledger.trust("vendor/model", undefined, "coding")!.successRate).toBeCloseTo((18 - 6 + 1) / (18 + 2), 9);
+		} finally {
+			db.close();
+		}
+	});
+});

package/test/turn.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,9 @@ 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 },
@@ -930,3 +930,68 @@ describe("latency measurement covers the work the router actually does", () => {
 	});
 
 });
+
+describe("summarising compaction in a turn", () => {
+	function reqWithTool(): NormRequest {
+		const content = "line\n".repeat(400);
+		const req = mkReq();
+		req.messages = [
+			{ role: "user", text: "fix it", images: 0, textBytes: 6, toolCalls: [] },
+			{ role: "assistant", text: "", images: 0, textBytes: 0, toolCalls: [{ id: "c1", name: "read", argsJson: '{"path":"a.ts"}' }] },
+			{ role: "tool", text: content, images: 0, textBytes: Buffer.byteLength(content), toolCalls: [], toolCallId: "c1" },
+			{ role: "user", text: "go on", images: 0, textBytes: 5, toolCalls: [] },
+		];
+		req.promptBytes = req.messages.reduce((s, m) => s + m.textBytes, 0);
+		return req;
+	}
+	function decisionWithPlan(): Decision {
+		const d = mkDecision("hard", "dear/model", { escalateTo: null });
+		d.compactionPlan = [{ index: 2, mode: "truncate", keepHead: 100, keepTail: 100, note: "large read result", bytes: 2_000 }];
+		d.compactionSavedBytes = 1_700;
+		return d;
+	}
+
+	test("new edits are digested with the turn's tier, persisted with the plan, and not paid twice on a retry", async () => {
+		const seen: { toolName: string; tier?: string; source?: string; content: string; input: Record<string, unknown> }[] = [];
+		const digester = {
+			digest: async (r: { toolName: string; tier?: string; source?: string; content: string; input: Record<string, unknown> }) => {
+				seen.push(r);
+				return { digested: true as const, text: "[digest] the file", model: "cheap/model", usd: 0.0001, inputBytes: r.content.length, outputChars: 17, ms: 5 };
+			},
+		};
+		// First attempt is probe-rejected and escalates; the second dispatches. Both decisions carry the same new edit.
+		const { router } = mkRouter([decisionWithPlan(), decisionWithPlan()]);
+		const { upstream } = mkUpstream([
+			{ kind: "chunks", chunks: [startChunk("dear/model"), textChunk("I'm sorry, but I can't help with that request."), finishChunk("stop")] },
+			{ kind: "chunks", chunks: [startChunk("dear/model"), textChunk("done"), finishChunk("stop"), usageChunk({ promptTokens: 50, completionTokens: 2 }, 0.001)] },
+		]);
+		const { ledger } = mkLedger();
+		const { store, map } = mkConversations();
+		const { sink, errors } = mkSink();
+		const cfg = mkConfig();
+		cfg.compaction.digestToolResults = true;
+		cfg.escalation.maxAttempts = 2;
+
+		await runTurn(reqWithTool(), sink, { config: cfg, router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge(), digester }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(seen).toHaveLength(1);
+		expect(seen[0]).toMatchObject({ toolName: "read", tier: "hard", source: "compaction", input: { path: "a.ts" } });
+		expect(seen[0]!.content.startsWith("line\n")).toBe(true);
+		const plan = map.get("conv-test")!.compactionPlan!;
+		expect(plan[0]?.digest).toBe("[digest] the file");
+	});
+
+	test("without compaction.digestToolResults the digester is never consulted", async () => {
+		let calls = 0;
+		const digester = { digest: async () => { calls++; return { digested: false as const, reason: "n/a" }; } };
+		const { router } = mkRouter([decisionWithPlan()]);
+		const { upstream } = mkUpstream([{ kind: "chunks", chunks: [startChunk("dear/model"), textChunk("done"), finishChunk("stop")] }]);
+		const { ledger } = mkLedger();
+		const { store, map } = mkConversations();
+		const { sink } = mkSink();
+		await runTurn(reqWithTool(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge(), digester }, new AbortController().signal);
+		expect(calls).toBe(0);
+		expect(map.get("conv-test")!.compactionPlan![0]?.digest).toBeUndefined();
+	});
+});