auto-model-router 0.4.1 → 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.1",
+    "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.1",
+      "version": "0.4.3",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -213,6 +213,7 @@ extensions:
   - auto-model-router/omp-extension/router-embed.ts
   - auto-model-router/omp-extension/router-toast.ts      # optional: chosen-model toasts
   - auto-model-router/omp-extension/router-configure.ts # optional: /router config, report, status
+  - auto-model-router/omp-extension/router-digest.ts    # optional: cheap-model digest of large tool results
 ```
 
 ### From the repo (cross-platform installer)
@@ -236,6 +237,7 @@ The installer adds:
 - `router-embed.ts` — **required**; runs the router in-process.
 - `router-toast.ts` — optional; chosen-model toasts.
 - `router-configure.ts` — optional; the `/router` command (configure, usage reports, status).
+- `router-digest.ts` — optional; condenses large tool results with a cheap model before an expensive one reads them (needs `digest.enabled`).
 
 Or add the paths by hand to omp's `~/.omp/agent/config.yml`:
 
@@ -245,6 +247,7 @@ extensions:
   - /path/to/auto-model-router/omp-extension/router-embed.ts
   - /path/to/auto-model-router/omp-extension/router-toast.ts      # optional: chosen-model toasts
   - /path/to/auto-model-router/omp-extension/router-configure.ts # optional: /router config, report, status
+  - /path/to/auto-model-router/omp-extension/router-digest.ts    # optional: cheap-model digest of large tool results
 ```
 
 Then restart the omp session (extensions load at session start).
@@ -494,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:
 
@@ -507,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
@@ -531,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. |
@@ -665,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. |
@@ -681,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. |
@@ -745,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
 
@@ -777,11 +798,36 @@ Each profile is a complete entry (arrays replace wholesale):
 | `maxTokens` | `32000` | Advertised max output tokens. |
 | `budget` | unset | Per-profile budget overrides. |
 
+### `digest` — cheap-model digest of large tool results
+
+Tool results are the bulk of every prompt (see the report's prompt anatomy),
+and a prompt is ~96% of spend. With the `router-digest` extension installed
+and `digest.enabled` on, a large read, grep, glob or bash result produced
+while the session's current model is at or above `fromTier` is sent to
+`POST /v1/router/digest`; the cheapest `tier` model rewrites it to what the
+task needs (exact paths, line numbers, names, errors, code to be edited) and
+the digest replaces the tool result. It begins with a marker naming the tool
+and arguments to re-run for the full output, so nothing is lost, only
+deferred. Errors, images, edits and writes are never digested. Every digest
+is a ledger row (`requestedModel` `digest`) and the report totals them.
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `enabled` | `false` | Master switch; the extension polls it every minute. |
+| `minBytes` / `maxBytes` | `12000` / `400000` | Result size window that gets digested. |
+| `tools` | `read, grep, glob, bash, web_fetch, webfetch, ls, find` | Eligible tool names (lower-case). |
+| `fromTier` | `moderate` | Digest only when the session's current model is at or above this tier. |
+| `tier` / `model` | `simple` / unset | Where the digest model is picked from, or a pinned slug. |
+| `maxOutputTokens` | `700` | Digest length cap. |
+| `maxCostUsd` | `0.02` | Skip when the digest itself would cost more. |
+| `timeoutMs` | `25000` | The raw result stands if the cheap model is slower. |
+
 ### `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
 

package/omp-extension/digest-logic.ts

@@ -0,0 +1,53 @@
+/**
+ * Pure logic for the tool-result digest extension: which results to send,
+ * how to read a tool result's text, and how to shape the replacement.
+ */
+
+export interface DigestPolicy {
+	enabled: boolean;
+	minBytes: number;
+	maxBytes: number;
+	tools: string[];
+	fromTier: string;
+}
+
+export const DISABLED_POLICY: DigestPolicy = { enabled: false, minBytes: 0, maxBytes: 0, tools: [], fromTier: "hard" };
+
+/** The text of a tool result's content parts; images are left alone (and block digesting). */
+export function textOf(content: ReadonlyArray<{ type: string; text?: string }>): { text: string; hasImage: boolean } {
+	let text = "";
+	let hasImage = false;
+	for (const part of content) {
+		if (part.type === "text" && typeof part.text === "string") text += (text === "" ? "" : "\n") + part.text;
+		else if (part.type === "image") hasImage = true;
+	}
+	return { text, hasImage };
+}
+
+/** Client-side gate: cheap checks before anything is sent to the router. */
+export function shouldSend(policy: DigestPolicy, toolName: string, isError: boolean, text: string, hasImage: boolean): boolean {
+	if (!policy.enabled || isError || hasImage) return false;
+	if (!policy.tools.includes(toolName.toLowerCase())) return false;
+	const bytes = Buffer.byteLength(text);
+	return bytes >= policy.minBytes && bytes <= policy.maxBytes;
+}
+
+/** Parses the router's policy payload defensively; anything odd ⇒ disabled. */
+export function parsePolicy(json: unknown): DigestPolicy {
+	if (typeof json !== "object" || json === null) return DISABLED_POLICY;
+	const p = json as Record<string, unknown>;
+	if (p.enabled !== true) return DISABLED_POLICY;
+	return {
+		enabled: true,
+		minBytes: typeof p.minBytes === "number" ? p.minBytes : 12_000,
+		maxBytes: typeof p.maxBytes === "number" ? p.maxBytes : 400_000,
+		tools: Array.isArray(p.tools) ? p.tools.filter((t): t is string => typeof t === "string").map((t) => t.toLowerCase()) : [],
+		fromTier: typeof p.fromTier === "string" ? p.fromTier : "hard",
+	};
+}
+
+/** One-line toast for a digest that happened. */
+export function digestToast(toolName: string, inputBytes: number, outputChars: number, model: string, usd: number): string {
+	const kb = (n: number): string => `${(n / 1024).toFixed(0)}KB`;
+	return `digested ${toolName} ${kb(inputBytes)} → ${kb(outputChars)} via ${model.replace(/^ollama\//, "")} ($${usd.toFixed(4)})`;
+}

package/omp-extension/pi-coding-agent.d.ts

@@ -127,9 +127,22 @@ declare module "@oh-my-pi/pi-coding-agent" {
 		details?: unknown;
 	}
 
+	/** A tool result's content parts (text and images). */
+	export interface ToolResultPart {
+		type: string;
+		text?: string;
+	}
+
+	/** What a `tool_result` handler may return to replace the result. */
+	export interface ToolResultEventResult {
+		content?: ToolResultPart[];
+		isError?: boolean;
+	}
+
 	export interface ExtensionAPI {
 		setLabel(label: string): void;
-		on(event: string, handler: (event: unknown, ctx: ExtensionContext) => void | Promise<void>): void;
+		/** Handlers may return an event result (e.g. a `tool_result` replacement); omp ignores it where none applies. */
+		on(event: string, handler: (event: unknown, ctx: ExtensionContext) => unknown): void;
 		registerProvider(id: string, registration: ProviderRegistration): void;
 		unregisterProvider(id: string): void;
 		registerCommand(name: string, command: CommandDefinition): void;

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/omp-extension/router-digest.ts

@@ -0,0 +1,93 @@
+/**
+ * omp extension: condense large tool results with a cheap model before an
+ * expensive one reads them.
+ *
+ * Tool results are the bulk of every prompt, and a prompt is ~96% of spend.
+ * When a read, grep, glob or bash result is large and this session's
+ * current model sits at or above the router's `digest.fromTier`, the raw
+ * text goes to the router's `/v1/router/digest`, a simple-tier model
+ * rewrites it to what the task needs, and the digest replaces the tool
+ * result. The digest starts with a marker saying how to get the full output
+ * back (re-run the tool, or read a line range), so nothing is lost.
+ *
+ * The router decides (policy, session tier, cost guard); this extension only
+ * ships text that passes the cheap client-side checks. Off unless
+ * `digest.enabled` is set in the router config.
+ *
+ * Install beside router-embed.ts:
+ *
+ *   # ~/.omp/agent/config.yml
+ *   extensions:
+ *     - /path/to/auto-model-router/omp-extension/router-embed.ts
+ *     - /path/to/auto-model-router/omp-extension/router-digest.ts
+ */
+
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+
+import { DISABLED_POLICY, digestToast, parsePolicy, shouldSend, textOf, type DigestPolicy } from "./digest-logic.ts";
+import { routerAuthHeaders, routerBaseUrl } from "./router-url.ts";
+
+const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "";
+/** Re-read the policy this often, so a config change lands without a restart. */
+const POLICY_TTL_MS = 60_000;
+
+export default function (pi: ExtensionAPI): void {
+	pi.setLabel("auto-model-router digest");
+
+	let policy: DigestPolicy = DISABLED_POLICY;
+	let policyAtMs = 0;
+	let lastUserText = "";
+
+	async function refreshPolicy(): Promise<void> {
+		if (Date.now() - policyAtMs < POLICY_TTL_MS) return;
+		policyAtMs = Date.now();
+		try {
+			const res = await fetch(`${routerBaseUrl()}/v1/router/digest/policy`, { headers: routerAuthHeaders(), signal: AbortSignal.timeout(2_000) });
+			policy = res.ok ? parsePolicy(await res.json()) : DISABLED_POLICY;
+		} catch {
+			policy = DISABLED_POLICY;
+		}
+	}
+
+	pi.on("session_start", async () => {
+		policyAtMs = 0;
+		await refreshPolicy();
+	});
+
+	// The user's latest ask steers what the digest keeps.
+	pi.on("input", (event) => {
+		const e = event as { text?: string };
+		if (typeof e.text === "string" && e.text.trim() !== "") lastUserText = e.text.trim().slice(0, 400);
+		return undefined;
+	});
+
+	pi.on("tool_result", async (event, ctx) => {
+		const e = event as { toolName: string; input: Record<string, unknown>; content: Array<{ type: string; text?: string }>; isError: boolean };
+		await refreshPolicy();
+		const { text, hasImage } = textOf(e.content);
+		if (!shouldSend(policy, e.toolName, e.isError, text, hasImage)) return undefined;
+		try {
+			const res = await fetch(`${routerBaseUrl()}/v1/router/digest`, {
+				method: "POST",
+				headers: { ...routerAuthHeaders(), "content-type": "application/json" },
+				body: JSON.stringify({
+					ompSessionId: ctx.sessionManager.getSessionId(),
+					harnessId: HARNESS_ID,
+					toolName: e.toolName,
+					input: e.input,
+					content: text,
+					query: lastUserText,
+				}),
+				signal: AbortSignal.timeout(30_000),
+			});
+			if (!res.ok) return undefined;
+			const r = (await res.json()) as { digested: boolean; text?: string; model?: string; usd?: number; inputBytes?: number; outputChars?: number };
+			if (!r.digested || typeof r.text !== "string") return undefined;
+			if (ctx.hasUI) ctx.ui.notify(digestToast(e.toolName, r.inputBytes ?? 0, r.outputChars ?? 0, r.model ?? "?", r.usd ?? 0), "info");
+			return { content: [{ type: "text", text: r.text }] };
+		} catch {
+			// Router unreachable or slow: the raw result stands.
+			return undefined;
+		}
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.4.1",
+  "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 },
 		],
 	},
 	{
@@ -310,9 +313,27 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "budget.onExceeded", label: "On exceeded", kind: "enum", options: ["downgrade", "reject"] },
 		],
 	},
+	{
+		title: "Digest",
+		fields: [
+			{ path: "digest.enabled", label: "Digest large tool results with a cheap model", kind: "boolean" },
+			{ path: "digest.minBytes", label: "Min result bytes", kind: "number", min: 0 },
+			{ path: "digest.maxBytes", label: "Max result bytes", kind: "number", min: 1 },
+			{ path: "digest.tools", label: "Tools eligible", kind: "stringArray", hint: "comma-separated, lower-case" },
+			{ path: "digest.fromTier", label: "Digest when the session is at or above", kind: "enum", options: TIER_NAMES },
+			{ path: "digest.tier", label: "Pick the digest model from tier", kind: "enum", options: TIER_NAMES },
+			{ path: "digest.model", label: "Pinned digest model", kind: "string", optional: true, hint: "blank = cheapest in tier" },
+			{ path: "digest.maxOutputTokens", label: "Max digest tokens", kind: "number", min: 1 },
+			{ path: "digest.maxCostUsd", label: "Max cost per digest $", kind: "number", min: 0 },
+			{ path: "digest.timeoutMs", label: "Digest timeout", kind: "number", min: 1, hint: "ms" },
+		],
+	},
 	{
 		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,10 +292,29 @@ 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.
+		enabled: false,
+		minBytes: 12_000,
+		maxBytes: 400_000,
+		tools: ["read", "grep", "glob", "bash", "web_fetch", "webfetch", "ls", "find"],
+		fromTier: "moderate",
+		tier: "simple",
+		model: "",
+		maxOutputTokens: 700,
+		maxCostUsd: 0.02,
+		timeoutMs: 25_000,
 	},
 	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,21 @@ 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(),
+			minBytes: z.number().int().nonnegative().optional(),
+			maxBytes: z.number().int().positive().optional(),
+			tools: z.array(z.string()).optional(),
+			fromTier: tier.optional(),
+			tier: tier.optional(),
+			model: z.string().optional(),
+			maxOutputTokens: z.number().int().positive().optional(),
+			maxCostUsd: z.number().nonnegative().optional(),
+			timeoutMs: z.number().int().positive().optional(),
+		})
+		.optional(),
 	ledger: ledger.optional(),
 	adaptiveTierFloors: z.boolean().optional(),
 	adaptivePriceCeilings: z.boolean().optional(),