auto-model-router 0.4.1 → 0.4.3

package/src/config/types.ts

@@ -232,6 +232,15 @@ export interface FilterConfig {
 	 * once a week of verdicts is in the report.
 	 */
 	feedbackWeight: number;
+	/**
+	 * Count a verdict toward a model's trust only when routing the same task
+	 * type the judged turn was (the ledger's `task`: coding, vision,
+	 * documentation, data, chat). A model that writes good code but bad prose
+	 * then keeps its coding trust. Verdicts on turns with no recorded task
+	 * count for every task. Off by default: verdicts are scarce, and pooling
+	 * them converges sooner.
+	 */
+	feedbackByTask: boolean;
 	/** Attempts required before `minTrust` is enforced against a model. */
 	minTrustSamples: number;
 	/**
@@ -554,6 +563,32 @@ export interface CacheConfig {
 	milestoneTokens: number;
 }
 
+/**
+ * Tool-result digest: a cheap model condenses large tool outputs before an
+ * expensive one reads them (see server/digest.ts and the router-digest omp
+ * extension).
+ */
+export interface DigestConfig {
+	/** Master switch; the omp extension polls this as its policy. */
+	enabled: boolean;
+	/** Tool results smaller than this pass through untouched. */
+	minBytes: number;
+	/** Results larger than this are left alone (too costly even for a cheap model). */
+	maxBytes: number;
+	/** Tool names (lower-case) whose results may be digested. Never errors, never edits/writes. */
+	tools: string[];
+	/** Digest only when the session's current model is at or above this tier. */
+	fromTier: Tier;
+	/** Tier the digest model is picked from (cheapest candidate that fits). */
+	tier: Tier;
+	/** Pin a specific digest model; empty ⇒ pick from `tier`. */
+	model: string;
+	maxOutputTokens: number;
+	/** Skip when the digest itself would cost more than this, USD. */
+	maxCostUsd: number;
+	timeoutMs: number;
+}
+
 /** Usage-report options. */
 export interface ReportConfig {
 	/**
@@ -563,6 +598,13 @@ export interface ReportConfig {
 	 * are skipped.
 	 */
 	baselines: string[];
+	/**
+	 * Post a one-screen summary of the last 24 hours (spend, top models, cache
+	 * hit, escalations, soft-failure spikes, Ollama meter) into the transcript
+	 * at the first omp session start of each day. `/router summary` shows it
+	 * on demand regardless.
+	 */
+	dailySummary: boolean;
 }
 
 export interface BudgetConfig {
@@ -720,6 +762,17 @@ export interface CompactionConfig {
 	keepTailBytes: number;
 	/** Elide an older tool result when a newer call to the same resource supersedes it. */
 	elideSupersededReads: boolean;
+	/**
+	 * Summarising compaction: when the plan gains an edit, a cheap model
+	 * (`digest.tier` / `digest.model`, under `digest.maxCostUsd` and
+	 * `digest.timeoutMs`) digests the tool result instead of it being cut to
+	 * head+tail or a stub. The digest is stored on the edit, so the bytes sent
+	 * stay identical on later turns. Applies when the turn routed at or above
+	 * `digest.fromTier`; does not need `digest.enabled`.
+	 */
+	digestToolResults: boolean;
+	/** Digests per turn at most; the rest of a plan's new edits stay plain until a later turn. */
+	digestMaxPerTurn: number;
 	/** Collapse byte-identical repeated tool results to a single copy. */
 	collapseDuplicateResults: boolean;
 }
@@ -741,6 +794,7 @@ export interface RouterConfig {
 	compaction: CompactionConfig;
 	budget: BudgetConfig;
 	report: ReportConfig;
+	digest: DigestConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**

package/src/cost/ledger.ts

@@ -27,6 +27,7 @@ import type {
 	ModelCacheReliability,
 	ModelLatency,
 	ModelTrust,
+	SoftFailureSpike,
 	UsageCounts,
 } from "./types.ts";
 
@@ -35,6 +36,20 @@ const MIN_CALIBRATION_SAMPLES = 20;
 /** Calibration samples outside this bytes-per-token band are provider accounting quirks, not tokenizer facts. */
 const MIN_SANE_BYTES_PER_TOKEN = 1.5;
 const MAX_SANE_BYTES_PER_TOKEN = 8;
+/**
+ * Soft-failure spike detection (visibility only). A model is spiking when, over
+ * the recent window, it has at least SPIKE_MIN_DISPATCHES dispatches, at least
+ * SPIKE_MIN_FAILURES of them failed, its failure rate is at least
+ * SPIKE_MIN_RATE, and that rate is at least SPIKE_RATIO × its own baseline
+ * rate over the preceding window (a model with no baseline failures spikes on
+ * the absolute floor alone).
+ */
+const SPIKE_RECENT_MS = 60 * 60_000;
+const SPIKE_BASELINE_MS = 7 * 24 * 60 * 60_000;
+const SPIKE_MIN_DISPATCHES = 5;
+const SPIKE_MIN_FAILURES = 3;
+const SPIKE_MIN_RATE = 0.25;
+const SPIKE_RATIO = 2;
 /** Escalated attempts needed before their measured cost is trusted. */
 const MIN_ESCALATION_SAMPLES = 10;
 /** The escalation-cost aggregate scans a window of rows; memoised for this long. */
@@ -334,11 +349,23 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 		`SELECT ${FEEDBACK_SELECT} FROM feedback f JOIN ledger l ON l.id = f.ledger_id WHERE f.slug = ? AND l.harness_id = ? AND f.created_at_ms > ?`,
 	);
 	const allFeedbackStmt = db.query(`SELECT f.slug, ${FEEDBACK_SELECT} FROM feedback f WHERE f.created_at_ms > ? GROUP BY f.slug`);
-	const feedbackFor = (slug: string, harnessId: string | undefined, cutoff: number): FeedbackRow | null => {
+	// Task-scoped variants (filters.feedbackByTask): the judged turn's task
+	// must match, or be unrecorded (older rows, or a turn that never classified).
+	const feedbackTaskStmt = db.query(
+		`SELECT ${FEEDBACK_SELECT} FROM feedback f JOIN ledger l ON l.id = f.ledger_id WHERE f.slug = ? AND (l.task = ? OR l.task IS NULL) AND f.created_at_ms > ?`,
+	);
+	const feedbackHarnessTaskStmt = db.query(
+		`SELECT ${FEEDBACK_SELECT} FROM feedback f JOIN ledger l ON l.id = f.ledger_id WHERE f.slug = ? AND l.harness_id = ? AND (l.task = ? OR l.task IS NULL) AND f.created_at_ms > ?`,
+	);
+	const feedbackFor = (slug: string, harnessId: string | undefined, cutoff: number, task?: string): FeedbackRow | null => {
 		if (cfg.filters.feedbackWeight <= 0) return null;
-		return harnessId !== undefined && harnessId !== ""
-			? (feedbackHarnessStmt.get(slug, harnessId, cutoff) as FeedbackRow | null)
-			: (feedbackStmt.get(slug, cutoff) as FeedbackRow | null);
+		const byHarness = harnessId !== undefined && harnessId !== "";
+		if (cfg.filters.feedbackByTask && task !== undefined && task !== "") {
+			return byHarness
+				? (feedbackHarnessTaskStmt.get(slug, harnessId, task, cutoff) as FeedbackRow | null)
+				: (feedbackTaskStmt.get(slug, task, cutoff) as FeedbackRow | null);
+		}
+		return byHarness ? (feedbackHarnessStmt.get(slug, harnessId, cutoff) as FeedbackRow | null) : (feedbackStmt.get(slug, cutoff) as FeedbackRow | null);
 	};
 	const latencyStmt = db.query(
 		`SELECT ${LATENCY_SELECT} FROM (SELECT * FROM ledger WHERE slug = ? ORDER BY created_at_ms DESC LIMIT ${LATENCY_WINDOW_ROWS})`,
@@ -351,7 +378,8 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 	const providerSpendStmt = db.query(
 		"SELECT COALESCE(SUM(COALESCE(reported_usd, predicted_usd)), 0) AS total FROM ledger WHERE created_at_ms >= ? AND COALESCE(served_slug, slug) LIKE ?",
 	);
-	const sessionStmt = db.query("SELECT * FROM ledger WHERE omp_session_id = ? AND wasted = 0 ORDER BY created_at_ms DESC LIMIT ?");
+	// Digest rows (requested_model 'digest') are side calls, not the session's turns.
+	const sessionStmt = db.query("SELECT * FROM ledger WHERE omp_session_id = ? AND wasted = 0 AND requested_model <> 'digest' ORDER BY created_at_ms DESC LIMIT ?");
 	// What an escalated retry actually bills, per prompt token, over a window.
 	// attempt > 0 rows are the re-dispatches that followed a rejected attempt;
 	// errored ones carry no usage and are excluded.
@@ -362,6 +390,19 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 		 FROM ledger WHERE attempt > 0 AND error IS NULL AND created_at_ms >= ?`,
 	);
 	let escalationMemo: { atMs: number; windowDays: number; value: EscalationCost | null } | null = null;
+	// Per-model failure counts over two adjacent windows: [recentStart, now] and
+	// [baselineStart, recentStart). Wasted rows (the failed attempt a retry
+	// replaced) stay in: they ARE the soft failures being counted. Digest side
+	// calls are excluded: they are not the session's turns.
+	const softFailureStmt = db.query(
+		`SELECT COALESCE(served_slug, slug) AS slug,
+			SUM(CASE WHEN created_at_ms >= $recentStart THEN 1 ELSE 0 END) AS recent_n,
+			SUM(CASE WHEN created_at_ms >= $recentStart AND (escalation_signal IS NOT NULL OR (${ATTRIBUTABLE_ERROR})) THEN 1 ELSE 0 END) AS recent_f,
+			SUM(CASE WHEN created_at_ms < $recentStart THEN 1 ELSE 0 END) AS base_n,
+			SUM(CASE WHEN created_at_ms < $recentStart AND (escalation_signal IS NOT NULL OR (${ATTRIBUTABLE_ERROR})) THEN 1 ELSE 0 END) AS base_f
+		 FROM ledger WHERE created_at_ms >= $baselineStart AND created_at_ms <= $now AND requested_model <> 'digest'
+		 GROUP BY COALESCE(served_slug, slug)`,
+	);
 	const cacheMetaStmt = db.query("SELECT fetched_at_ms FROM catalog_cache WHERE id = 1");
 	const cachePayloadStmt = db.query("SELECT payload FROM catalog_cache WHERE id = 1");
 
@@ -465,7 +506,7 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 			return computeBlendedRate(db, cfg, windowDays);
 		},
 
-		trust(slug: string, harnessId?: string): ModelTrust | null {
+		trust(slug: string, harnessId?: string, task?: string): ModelTrust | null {
 			// Read the window at CALL time, not at construction: hot reload mutates
 			// the shared config object in place, so a pinned value would ignore an
 			// edit until restart. 0 => cutoff 0 => every row qualifies.
@@ -475,7 +516,7 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 					? (trustHarnessStmt.get(slug, harnessId, cutoff) as TrustRow | null)
 					: (trustStmt.get(slug, cutoff) as TrustRow | null);
 			if (row === null || row.attempts === 0) return null;
-			return toTrust(slug, row, feedbackFor(slug, harnessId, cutoff), cfg.filters.feedbackWeight);
+			return toTrust(slug, row, feedbackFor(slug, harnessId, cutoff, task), cfg.filters.feedbackWeight);
 		},
 
 		allTrust(): ModelTrust[] {
@@ -496,7 +537,7 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 			if (row === null) return null;
 			return toLatency(slug, row);
 		},
-		signals(slugs: readonly string[], harnessId?: string): Map<string, LedgerSignals> {
+		signals(slugs: readonly string[], harnessId?: string, task?: string): Map<string, LedgerSignals> {
 			const cutoff = cfg.filters.trustWindowDays > 0 ? Date.now() - cfg.filters.trustWindowDays * DAY_MS : 0;
 			const hasHarness = harnessId !== undefined && harnessId !== "";
 			const out = new Map<string, LedgerSignals>();
@@ -508,7 +549,7 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 					? (latencyHarnessStmt.get(slug, harnessId) as LatencyRow | null)
 					: (latencyStmt.get(slug) as LatencyRow | null);
 				out.set(slug, {
-					trust: trustRow === null || trustRow.attempts === 0 ? null : toTrust(slug, trustRow, feedbackFor(slug, harnessId, cutoff), cfg.filters.feedbackWeight),
+					trust: trustRow === null || trustRow.attempts === 0 ? null : toTrust(slug, trustRow, feedbackFor(slug, harnessId, cutoff, task), cfg.filters.feedbackWeight),
 					latency: latencyRow === null ? null : toLatency(slug, latencyRow),
 				});
 			}
@@ -551,6 +592,33 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 			const rows = recentStmt.all(limit) as LedgerRow[];
 			return rows.map(toEntry);
 		},
+		softFailureSpikes(nowMs = Date.now(), recentMs = SPIKE_RECENT_MS, baselineMs = SPIKE_BASELINE_MS): SoftFailureSpike[] {
+			const rows = softFailureStmt.all({ $now: nowMs, $recentStart: nowMs - recentMs, $baselineStart: nowMs - recentMs - baselineMs }) as {
+				slug: string;
+				recent_n: number;
+				recent_f: number;
+				base_n: number;
+				base_f: number;
+			}[];
+			const spikes: SoftFailureSpike[] = [];
+			for (const r of rows) {
+				if (r.recent_n < SPIKE_MIN_DISPATCHES || r.recent_f < SPIKE_MIN_FAILURES) continue;
+				const recentRate = r.recent_f / r.recent_n;
+				const baselineRate = r.base_n > 0 ? r.base_f / r.base_n : 0;
+				if (recentRate < SPIKE_MIN_RATE || recentRate < SPIKE_RATIO * baselineRate) continue;
+				spikes.push({
+					slug: r.slug,
+					recentDispatches: r.recent_n,
+					recentFailures: r.recent_f,
+					recentRate,
+					baselineDispatches: r.base_n,
+					baselineFailures: r.base_f,
+					baselineRate,
+				});
+			}
+			spikes.sort((a, b) => b.recentRate - a.recentRate || b.recentFailures - a.recentFailures);
+			return spikes;
+		},
 		providerSpendSince(slugPrefix: string, sinceMs: number): number {
 			const row = providerSpendStmt.get(sinceMs, `${slugPrefix}%`) as { total: number } | null;
 			return row?.total ?? 0;

package/src/cost/report.ts

@@ -30,6 +30,10 @@ export interface ReportTotals {
 	/** Turns from omp subagents (`features.isSubagent`), and their spend. */
 	subagentDispatches: number;
 	subagentSpendUsd: number;
+	/** Tool-result digests (requestedModel "digest"): count, what they cost, bytes they condensed. */
+	digests: number;
+	digestSpendUsd: number;
+	digestInputTokens: number;
 }
 
 export interface ReportRow {
@@ -181,14 +185,19 @@ function toRow(r: RawRow, windowSpend: number): ReportRow {
  */
 export function buildUsageReport(
 	db: Database,
-	opts: { windowDays: number; harnessId?: string; nowMs?: number; baselines?: readonly BaselinePrice[] },
+	opts: { windowDays: number; harnessId?: string; nowMs?: number; baselines?: readonly BaselinePrice[]; /** Exclusive upper bound; default open-ended. */ untilMs?: number },
 ): UsageReport {
 	const nowMs = opts.nowMs ?? Date.now();
 	const windowDays = Math.max(1, opts.windowDays);
 	const sinceMs = nowMs - windowDays * 86_400_000;
 	const harnessId = opts.harnessId ?? "";
-	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 untilMs = opts.untilMs;
+	const where = [
+		"created_at_ms >= $since",
+		...(untilMs === undefined ? [] : ["created_at_ms < $until"]),
+		...(harnessId === "" ? [] : ["harness_id = $harness"]),
+	].join(" AND ");
+	const bind = { $since: sinceMs, ...(untilMs === undefined ? {} : { $until: untilMs }), ...(harnessId === "" ? {} : { $harness: harnessId }) };
 
 	const t = db
 		.query(
@@ -201,6 +210,9 @@ export function buildUsageReport(
 				SUM(CASE WHEN ${EST} THEN 1 ELSE 0 END) AS estimated_rows,
 				SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN 1 ELSE 0 END) AS subagent_rows,
 				COALESCE(SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN ${USD} ELSE 0 END), 0) AS subagent_spend,
+				SUM(CASE WHEN requested_model = 'digest' THEN 1 ELSE 0 END) AS digests,
+				COALESCE(SUM(CASE WHEN requested_model = 'digest' THEN ${USD} ELSE 0 END), 0) AS digest_spend,
+				COALESCE(SUM(CASE WHEN requested_model = 'digest' THEN ${PT} ELSE 0 END), 0) AS digest_input,
 				SUM(CASE WHEN escalation_signal IS NOT NULL THEN 1 ELSE 0 END) AS escalations,
 				SUM(CASE WHEN instr(reasons, 'failover:') > 0 THEN 1 ELSE 0 END) AS failovers,
 				SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) AS errors,
@@ -217,6 +229,9 @@ export function buildUsageReport(
 		estimated_rows: number | null;
 		subagent_rows: number | null;
 		subagent_spend: number;
+		digests: number | null;
+		digest_spend: number;
+		digest_input: number;
 		escalations: number | null;
 		failovers: number | null;
 		errors: number | null;
@@ -336,6 +351,9 @@ export function buildUsageReport(
 			cacheEstimated: (t.estimated_rows ?? 0) > 0,
 			subagentDispatches: t.subagent_rows ?? 0,
 			subagentSpendUsd: t.subagent_spend,
+			digests: t.digests ?? 0,
+			digestSpendUsd: t.digest_spend,
+			digestInputTokens: t.digest_input,
 		},
 		providers,
 		models,
@@ -400,6 +418,9 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 				.join(" · ")}`,
 		);
 	}
+	if (t.digests > 0) {
+		summary.push(`digests: ${num(t.digests)} tool results condensed (${num(t.digestInputTokens)} tok read by a cheap model) for ${usd(t.digestSpendUsd)}`);
+	}
 	if (t.subagentDispatches > 0) {
 		summary.push(`subagents: ${num(t.subagentDispatches)} dispatches, ${usd(t.subagentSpendUsd)} (${pct(t.spendUsd > 0 ? t.subagentSpendUsd / t.spendUsd : 0)} of spend)`);
 	}

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;