auto-model-router 0.4.2 → 0.4.3

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.4.2",
+    "version": "0.4.3",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.4.2",
+      "version": "0.4.3",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -497,6 +497,8 @@ escalation signal, error. Three views aggregate it, all from the same
   unreachable.
 - `auto-model-router report --days 7 [--harness <id>] [--json]` on the terminal.
 - `GET /v1/router/report?days=7&harness=<id>` for dashboards.
+- `GET /v1/router/summary?harness=<id>` — the daily summary as JSON (`auto=1`
+  applies the once-a-day gate and returns `due: false` when nothing is due).
 
 What it shows, for the window:
 
@@ -510,6 +512,18 @@ What it shows, for the window:
 | by day | UTC calendar days: dispatches, spend, cache hit |
 | same traffic on one model | the window's tokens priced on each `report.baselines` model at list price with the window's cache hit rate, and what share the router saved against it |
 
+**Soft-failure spikes.** `/health` (`softFailures.spikes`), `/router status`
+and the daily summary list any model whose failure rate over the last hour —
+probe rejections such as `empty_completion` or `repeat_tool_call` that
+OpenRouter counts as success, plus attributable transport errors — is at
+least 25%, at least twice its own rate over the preceding 7 days, and covers
+at least 5 dispatches with 3 failures. This is visibility only: two weeks of
+ledger data showed soft failures do not cluster tightly enough for a breaker
+to save money (after a burst, the next 15 minutes ran 84–1,577 successes per
+13–50 failures), and OpenRouter's provider failover plus the router's own
+escalation already cover the retry. Use a spike as the cue to `/router pin`
+or deny a model for the session.
+
 Spend follows the ledger's rule — the provider's reported cost when it gave
 one, else the usage-priced figure the router computed, else the forecast.
 Speed uses only clean streamed rows (TTFT recorded, no error); tokens/s is
@@ -534,7 +548,8 @@ Status); the subcommands go straight there:
 | --- | --- |
 | `/router config` | Section picker over **every** config key: Server, OpenRouter, Ollama Cloud, Benchmarks, Tiers, Tasks, Filters, Classifier, Escalation, Hysteresis, Exploration, Cache, Compaction, Context (agentdox), Budget, Ledger, Logging, Profiles. Only `ollama.prices` and `ollama.twins` (maps) stay YAML-only. |
 | `/router report` | Usage analytics in a fullscreen hub styled like `/models`: pick a view in the sidebar, set the window (24h / 7d / 30d / 90d) and the harness scope there too. `/router report 30d --all` presets them. See [Usage reports](#usage-reports). |
-| `/router status` | The router's `/health`: key sources, catalog size and age, Ollama availability, plan usage and cost bias, agentdox bridge. |
+| `/router summary [--all]` | The last 24 hours in a few lines: spend against the day before, turns and conversations, cache hit, escalations, errors, model switches with tier moves, top models, savings against the first `report.baselines` model, digests and subagent spend, soft-failure spikes, and the Ollama meter with its runway. Posted automatically once a day at session start when `report.dailySummary` is on (the router keeps a per-harness marker, so several omp windows show it once between them, and a day with no turns and no spikes is skipped). |
+| `/router status` | The router's `/health`: key sources, catalog size and age, Ollama availability, plan usage and cost bias, soft-failure spikes (below), agentdox bridge. |
 | `/router why` | Explain this session's last routed turn: model and provider, tier, classification source and confidence, cost, cache hit, latency, the full decision trail and classifier reasons, any feedback already given. |
 | `/router good` / `/router bad [note]` | Judge that turn. Recorded against the model that served it (`POST /v1/router/feedback`), shown per model in the report's `feedback` column, and the label the de-escalation work needs. `/router feedback good\|bad` is the same. |
 | `/router pin <model\|off>` | Route this session to one model until cleared (admitted past price, quality and trust filters; tool support and context window still apply). Escalations and failovers after the first attempt still run. |
@@ -668,6 +683,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `includeFree` | `false` | Include free models (rate-limited hard; usually excluded). |
 | `requireToolSupport` | `true` | Only models that support tool calls. |
 | `feedbackWeight` | `0` | How much a `/router good\|bad` verdict weighs in a model's trust rate: a bad verdict counts as this many failures, a good one as this many successes. `0` records verdicts without acting on them. |
+| `feedbackByTask` | `false` | Count a verdict only when routing the same task type as the judged turn (coding, vision, documentation, data, chat), so a model that codes well but explains badly keeps its coding trust. Verdicts on turns with no recorded task count everywhere. |
 | `minTrust` | `0.7` | Minimum success rate; models below this (after `minTrustSamples`) are demoted. |
 | `minTrustSamples` | `12` | Attempts before trust is enforced. |
 | `trustScopedByHarness` | `false` | `true` = each harness reads only its own trust rows. |
@@ -684,7 +700,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | Key | Default | Meaning |
 | --- | --- | --- |
 | `ambiguityThreshold` | `0.6` | Below this heuristic confidence, the adjudicator model decides the tier. |
-| `learnedModelPath` | unset | A model written by `bun tools/train-classifier.ts` (logistic regression over the ledger's recorded features, label = the turn escalated). When set, every decision records `learned: p(escalate)=…`. Advisory only: it never moves a tier until replay shows it should. |
+| `learnedModelPath` | unset | A model written by `bun tools/train-classifier.ts` (logistic regression over the ledger's recorded features; label = the turn escalated, or with `--label feedback` the turn was judged bad via `/router bad`). When set, every decision records `learned: p(escalate)=…` or `learned: p(bad)=…`. Advisory only: it never moves a tier until replay shows it should. |
 | `model` | `qwen/qwen3.7-flash` | Adjudicator model slug. |
 | `maxCostFraction` | `0.02` | Adjudicator cost cap as a fraction of the turn's budget. |
 | `maxCostUsd` | `0.002` | Absolute adjudicator cost cap, USD. |
@@ -748,6 +764,8 @@ shrunk results stay shrunk (rewriting them would break the prompt cache).
 | `keepHeadBytes` / `keepTailBytes` | `512` / `512` | Bytes kept around the elision breadcrumb. |
 | `elideSupersededReads` | `true` | Stub an older result when a newer call to the same resource supersedes it. |
 | `collapseDuplicateResults` | `true` | Collapse byte-identical repeated results to a single copy. |
+| `digestToolResults` | `false` | 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 dispatched bytes stay identical on later turns and the cache holds. Applies when the turn routed at or above `digest.fromTier`; works without `digest.enabled`. |
+| `digestMaxPerTurn` | `2` | Digests per turn at most (largest results first); the rest of a plan's new edits stay plain until a later turn. |
 
 ### `cache` — prompt-cache breakpoints
 
@@ -809,6 +827,7 @@ is a ledger row (`requestedModel` `digest`) and the report totals them.
 | Key | Default | Meaning |
 | --- | --- | --- |
 | `baselines` | `anthropic/claude-opus-5`, `anthropic/claude-sonnet-5` | Models the report prices the window's traffic on as a single-model counterfactual. Unknown slugs are skipped. |
+| `dailySummary` | `true` | Post the daily summary (below) into the transcript at the first interactive omp session start of each day. Hot-reloads. |
 
 ### `ledger` — cost measurement
 

package/omp-extension/report-logic.ts

@@ -6,6 +6,7 @@
  */
 
 import type { UsageReport } from "../src/cost/report.ts";
+import type { DailySummary } from "../src/cost/summary.ts";
 
 export interface ReportRequest {
 	windowDays: number;
@@ -61,6 +62,44 @@ export async function fetchReport(
 	return (await res.json()) as UsageReport;
 }
 
+/** GETs the daily summary; `auto` asks the router whether one is due today. Throws on any failure. */
+export async function fetchSummary(
+	baseUrl: string,
+	harnessId: string,
+	auto: boolean,
+	headers: Record<string, string>,
+	fetchImpl: FetchLike = fetch,
+	timeoutMs = 5_000,
+): Promise<{ due: boolean; reason?: string; summary: DailySummary | null }> {
+	const params = new URLSearchParams();
+	if (harnessId !== "") params.set("harness", harnessId);
+	if (auto) params.set("auto", "1");
+	const q = params.toString();
+	const res = await fetchImpl(`${baseUrl}/v1/router/summary${q === "" ? "" : `?${q}`}`, { headers, signal: AbortSignal.timeout(timeoutMs) });
+	if (!res.ok) throw new Error(`router returned ${res.status}`);
+	return (await res.json()) as { due: boolean; reason?: string; summary: DailySummary | null };
+}
+
+/** One spiking model as `/health` reports it. */
+export interface SoftFailureSpikeView {
+	slug?: string;
+	recentDispatches?: number;
+	recentFailures?: number;
+	recentRate?: number;
+	baselineDispatches?: number;
+	baselineRate?: number;
+}
+
+/** "slug: 40% of 10 failed in the last 1h (7d baseline 8% of 120)" — one line per spiking model. */
+export function renderSoftFailureSpikes(spikes: readonly SoftFailureSpikeView[] | undefined | null, recentMs = 3_600_000, baselineDays = 7): string[] {
+	if (spikes === undefined || spikes === null || spikes.length === 0) return [];
+	const window = recentMs >= 3_600_000 ? `${(recentMs / 3_600_000).toFixed(recentMs % 3_600_000 === 0 ? 0 : 1)}h` : `${Math.round(recentMs / 60_000)}m`;
+	return spikes.map(
+		(s) =>
+			`${s.slug ?? "?"}: ${((s.recentRate ?? 0) * 100).toFixed(0)}% of ${s.recentDispatches ?? 0} failed in the last ${window} (${baselineDays}d baseline ${((s.baselineRate ?? 0) * 100).toFixed(0)}% of ${s.baselineDispatches ?? 0})`,
+	);
+}
+
 /** The subset of `/health` the status view renders. */
 export interface HealthSnapshot {
 	status?: string;
@@ -80,6 +119,7 @@ export interface HealthSnapshot {
 		runway?: { dailyBurnUsd?: number; creditsLeftUsd?: number; days?: number | null } | null;
 		costBias?: { configured?: number; effective?: number; biasUntilUsage?: number };
 	} | null;
+	softFailures?: { recentMs?: number; baselineDays?: number; spikes?: SoftFailureSpikeView[] } | null;
 	catalog?: {
 		models?: number;
 		ageMs?: number;
@@ -119,6 +159,12 @@ export function renderStatus(baseUrl: string, h: HealthSnapshot, nowMs = Date.no
 		const rwText = rw !== undefined && rw !== null ? ` · burn $${(rw.dailyBurnUsd ?? 0).toFixed(2)}/day · ${rw.days === null || rw.days === undefined ? "credits left: unknown burn" : `~${Math.round(rw.days)} days of credits left`}` : "";
 		if (o.meter !== undefined && o.meter !== null) out.push(`ollama billing: ${calText}${rwText}`);
 	}
+	const sf = h.softFailures;
+	if (sf !== undefined && sf !== null) {
+		const lines = renderSoftFailureSpikes(sf.spikes, sf.recentMs, sf.baselineDays);
+		if (lines.length === 0) out.push("soft failures: no model spiking in the last hour");
+		else out.push(`soft failures SPIKING (${lines.length}):`, ...lines.map((l) => `  ${l}`));
+	}
 	const a = h.agentdox;
 	out.push(a === undefined || a === null ? "agentdox: off" : `agentdox: ${a.url ?? "?"} scope ${a.defaultScope ?? "?"}${a.recordTurns === true ? " · recording turns" : ""}`);
 	return out.join("\n");

package/omp-extension/router-configure.ts

@@ -50,6 +50,7 @@ import { routerConfigPath, writeRouterConfig } from "../src/cli/config-cmd.ts";
 import { loadConfig } from "../src/config/load.ts";
 import type { RouterConfig } from "../src/config/types.ts";
 import { buildUsageReport, renderUsageReport, type UsageReport } from "../src/cost/report.ts";
+import { buildDailySummary, renderDailySummary } from "../src/cost/summary.ts";
 import { openDb } from "../src/util/sqlite.ts";
 
 import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
@@ -61,6 +62,7 @@ import { ReportHub } from "./report-hub.ts";
 import {
 	describeOverride,
 	fetchReport,
+	fetchSummary,
 	parseOverrideArgs,
 	parseReportArgs,
 	renderStatus,
@@ -77,12 +79,32 @@ const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "";
 
 /** Custom message type for report/status output in the transcript. */
 const MESSAGE_TYPE = "auto-model-router";
+/** The embedded router boots on session_start too; the auto summary waits for it this long. */
+const SUMMARY_TRIES = 8;
+const SUMMARY_RETRY_MS = 1_500;
 
 export default function (pi: ExtensionAPI): void {
 	pi.setLabel("auto-model-router");
 
+	// Once a day, the first interactive session posts yesterday's summary. The
+	// router decides whether one is due (report.dailySummary, a per-harness
+	// marker), so several windows on one router show it once between them.
+	pi.on("session_start", async (_event, ctx) => {
+		if (!ctx.hasUI) return;
+		for (let i = 0; i < SUMMARY_TRIES; i++) {
+			try {
+				const r = await fetchSummary(routerBaseUrl(), HARNESS_ID, true, routerAuthHeaders(), fetch, 2_000);
+				if (r.due && r.summary !== null) post(pi, renderDailySummary(r.summary));
+				return;
+			} catch {
+				// Router still starting (embed) or absent: try again shortly, then give up quietly.
+				await new Promise((resolve) => setTimeout(resolve, SUMMARY_RETRY_MS));
+			}
+		}
+	});
+
 	pi.registerCommand("router", {
-		description: "auto-model-router: configure, usage report, status",
+		description: "auto-model-router: configure, usage report, status, daily summary",
 		handler: async (args, ctx) => {
 			const [verb = "", ...rest] = args.trim().split(/\s+/).filter((t) => t !== "");
 			const tail = rest.join(" ");
@@ -95,6 +117,9 @@ export default function (pi: ExtensionAPI): void {
 				case "status":
 				case "health":
 					return status(pi, ctx);
+				case "summary":
+				case "daily":
+					return summary(pi, ctx, tail);
 				case "why":
 				case "explain":
 					return why(pi, ctx);
@@ -116,20 +141,22 @@ export default function (pi: ExtensionAPI): void {
 				case "":
 					break;
 				default:
-					ctx.ui.notify(`unknown /router subcommand "${verb}" (config | report | status | why | good | bad | pin | tier)`, "warn");
+					ctx.ui.notify(`unknown /router subcommand "${verb}" (config | report | summary | status | why | good | bad | pin | tier)`, "warn");
 					return;
 			}
 
 			const chosen = await ctx.ui.select("auto-model-router", [
 				{ label: "Configure", description: "edit any router setting" },
 				{ label: "Report", description: "usage analytics; window and scope adjustable inside" },
-				{ label: "Status", description: "keys, catalog, Ollama, agentdox" },
+				{ label: "Summary", description: "the last 24h in a few lines" },
+				{ label: "Status", description: "keys, catalog, Ollama, agentdox, soft-failure spikes" },
 				{ label: "Why", description: "explain this session's last routed turn" },
 				{ label: "Override", description: "pin a model or force a tier for this session" },
 			]);
 			if (chosen === undefined) return;
 			if (chosen === "Configure") return configure(ctx);
 			if (chosen === "Status") return status(pi, ctx);
+			if (chosen === "Summary") return summary(pi, ctx, "");
 			if (chosen === "Report") return report(pi, ctx, "");
 			if (chosen === "Why") return why(pi, ctx);
 			if (chosen === "Override") return override(ctx, "tier", "");
@@ -299,6 +326,31 @@ async function override(ctx: ExtensionContext, verb: "pin" | "tier", text: strin
 	}
 }
 
+/** `/router summary [--all]`: the last 24h, from the router or (router down) the ledger directly. */
+async function summary(pi: ExtensionAPI, ctx: ExtensionContext, argText: string): Promise<void> {
+	const harnessId = parseReportArgs(argText, HARNESS_ID).harnessId;
+	try {
+		const r = await fetchSummary(routerBaseUrl(), harnessId, false, routerAuthHeaders());
+		if (r.summary !== null) {
+			post(pi, renderDailySummary(r.summary));
+			return;
+		}
+	} catch {
+		// Fall through to the ledger.
+	}
+	const cfg = loadConfig();
+	if (!existsSync(cfg.ledger.path)) {
+		ctx.ui.notify(`router unreachable at ${routerBaseUrl()} and no ledger at ${cfg.ledger.path}`, "error");
+		return;
+	}
+	const db = openDb(cfg.ledger.path);
+	try {
+		post(pi, `${renderDailySummary(buildDailySummary(db, { harnessId }))}\n(router unreachable: read from the ledger; spikes and the Ollama meter need the router)`);
+	} finally {
+		db.close();
+	}
+}
+
 async function status(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
 	try {
 		post(pi, await loadStatus());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/config-wizard.ts

@@ -184,6 +184,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "filters.requireToolSupport", label: "Require tool support", kind: "boolean" },
 			{ path: "filters.minTrust", label: "Min trust", kind: "number", min: 0, max: 1 },
 			{ path: "filters.feedbackWeight", label: "Feedback weight in trust", kind: "number", min: 0, hint: "0=record only; a bad verdict = this many failures" },
+			{ path: "filters.feedbackByTask", label: "Scope verdicts to the task type", kind: "boolean" },
 			{ path: "filters.minTrustSamples", label: "Min trust samples", kind: "number", min: 0 },
 			{ path: "filters.trustScopedByHarness", label: "Scope trust per harness", kind: "boolean" },
 			{ path: "filters.trustWindowDays", label: "Trust window", kind: "number", min: 0, hint: "days, 0=all time" },
@@ -280,6 +281,8 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "compaction.keepTailBytes", label: "Keep tail bytes", kind: "number", min: 0 },
 			{ path: "compaction.elideSupersededReads", label: "Elide superseded reads", kind: "boolean" },
 			{ path: "compaction.collapseDuplicateResults", label: "Collapse duplicate results", kind: "boolean" },
+			{ path: "compaction.digestToolResults", label: "Digest compacted results with a cheap model", kind: "boolean" },
+			{ path: "compaction.digestMaxPerTurn", label: "Digests per turn at most", kind: "number", min: 0 },
 		],
 	},
 	{
@@ -327,7 +330,10 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 	},
 	{
 		title: "Report",
-		fields: [{ path: "report.baselines", label: "Counterfactual baseline models", kind: "stringArray", hint: "comma-separated slugs" }],
+		fields: [
+			{ path: "report.baselines", label: "Counterfactual baseline models", kind: "stringArray", hint: "comma-separated slugs" },
+			{ path: "report.dailySummary", label: "Daily summary at session start", kind: "boolean" },
+		],
 	},
 	{
 		title: "Ledger",

package/src/config/defaults.ts

@@ -103,6 +103,7 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		minTrust: 0.7,
 		// Verdicts are recorded and reported first; weigh them once there are some.
 		feedbackWeight: 0,
+		feedbackByTask: false,
 		minTrustSamples: 12,
 		// Shared trust by default: more samples, demotion guard stays effective
 		// even with a tiny guardrail-narrowed catalog.
@@ -291,6 +292,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		keepTailBytes: 512,
 		elideSupersededReads: true,
 		collapseDuplicateResults: true,
+		// Off: a synchronous cheap-model call before dispatch, only worth it where
+		// stale tool output is the prompt and the turn is on a dear model.
+		digestToolResults: false,
+		digestMaxPerTurn: 2,
 	},
 	digest: {
 		// Off until an operator turns it on: it changes what the model reads.
@@ -308,6 +313,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 	report: {
 		// The frontier pair most omp users would otherwise run on.
 		baselines: ["anthropic/claude-opus-5", "anthropic/claude-sonnet-5"],
+		// One transcript message per day, at the first interactive session start.
+		dailySummary: true,
 	},
 	budget: {
 		// No caps by default; at a configured ceiling, downgrade rather than fail.

package/src/config/schema.ts

@@ -90,6 +90,7 @@ const filters = z.strictObject({
 	requireToolSupport: z.boolean().optional(),
 	minTrust: z.number().min(0).max(1).optional(),
 	feedbackWeight: z.number().nonnegative().optional(),
+	feedbackByTask: z.boolean().optional(),
 	minTrustSamples: z.number().int().nonnegative().optional(),
 	trustScopedByHarness: z.boolean().optional(),
 	trustWindowDays: z.number().nonnegative().optional(),
@@ -205,6 +206,8 @@ const compaction = z.strictObject({
 	keepTailBytes: z.number().int().nonnegative().optional(),
 	elideSupersededReads: z.boolean().optional(),
 	collapseDuplicateResults: z.boolean().optional(),
+	digestToolResults: z.boolean().optional(),
+	digestMaxPerTurn: z.number().int().nonnegative().optional(),
 });
 
 const budget = z.strictObject({
@@ -272,7 +275,7 @@ export const configInputSchema = z.strictObject({
 	compaction: compaction.optional(),
 	budget: budget.optional(),
 	profiles: z.array(profile).optional(),
-	report: z.strictObject({ baselines: z.array(z.string()).optional() }).optional(),
+	report: z.strictObject({ baselines: z.array(z.string()).optional(), dailySummary: z.boolean().optional() }).optional(),
 	digest: z
 		.strictObject({
 			enabled: z.boolean().optional(),

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;
 	/**
@@ -589,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 {
@@ -746,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;
 }

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})`,
@@ -363,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");
 
@@ -466,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.
@@ -476,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[] {
@@ -497,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>();
@@ -509,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),
 				});
 			}
@@ -552,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

@@ -185,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(