auto-model-router 0.4.2 → 0.4.4

package/.gitattributes

@@ -0,0 +1,2 @@
+# SQLite fixtures must never get line-ending conversion (core.autocrlf is on for this checkout).
+*.db binary

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.4",
     "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.4",
       "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. |
@@ -547,7 +562,9 @@ as the placeholder — empty input keeps it, `-` clears an optional field,
 credentials show as `set`/`unset` and are never echoed. `Save and exit` writes the merged config
 (schema-checked and backed up first). Tier, task, filter, classifier,
 hysteresis, exploration, compaction, cache and budget changes hot-reload;
-restart omp for `server`, `openrouter`, `ollama`, `context` and `ledger`.
+restart omp for `server` (except `subagentProfile`), `openrouter`, `context`,
+`ledger.path` and the Ollama connection keys; `ollama.costBias`,
+`ollama.biasUntilUsage` and `ledger.retentionDays` hot-reload too.
 
 ### Via `auto-model-router config` (text wizard / CLI)
 
@@ -668,6 +685,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 +702,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 +766,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
 
@@ -804,11 +824,18 @@ is a ledger row (`requestedModel` `digest`) and the report totals them.
 | `maxCostUsd` | `0.02` | Skip when the digest itself would cost more. |
 | `timeoutMs` | `25000` | The raw result stands if the cheap model is slower. |
 
+Quality signal: when the agent later calls the same tool with the same
+primary argument (re-reads a digested file, re-runs a digested grep), the
+router marks that digest's ledger row wasted. The report's `digests` line
+shows the re-run rate; a high rate means the digest is dropping what the
+task needed, and `digest.maxOutputTokens` or `digest.model` is the lever.
+
 ### `report` — usage-report options
 
 | 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
 
@@ -819,6 +846,7 @@ is a ledger row (`requestedModel` `digest`) and the report totals them.
 | `blendMinSamples` | `25` | Turns before the measured blend replaces the fallback. |
 | `fallbackBlend` | input `1.5`, output `7.5` | Pre-measurement blend (USD/Mtok) for omp's cost display. |
 | `conversationTtlMs` | `604800000` (7 d) | Drop conversation state untouched this long. |
+| `retentionDays` | `365` | Delete ledger rows older than this, checked hourly; `0` keeps everything. The ledger grows about 2.5 MB a day under steady use. Freed pages are reused, so the file stops growing rather than shrinking. |
 
 ### Top-level
 

package/bunfig.toml

@@ -0,0 +1,2 @@
+[test]
+preload = ["./test/support/preload.ts"]

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.4",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/catalog/composite.ts

@@ -23,6 +23,8 @@ export interface CompositeBias {
 	/** Plan usage fraction at which the bias switches off (list price). */
 	biasUntilUsage: number;
 	usage: OllamaUsageSource;
+	/** When given, read on every use instead of the static pair, so a config hot reload applies. */
+	live?: () => { costBias: number; biasUntilUsage: number };
 }
 
 export function createCompositeCatalog(
@@ -39,7 +41,8 @@ export function createCompositeCatalog(
 
 	/** The multiplier in force from the latest usage reading (no network). */
 	function currentBias(): number {
-		return effectiveOllamaBias(bias.costBias, bias.biasUntilUsage, bias.usage.peek());
+		const b = bias.live?.() ?? bias;
+		return effectiveOllamaBias(b.costBias, b.biasUntilUsage, bias.usage.peek());
 	}
 
 	function combine(base: CatalogSnapshot, models: readonly CatalogModel[]): CatalogSnapshot {

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",
@@ -338,6 +344,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "ledger.fallbackBlend.inputPerMtok", label: "Fallback blend input $/Mtok", kind: "number", min: 0 },
 			{ path: "ledger.fallbackBlend.outputPerMtok", label: "Fallback blend output $/Mtok", kind: "number", min: 0 },
 			{ path: "ledger.conversationTtlMs", label: "Conversation TTL", kind: "number", min: 1, hint: "ms" },
+			{ path: "ledger.retentionDays", label: "Ledger retention", kind: "number", min: 0, hint: "days; 0 keeps everything" },
 		],
 	},
 	{

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.
@@ -330,6 +337,7 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// so early cost reporting never underreports.
 		fallbackBlend: { inputPerMtok: 1.5, outputPerMtok: 7.5 },
 		conversationTtlMs: 7 * 24 * 60 * 60 * 1000,
+		retentionDays: 365,
 	},
 	// On by default: an absolute floor that no available model meets is how the
 	// router ends up serving every turn from the cheapest tier.

package/src/config/hot-reload.ts

@@ -90,15 +90,47 @@ export interface WatchConfigOptions {
 }
 
 /**
- * Watches `path` and applies valid changes to `live` in place. `frozen` blocks
- * (top-level names) are re-copied from `pinned` after every reload so file
- * edits to construction-captured blocks cannot silently diverge.
+ * Config paths captured at construction, so a file edit cannot reach the
+ * running process: the socket, the upstream clients, the agentdox bridge, the
+ * ledger file. Everything else, including `ollama.costBias`,
+ * `ollama.biasUntilUsage`, `server.subagentProfile` and `ledger.retentionDays`,
+ * is read at call time and hot-reloads. A bare block name pins the whole
+ * block; `block.key` pins one key and lets its siblings through.
+ */
+export const PINNED_CONFIG_PATHS: readonly string[] = [
+	"server.host",
+	"server.port",
+	"server.apiKey",
+	"server.harnessId",
+	"server.maxConcurrentTurns",
+	"openrouter",
+	"ollama.enabled",
+	"ollama.baseUrl",
+	"ollama.apiKey",
+	"ollama.timeoutMs",
+	"ollama.catalogTtlMs",
+	"ollama.includeLocal",
+	"ollama.prices",
+	"ollama.twins",
+	"ollama.usagePollMs",
+	"ollama.quotaCooldownMs",
+	"ollama.rateLimitCooldownMs",
+	"ollama.planCreditsUsd",
+	"context",
+	"ledger.path",
+];
+
+/**
+ * Watches `path` and applies valid changes to `live` in place. `frozen`
+ * entries are re-copied from `pinned` after every reload so file edits to
+ * construction-captured settings cannot silently diverge: a top-level name
+ * pins the whole block, `block.key` pins one key of it.
  */
 export function watchConfig(
 	path: string,
 	live: RouterConfig,
 	pinned: RouterConfig,
-	frozen: readonly (keyof RouterConfig)[],
+	frozen: readonly string[],
 	opts: WatchConfigOptions = {},
 ): ConfigWatcher {
 	let closed = false;
@@ -119,14 +151,31 @@ export function watchConfig(
 		}
 		lastError = "";
 
-		const frozenSet = new Set(frozen);
+		const frozenBlocks = new Set(frozen.filter((f) => !f.includes(".")));
+		const frozenKeys = new Map<string, string[]>();
+		for (const f of frozen) {
+			const dot = f.indexOf(".");
+			if (dot < 0) continue;
+			const block = f.slice(0, dot);
+			frozenKeys.set(block, [...(frozenKeys.get(block) ?? []), f.slice(dot + 1)]);
+		}
 		const changed: string[] = [];
 		const next = result.cfg as unknown as Record<string, unknown>;
+		const pinnedRec = pinned as unknown as Record<string, unknown>;
 		for (const key of Object.keys(next)) {
-			// Frozen blocks belong to construction: keep the pinned values.
-			const value = frozenSet.has(key as keyof RouterConfig)
-				? (pinned as unknown as Record<string, unknown>)[key]
-				: next[key];
+			// Frozen blocks belong to construction: keep the pinned values. A
+			// partially frozen block takes the file's siblings and the pinned keys.
+			let value = frozenBlocks.has(key) ? pinnedRec[key] : next[key];
+			const keys = frozenKeys.get(key);
+			if (keys !== undefined && !frozenBlocks.has(key) && value !== null && typeof value === "object") {
+				const merged: Record<string, unknown> = { ...(value as Record<string, unknown>) };
+				const pinnedBlock = (pinnedRec[key] ?? {}) as Record<string, unknown>;
+				for (const k of keys) {
+					if (pinnedBlock[k] === undefined) delete merged[k];
+					else merged[k] = pinnedBlock[k];
+				}
+				value = merged;
+			}
 			const before = JSON.stringify((live as unknown as Record<string, unknown>)[key]);
 			const after = JSON.stringify(value);
 			if (before !== after) changed.push(key);

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({
@@ -226,6 +229,7 @@ const ledger = z.strictObject({
 	blendMinSamples: z.number().int().nonnegative().optional(),
 	fallbackBlend: fallbackBlend.optional(),
 	conversationTtlMs: z.number().positive().optional(),
+	retentionDays: z.number().int().nonnegative().optional(),
 });
 
 // Complete entries: arrays replace wholesale, so a partial profile would
@@ -272,7 +276,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 {
@@ -641,6 +657,13 @@ export interface LedgerConfig {
 	fallbackBlend: { inputPerMtok: number; outputPerMtok: number };
 	/** Drop conversation state untouched for longer than this, ms. */
 	conversationTtlMs: number;
+	/**
+	 * Delete ledger rows older than this many days (checked hourly). 0 keeps
+	 * everything. The ledger grows ~2.5 MB a day under steady use; trust,
+	 * reports and replay only read windows well inside a year. Freed pages
+	 * are reused, so the file stops growing rather than shrinking.
+	 */
+	retentionDays: number;
 }
 
 /**
@@ -746,6 +769,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;
 }