auto-model-router 0.4.2 → 0.4.3

package/src/cost/summary.ts

@@ -0,0 +1,231 @@
+/**
+ * The daily summary: what the router did in the last 24 hours, in a few
+ * lines. Posted into the transcript once a day at omp session start
+ * (`report.dailySummary`) and on demand via `/router summary` or
+ * `GET /v1/router/summary`.
+ *
+ * Built from the same `buildUsageReport` the report hub uses, over a 1-day
+ * window, with the preceding day for comparison, plus the two live signals the
+ * report cannot carry: soft-failure spikes (the last hour) and the Ollama
+ * meter. The once-a-day gate is a marker in `router_kv`, keyed per harness, so
+ * several omp windows on one router share it and a restart does not repeat it.
+ */
+
+import type { Database } from "bun:sqlite";
+import { TIER_ORDER } from "../router/types.ts";
+import { buildUsageReport, type BaselinePrice, type BaselineRow, type UsageReport } from "./report.ts";
+import type { SoftFailureSpike } from "./types.ts";
+
+/** One 24-hour window's headline numbers. */
+export interface SummaryWindow {
+	spendUsd: number;
+	dispatches: number;
+	conversations: number;
+	cacheHitRate: number;
+	cacheEstimated: boolean;
+	escalations: number;
+	errors: number;
+	modelSwitches: number;
+	digests: number;
+	digestSpendUsd: number;
+	subagentSpendUsd: number;
+}
+
+export interface SummaryModel {
+	slug: string;
+	spendUsd: number;
+	share: number;
+	dispatches: number;
+}
+
+export interface SummaryOllama {
+	plan: string | null;
+	usedUsd: number;
+	creditsUsd: number;
+	/** Days of credits left at the recent burn; null when the burn is zero. */
+	runwayDays: number | null;
+}
+
+export interface DailySummary {
+	generatedAtMs: number;
+	sinceMs: number;
+	/** Empty ⇒ every harness. */
+	harnessId: string;
+	current: SummaryWindow;
+	/** The 24 hours before `sinceMs`. */
+	previous: SummaryWindow;
+	/** Top models by spend in the current window. */
+	topModels: SummaryModel[];
+	/** Tier moves between consecutive kept turns of one conversation. */
+	tierChanges: { up: number; down: number };
+	/** The first configured baseline the catalog knew, when any. */
+	baseline: BaselineRow | null;
+	spikes: SoftFailureSpike[];
+	ollama: SummaryOllama | null;
+}
+
+const DAY_MS = 86_400_000;
+/** How many top models the summary names. */
+const TOP_MODELS = 3;
+
+function windowOf(r: UsageReport): SummaryWindow {
+	const t = r.totals;
+	return {
+		spendUsd: t.spendUsd,
+		dispatches: t.dispatches,
+		conversations: t.conversations,
+		cacheHitRate: t.cacheHitRate,
+		cacheEstimated: t.cacheEstimated,
+		escalations: t.escalations,
+		errors: t.errors,
+		modelSwitches: t.modelSwitches,
+		digests: t.digests,
+		digestSpendUsd: t.digestSpendUsd,
+		subagentSpendUsd: t.subagentSpendUsd,
+	};
+}
+
+/** Counts tier moves up and down between consecutive kept turns of each conversation since `sinceMs`. */
+export function countTierChanges(db: Database, sinceMs: number, harnessId: string): { up: number; down: number } {
+	const where = harnessId === "" ? "created_at_ms >= $since" : "created_at_ms >= $since AND harness_id = $harness";
+	const bind = harnessId === "" ? { $since: sinceMs } : { $since: sinceMs, $harness: harnessId };
+	const seq = db
+		.query(`SELECT conversation_key AS ck, tier FROM ledger WHERE ${where} AND wasted = 0 AND requested_model <> 'digest' ORDER BY conversation_key, created_at_ms`)
+		.all(bind) as { ck: string; tier: string }[];
+	let up = 0;
+	let down = 0;
+	for (let i = 1; i < seq.length; i++) {
+		const a = seq[i - 1]!;
+		const b = seq[i]!;
+		if (a.ck !== b.ck) continue;
+		const ra = TIER_ORDER.indexOf(a.tier as (typeof TIER_ORDER)[number]);
+		const rb = TIER_ORDER.indexOf(b.tier as (typeof TIER_ORDER)[number]);
+		if (ra < 0 || rb < 0 || ra === rb) continue;
+		if (rb > ra) up++;
+		else down++;
+	}
+	return { up, down };
+}
+
+export function buildDailySummary(
+	db: Database,
+	opts: {
+		harnessId?: string;
+		nowMs?: number;
+		baselines?: readonly BaselinePrice[];
+		spikes?: readonly SoftFailureSpike[];
+		ollama?: SummaryOllama | null;
+	} = {},
+): DailySummary {
+	const nowMs = opts.nowMs ?? Date.now();
+	const harnessId = opts.harnessId ?? "";
+	const baselines = opts.baselines ?? [];
+	const current = buildUsageReport(db, { windowDays: 1, harnessId, nowMs, baselines });
+	const previous = buildUsageReport(db, { windowDays: 1, harnessId, nowMs: nowMs - DAY_MS, untilMs: current.sinceMs });
+	return {
+		generatedAtMs: nowMs,
+		sinceMs: current.sinceMs,
+		harnessId,
+		current: windowOf(current),
+		previous: windowOf(previous),
+		topModels: current.models.slice(0, TOP_MODELS).map((m) => ({ slug: m.key, spendUsd: m.spendUsd, share: m.share, dispatches: m.dispatches })),
+		tierChanges: countTierChanges(db, current.sinceMs, harnessId),
+		baseline: current.baselines[0] ?? null,
+		spikes: [...(opts.spikes ?? [])],
+		ollama: opts.ollama ?? null,
+	};
+}
+
+/** Whether the once-a-day auto summary is worth posting: something happened, or something is wrong. */
+export function summaryHasNews(s: DailySummary): boolean {
+	return s.current.dispatches > 0 || s.spikes.length > 0;
+}
+
+const usd = (v: number): string => (v >= 100 ? `$${v.toFixed(0)}` : v >= 1 ? `$${v.toFixed(2)}` : `$${v.toFixed(3)}`);
+const pct = (v: number, estimated = false): string => `${estimated ? "~" : ""}${Math.round(v * 100)}%`;
+
+function delta(current: number, previous: number): string {
+	if (previous <= 0) return current > 0 ? " (prev 24h: none)" : "";
+	const change = (current - previous) / previous;
+	const sign = change >= 0 ? "+" : "−";
+	return ` (prev 24h ${usd(previous)}, ${sign}${Math.round(Math.abs(change) * 100)}%)`;
+}
+
+/** Renders the summary as a few plain lines for the transcript. */
+export function renderDailySummary(s: DailySummary): string {
+	const scope = s.harnessId === "" ? "all harnesses" : `harness ${s.harnessId}`;
+	const out: string[] = [`auto-model-router daily summary — last 24h (${scope})`];
+	const c = s.current;
+	if (c.dispatches === 0) {
+		out.push("no routed turns in the last 24h");
+	} else {
+		out.push(
+			`spend ${usd(c.spendUsd)}${delta(c.spendUsd, s.previous.spendUsd)} · ${c.dispatches} turns · ${c.conversations} conversations · ${usd(c.spendUsd / c.dispatches)}/turn`,
+		);
+		const moves = c.modelSwitches > 0 ? ` (${s.tierChanges.up} tier up, ${s.tierChanges.down} down)` : "";
+		out.push(`cache hit ${pct(c.cacheHitRate, c.cacheEstimated)} · ${c.escalations} escalations · ${c.errors} errors · ${c.modelSwitches} model switches${moves}`);
+		if (s.topModels.length > 0) {
+			out.push(`top models: ${s.topModels.map((m) => `${m.slug} ${usd(m.spendUsd)} (${pct(m.share)}, ${m.dispatches} turns)`).join(" · ")}`);
+		}
+		if (s.baseline !== null && s.baseline.usd > 0) {
+			const b = s.baseline;
+			out.push(b.savedShare >= 0 ? `saved ${pct(b.savedShare)} vs ${b.slug} (${usd(b.usd)} at list)` : `cost ${pct(-b.savedShare)} MORE than ${b.slug} (${usd(b.usd)} at list)`);
+		}
+		const extras: string[] = [];
+		if (c.digests > 0) extras.push(`${c.digests} digests for ${usd(c.digestSpendUsd)}`);
+		if (c.subagentSpendUsd > 0) extras.push(`subagents ${usd(c.subagentSpendUsd)}`);
+		if (extras.length > 0) out.push(extras.join(" · "));
+	}
+	if (s.spikes.length === 0) out.push("soft failures: no model spiking in the last hour");
+	else {
+		out.push(`soft failures SPIKING (${s.spikes.length}):`);
+		for (const sp of s.spikes) {
+			out.push(`  ${sp.slug}: ${pct(sp.recentRate)} of ${sp.recentDispatches} failed in the last 1h (7d baseline ${pct(sp.baselineRate)} of ${sp.baselineDispatches})`);
+		}
+	}
+	const o = s.ollama;
+	if (o !== null) {
+		const runway = o.runwayDays === null ? "" : ` · ~${Math.round(o.runwayDays)} days of credits left`;
+		out.push(`ollama: ${o.plan === null ? "plan" : `${o.plan} plan`} $${o.usedUsd.toFixed(2)} of $${o.creditsUsd}${runway}`);
+	}
+	return out.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Once-a-day gate
+// ---------------------------------------------------------------------------
+
+/** A summary posted less than this long ago is not due again. */
+export const DAILY_SUMMARY_INTERVAL_MS = 20 * 3_600_000;
+
+export interface KeyValueStore {
+	get(key: string): string | null;
+	set(key: string, value: string): void;
+}
+
+/** A tiny durable key/value store over the `router_kv` table. */
+export function createKv(db: Database): KeyValueStore {
+	const getStmt = db.query("SELECT value FROM router_kv WHERE key = $key");
+	const setStmt = db.query("INSERT INTO router_kv (key, value, updated_at_ms) VALUES ($key, $value, $at) ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at_ms = excluded.updated_at_ms");
+	return {
+		get(key) {
+			const row = getStmt.get({ $key: key }) as { value: string } | null;
+			return row === null ? null : row.value;
+		},
+		set(key, value) {
+			setStmt.run({ $key: key, $value: value, $at: Date.now() });
+		},
+	};
+}
+
+const shownKey = (harnessId: string): string => `daily_summary_shown:${harnessId}`;
+
+/** True when no auto summary has been posted for this harness within the interval. */
+export function summaryDue(kv: KeyValueStore, harnessId: string, nowMs = Date.now()): boolean {
+	const last = Number(kv.get(shownKey(harnessId)) ?? "0");
+	return !(Number.isFinite(last) && nowMs - last < DAILY_SUMMARY_INTERVAL_MS);
+}
+
+export function markSummaryShown(kv: KeyValueStore, harnessId: string, nowMs = Date.now()): void {
+	kv.set(shownKey(harnessId), String(nowMs));
+}

package/src/cost/types.ts

@@ -230,6 +230,25 @@ export interface EscalationCost {
 	windowDays: number;
 }
 
+/**
+ * A model whose recent failure rate (probe rejections OpenRouter counts as
+ * success, plus attributable transport errors) is well above its own
+ * baseline. Visibility only: the ledger data showed soft failures do not
+ * cluster tightly enough for a breaker to save money, so the router reports
+ * spikes (/health, /router status, the daily summary) rather than acting.
+ */
+export interface SoftFailureSpike {
+	slug: string;
+	/** Dispatches and failures in the recent window. */
+	recentDispatches: number;
+	recentFailures: number;
+	recentRate: number;
+	/** The same, over the baseline window (recent window excluded). */
+	baselineDispatches: number;
+	baselineFailures: number;
+	baselineRate: number;
+}
+
 export interface Ledger {
 	record(entry: LedgerEntry): void;
 	/** Total reported (or predicted, when reported is null) spend for a conversation. */
@@ -240,8 +259,12 @@ export interface Ledger {
 	 */
 	spendSince(sinceMs: number, harnessId?: string): number;
 	blendedRate(windowDays: number): BlendedRate | null;
-	/** Per-model reliability over the ledger, optionally scoped to a harness. */
-	trust(slug: string, harnessId?: string): ModelTrust | null;
+	/**
+	 * Per-model reliability over the ledger, optionally scoped to a harness.
+	 * `task` (with `filters.feedbackByTask`) counts only verdicts given on
+	 * turns of that task type, plus verdicts on turns with no recorded task.
+	 */
+	trust(slug: string, harnessId?: string, task?: string): ModelTrust | null;
 	allTrust(): ModelTrust[];
 	/**
 	 * Per-model responsiveness (mean TTFT + completion throughput), optionally
@@ -251,7 +274,7 @@ export interface Ledger {
 	 */
 	latency(slug: string, harnessId?: string): ModelLatency | null;
 	/** Batch trust and latency for one candidate set; one query per signal kind. Optional — callers can fall back to per-slug calls. */
-	signals?(slugs: readonly string[], harnessId?: string): Map<string, LedgerSignals>;
+	signals?(slugs: readonly string[], harnessId?: string, task?: string): Map<string, LedgerSignals>;
 	/**
 	 * What an escalated retry actually bills per prompt token, measured over
 	 * the last `windowDays` of attempt > 0 rows. Null until enough escalated
@@ -271,6 +294,11 @@ export interface Ledger {
 	recentEntries(limit: number): LedgerEntry[];
 	/** Spend since an instant on slugs with a prefix (`ollama/`), for provider-level reconciliation. Optional. */
 	providerSpendSince?(slugPrefix: string, sinceMs: number): number;
+	/**
+	 * Models whose soft-failure rate over the last `recentMs` is a spike against
+	 * their own rate over the preceding `baselineMs`. Optional; visibility only.
+	 */
+	softFailureSpikes?(nowMs?: number, recentMs?: number, baselineMs?: number): SoftFailureSpike[];
 	/** Newest kept (non-wasted) entry for an omp session, for /router why and feedback. Optional so fakes need not implement it. */
 	latestForSession?(ompSessionId: string): LedgerEntry | null;
 	/** Newest entries for an omp session, newest first. Optional. */

package/src/router/candidates.ts

@@ -263,7 +263,7 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 		const signals = args.signals;
 		const trust =
 			signals?.get(slug)?.trust ??
-			ledger?.trust(slug, filters.trustScopedByHarness ? req.harnessId : undefined) ??
+			ledger?.trust(slug, filters.trustScopedByHarness ? req.harnessId : undefined, filters.feedbackByTask ? task : undefined) ??
 			null;
 		if (!relaxTrust && trust !== null && trust.attempts >= filters.minTrustSamples && trust.successRate < filters.minTrust) {
 			rejected.push({

package/src/router/classify.ts

@@ -10,7 +10,7 @@ import type { Ledger } from "../cost/types.ts";
 import { estimateTokens } from "../tokens/estimate.ts";
 import type { UpstreamClient } from "../upstream/types.ts";
 import { sha256Hex } from "../util/hash.ts";
-import { loadLearnedModel, predictRisk } from "./learned.ts";
+import { learnedRiskName, loadLearnedModel, predictRisk } from "./learned.ts";
 import type { NormRequest, ReasoningLevel } from "../wire/types.ts";
 import type { Classification, Features, TaskType, Tier } from "./types.ts";
 
@@ -313,7 +313,7 @@ export async function classify(
 		if (model !== null) {
 			const risk = predictRisk(model, f);
 			heuristic.learnedRisk = risk;
-			heuristic.reasons.push(`learned: p(escalate)=${risk.toFixed(3)}`);
+			heuristic.reasons.push(`learned: p(${learnedRiskName(model)})=${risk.toFixed(3)}`);
 		}
 	}
 	if (cc.ambiguityThreshold <= 0 || heuristic.confidence >= cc.ambiguityThreshold) return heuristic;

package/src/router/compaction.ts

@@ -33,6 +33,7 @@ const BREADCRUMB_BYTES = 120;
  */
 export function compactedBytes(originalBytes: number, edit: CompactionEdit | undefined): number {
 	if (edit === undefined) return originalBytes;
+	if (edit.digest !== undefined) return Math.min(originalBytes, Buffer.byteLength(edit.digest));
 	const kept = edit.mode === "stub" ? BREADCRUMB_BYTES : edit.keepHead + edit.keepTail + BREADCRUMB_BYTES;
 	return Math.min(originalBytes, kept);
 }

package/src/router/learned.ts

@@ -77,8 +77,13 @@ export function learnedVector(f: Partial<Features>): number[] {
 	];
 }
 
+/** What a learned model's positive class means. */
+export type LearnedLabel = "escalation" | "feedback";
+
 export interface LearnedModel {
 	version: number;
+	/** Positive class: the turn escalated (default), or the user judged it bad. */
+	label?: LearnedLabel;
 	trainedAtMs: number;
 	rows: number;
 	positives: number;
@@ -93,7 +98,12 @@ export interface LearnedModel {
 
 const sigmoid = (z: number): number => 1 / (1 + Math.exp(-z));
 
-/** P(escalate) for one turn under a model. */
+/** The positive-class name a decision reason should print for a model. */
+export function learnedRiskName(model: LearnedModel): string {
+	return model.label === "feedback" ? "bad" : "escalate";
+}
+
+/** P(positive class) for one turn under a model: p(escalate), or p(bad) for a feedback-labelled model. */
 export function predictRisk(model: LearnedModel, f: Partial<Features>): number {
 	const x = learnedVector(f);
 	let z = model.bias;

package/src/router/select.ts

@@ -361,7 +361,11 @@ export function select(args: SelectArgs): Decision {
 	// query per signal kind, instead of per-model individual lookups.
 	const candidateSignals =
 		ledger !== null && snapshot.models.length > 0
-			? ledger.signals?.(snapshot.models.map((m) => m.slug), cfg.filters.trustScopedByHarness ? req.harnessId : undefined)
+			? ledger.signals?.(
+					snapshot.models.map((m) => m.slug),
+					cfg.filters.trustScopedByHarness ? req.harnessId : undefined,
+					cfg.filters.feedbackByTask ? classification.task : undefined,
+				)
 			: undefined;
 	// What an escalated retry has actually been billing per prompt token, for
 	// the escalation-cost term in candidate scoring. Read once per turn; null

package/src/server/compaction-digest.ts

@@ -0,0 +1,127 @@
+/**
+ * Summarising compaction: when the compaction plan gains new edits, a cheap
+ * model digests the tool results those edits would otherwise truncate or stub,
+ * and the digest rides in the persisted plan in place of the breadcrumb.
+ *
+ * Plain compaction keeps a head and a tail of a stale tool result; a digest
+ * keeps what the task needs from all of it (paths, identifiers, errors, the
+ * code the agent will edit) in a few hundred chars. The digest is stored on
+ * the edit, so the bytes sent stay identical on every later turn until the
+ * plan changes — the same byte-stability plain edits have, which is what keeps
+ * the prompt cache warm.
+ *
+ * Bounded: at most `compaction.digestMaxPerTurn` digests per turn, each under
+ * the digest's own cost guard and timeout, largest results first. A digest
+ * that fails or declines leaves the plain edit in place; nothing is lost.
+ */
+
+import type { RouterConfig } from "../config/types.ts";
+import { compactedBytes } from "../router/compaction.ts";
+import type { Logger } from "../util/log.ts";
+import type { CompactionEdit, NormRequest } from "../wire/types.ts";
+import type { DigestRequest, DigestResult } from "./digest.ts";
+
+export interface CompactionDigester {
+	digest(req: DigestRequest): Promise<DigestResult>;
+}
+
+export interface DigestCompactionArgs {
+	req: NormRequest;
+	/** The plan this turn dispatches with; edits gain `digest` in place. */
+	plan: CompactionEdit[];
+	/** The tier this turn routed to: the digest pays off only above `digest.fromTier`. */
+	tier: string;
+	cfg: RouterConfig;
+	digester: CompactionDigester;
+	/** Per-turn memo (index:bytes → digest) so a retry does not pay twice. */
+	memo: Map<string, string>;
+	/** The user's current ask, steering what the digest keeps. */
+	query: string;
+	log: Logger;
+}
+
+/** Tool name and parsed arguments for a tool-result message, via its call id. */
+function toolOf(req: NormRequest, index: number): { name: string; input: Record<string, unknown> } | null {
+	const m = req.messages[index];
+	if (m === undefined || m.role !== "tool") return null;
+	let name = m.toolName ?? "";
+	let input: Record<string, unknown> = {};
+	if (m.toolCallId !== undefined) {
+		for (const a of req.messages) {
+			if (a.role !== "assistant") continue;
+			const tc = a.toolCalls.find((c) => c.id === m.toolCallId);
+			if (tc === undefined) continue;
+			if (name === "") name = tc.name;
+			try {
+				const parsed: unknown = JSON.parse(tc.argsJson);
+				if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) input = parsed as Record<string, unknown>;
+			} catch {
+				// Unparseable args: the marker just names the tool.
+			}
+			break;
+		}
+	}
+	return name === "" ? null : { name, input };
+}
+
+/**
+ * Digests the plan's new (undigested) edits, largest first, up to the per-turn
+ * cap. Returns the change in bytes saved versus the plain edits: positive when
+ * the digests are smaller than what truncation would have kept, negative when
+ * a digest keeps more than head+tail did (it usually does, and that is the point).
+ */
+export async function digestCompactionEdits(args: DigestCompactionArgs): Promise<number> {
+	const { req, plan, tier, cfg, digester, memo, query, log } = args;
+	const max = cfg.compaction.digestMaxPerTurn;
+	if (max <= 0) return 0;
+	const pending = plan.filter((e) => e.digest === undefined).sort((a, b) => b.bytes - a.bytes);
+	let delta = 0;
+	const work: CompactionEdit[] = [];
+	for (const e of pending) {
+		const key = `${e.index}:${e.bytes}`;
+		const remembered = memo.get(key);
+		if (remembered !== undefined) {
+			delta += compactedBytes(e.bytes, e) - Buffer.byteLength(remembered);
+			e.digest = remembered;
+			continue;
+		}
+		if (work.length >= max) break;
+		work.push(e);
+	}
+	if (work.length === 0) return delta;
+
+	const results = await Promise.all(
+		work.map(async (e): Promise<{ edit: CompactionEdit; result: DigestResult }> => {
+			const tool = toolOf(req, e.index);
+			const m = req.messages[e.index];
+			if (tool === null || m === undefined) return { edit: e, result: { digested: false, reason: "tool result has no tool name" } };
+			try {
+				const result = await digester.digest({
+					ompSessionId: req.ompSessionId,
+					harnessId: req.harnessId,
+					toolName: tool.name,
+					input: tool.input,
+					content: m.text,
+					query,
+					tier,
+					source: "compaction",
+				});
+				return { edit: e, result };
+			} catch (err) {
+				return { edit: e, result: { digested: false, reason: err instanceof Error ? err.message : String(err) } };
+			}
+		}),
+	);
+	for (const { edit, result } of results) {
+		if (!result.digested) {
+			log.debug("compaction digest declined", { index: edit.index, bytes: edit.bytes, reason: result.reason });
+			continue;
+		}
+		const plain = compactedBytes(edit.bytes, edit);
+		edit.digest = result.text;
+		memo.set(`${edit.index}:${edit.bytes}`, result.text);
+		delta += plain - Buffer.byteLength(result.text);
+		log.info("compaction digest", { index: edit.index, bytes: edit.bytes, chars: result.outputChars, model: result.model, usd: result.usd });
+	}
+	return delta;
+}

package/src/server/digest.ts

@@ -39,6 +39,14 @@ export interface DigestRequest {
 	content: string;
 	/** The user's current ask, so the digest keeps what matters for it. */
 	query: string;
+	/** The tier to judge `digest.fromTier` against; default: the session's last routed tier. */
+	tier?: string;
+	/**
+	 * Who asked. `tool_result` (default) is the omp extension and is gated on
+	 * `digest.enabled`; `compaction` is summarising compaction inside a turn
+	 * and is gated on `compaction.digestToolResults` instead.
+	 */
+	source?: "tool_result" | "compaction";
 }
 
 export type DigestResult =
@@ -129,8 +137,10 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 	return {
 		async digest(req) {
 			const inputBytes = Buffer.byteLength(req.content);
-			const currentTier = ledger.latestForSession?.(req.ompSessionId)?.tier ?? null;
-			const applies = digestApplies(cfg.digest, req.toolName, inputBytes, false, currentTier);
+			const source = req.source ?? "tool_result";
+			const currentTier = req.tier ?? ledger.latestForSession?.(req.ompSessionId)?.tier ?? null;
+			const gate = source === "compaction" ? { ...cfg.digest, enabled: cfg.compaction.digestToolResults } : cfg.digest;
+			const applies = digestApplies(gate, req.toolName, inputBytes, false, currentTier);
 			if (!applies.ok) return { digested: false, reason: applies.reason };
 
 			const promptText = `Task: ${req.query === "" ? "(unknown)" : req.query}\nTool: ${req.toolName} ${JSON.stringify(req.input)}\n--- output ---\n${req.content}`;
@@ -190,7 +200,7 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 				servedSlug: model.slug,
 				tier: cfg.digest.tier,
 				classificationSource: "forced",
-				reasons: [`digest: ${req.toolName} ${inputBytes} bytes → ${text.length} chars for a ${currentTier} session`],
+				reasons: [`digest (${source}): ${req.toolName} ${inputBytes} bytes → ${text.length} chars for a ${currentTier} ${source === "compaction" ? "turn" : "session"}`],
 				features: null,
 				score: null,
 				confidence: null,

package/src/server/http.ts

@@ -9,6 +9,7 @@ import { createSessionOverrides } from "./overrides.ts";
 import { createDigester } from "./digest.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport } from "../cost/report.ts";
+import { buildDailySummary, createKv, markSummaryShown, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
 import { createRouter } from "../router/index.ts";
 import { createConversationStore } from "../router/state.ts";
@@ -195,8 +196,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	const context = createBridgeFromConfig(cfg, db);
 	const overrides = createSessionOverrides();
 	const feedback = createFeedbackStore(db);
+	const kv = createKv(db);
 	const digester = createDigester({ cfg, catalog, ledger, upstream, log });
-	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context, overrides, ollamaCostScale };
+	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context, overrides, ollamaCostScale, digester };
 
 	// Hot reload: ranking knobs (tiers, filters, escalation, budgets, …) take
 	// effect on the next turn without a restart, because every consumer reads
@@ -398,6 +400,29 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					const harnessId = url.searchParams.get("harness") ?? "";
 					return json(buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) }));
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/summary") {
+					// The last 24 hours in a few lines. `auto=1` is the session-start
+					// caller: it gets `due: false` unless report.dailySummary is on, no
+					// summary was posted for this harness in the last 20h, and there is
+					// something to say; posting is then marked so other windows skip it.
+					const harnessId = url.searchParams.get("harness") ?? "";
+					const auto = url.searchParams.get("auto") === "1";
+					if (auto && !cfg.report.dailySummary) return json({ due: false, reason: "report.dailySummary is off", summary: null });
+					if (auto && !summaryDue(kv, harnessId)) return json({ due: false, reason: "posted in the last 20h", summary: null });
+					const meter = ollamaMeter(ollamaUsage.peek(), cfg.ollama.planCreditsUsd);
+					const runway = ollamaRunway(meter, ledger.providerSpendSince?.("ollama/", Date.now() - 7 * 86_400_000) ?? 0, ollamaUsage.calibration()?.factor ?? 1);
+					const ollamaSummary: SummaryOllama | null =
+						ollama === null || meter === null ? null : { plan: meter.plan ?? null, usedUsd: meter.usedUsd, creditsUsd: meter.creditsUsd, runwayDays: runway?.days ?? null };
+					const summary = buildDailySummary(db, {
+						harnessId,
+						baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)),
+						spikes: ledger.softFailureSpikes?.() ?? [],
+						ollama: ollamaSummary,
+					});
+					if (auto && !summaryHasNews(summary)) return json({ due: false, reason: "nothing to report", summary: null });
+					if (auto) markSummaryShown(kv, harnessId);
+					return json({ due: true, summary });
+				}
 				if (req.method === "GET" && url.pathname === "/v1/router/decisions") {
 					const rawLimit = url.searchParams.get("limit");
 					const parsed = rawLimit === null ? 50 : Number.parseInt(rawLimit, 10);
@@ -514,6 +539,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 										runway: ollamaRunway(ollamaMeter(ollamaUsage.peek(), cfg.ollama.planCreditsUsd), ledger.providerSpendSince?.("ollama/", Date.now() - 7 * 86_400_000) ?? 0, ollamaUsage.calibration()?.factor ?? 1),
 										costBias: { configured: cfg.ollama.costBias, effective: catalog.ollamaBias?.() ?? cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage },
 									},
+						// Models failing well above their own baseline in the last hour.
+						// Visibility only: nothing routes around a spike.
+						softFailures: { recentMs: 3_600_000, baselineDays: 7, spikes: ledger.softFailureSpikes?.() ?? [] },
 						catalog: snap === null
 							? null
 							: {

package/src/server/turn.ts

@@ -28,6 +28,7 @@ import {
 } from "../router/types.ts";
 import { UpstreamError, type Dispatch, type UpstreamClient } from "../upstream/types.ts";
 import type { SessionOverrides } from "./overrides.ts";
+import { digestCompactionEdits, type CompactionDigester } from "./compaction-digest.ts";
 import { createLogger } from "../util/log.ts";
 import type { NormRequest, ResponseSink, TurnSummary, UpstreamChunk } from "../wire/types.ts";
 
@@ -71,6 +72,8 @@ export interface TurnDeps {
 	overrides?: SessionOverrides;
 	/** Ledger-vs-meter calibration for Ollama's estimated costs; absent ⇒ 1. */
 	ollamaCostScale?: () => number;
+	/** Cheap-model digester for summarising compaction (`compaction.digestToolResults`). Absent ⇒ plain edits. */
+	digester?: CompactionDigester;
 }
 
 /** A dead client connection surfaces as the sink throwing mid-stream. */
@@ -135,6 +138,8 @@ export async function runTurn(
 	// A failover decision already routed inside onUpstreamError; the next
 	// loop iteration dispatches it instead of routing again.
 	let pendingDecision: Decision | null = null;
+	// Digests made this turn, by edit; a retry re-plans and must not pay twice.
+	const digestMemo = new Map<string, string>();
 
 	for (let attempt = 0; attempt < maxAttempts; attempt++) {
 		// Client disconnected before anything was dispatched: spend nothing.
@@ -160,6 +165,27 @@ export async function runTurn(
 			}
 		}
 
+		// Summarising compaction: new edits get a cheap-model digest before the
+		// plan is applied and persisted. Bounded per turn; a decline leaves the
+		// plain edit. Accounted in the estimate adjustment below.
+		let compactionSavedBytes = decision.compactionSavedBytes;
+		if (deps.digester !== undefined && config.compaction.digestToolResults && decision.compactionPlan.length > 0) {
+			try {
+				compactionSavedBytes += await digestCompactionEdits({
+					req,
+					plan: decision.compactionPlan,
+					tier: decision.tier,
+					cfg: config,
+					digester: deps.digester,
+					memo: digestMemo,
+					query: relevanceQuery(req),
+					log,
+				});
+			} catch (err) {
+				log.warn("compaction digest failed; dispatching plain edits", { error: err instanceof Error ? err.message : String(err) });
+			}
+		}
+
 		// Resolve the shared context block. The bridge refreshes only when this
 		// turn's prefix is already cold — a model switch or a retry — so the
 		// injected bytes stay identical while the cache is worth keeping.
@@ -209,7 +235,7 @@ export async function runTurn(
 		// — not the raw request the estimate was taken from.
 		adjustPendingEstimate(
 			req.conversationKey,
-			req.promptBytes - decision.compactionSavedBytes + (contextBlock === undefined ? 0 : Buffer.byteLength(contextBlock)),
+			req.promptBytes - compactionSavedBytes + (contextBlock === undefined ? 0 : Buffer.byteLength(contextBlock)),
 		);
 
 		// Our own abort composes with the client's: escalation teardown and

package/src/util/sqlite.ts

@@ -141,6 +141,13 @@ CREATE TABLE IF NOT EXISTS feedback (
 CREATE INDEX IF NOT EXISTS idx_feedback_created ON feedback (created_at_ms);
 CREATE INDEX IF NOT EXISTS idx_feedback_ledger ON feedback (ledger_id);
 
+-- Small durable markers (e.g. when the daily summary was last posted, per harness).
+CREATE TABLE IF NOT EXISTS router_kv (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at_ms INTEGER NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS agentdox_sessions (
   conversation_key TEXT PRIMARY KEY,
   scope TEXT NOT NULL,