auto-model-router 0.4.1 → 0.4.2

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.2",
     "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.2",
       "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).
@@ -777,6 +780,30 @@ 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 |

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

package/src/cli/config-wizard.ts

@@ -310,6 +310,21 @@ 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" }],

package/src/config/defaults.ts

@@ -292,6 +292,19 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		elideSupersededReads: true,
 		collapseDuplicateResults: true,
 	},
+	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"],

package/src/config/schema.ts

@@ -273,6 +273,20 @@ export const configInputSchema = z.strictObject({
 	budget: budget.optional(),
 	profiles: z.array(profile).optional(),
 	report: z.strictObject({ baselines: z.array(z.string()).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(),

package/src/config/types.ts

@@ -554,6 +554,32 @@ export interface CacheConfig {
 	milestoneTokens: number;
 }
 
+/**
+ * Tool-result digest: a cheap model condenses large tool outputs before an
+ * expensive one reads them (see server/digest.ts and the router-digest omp
+ * extension).
+ */
+export interface DigestConfig {
+	/** Master switch; the omp extension polls this as its policy. */
+	enabled: boolean;
+	/** Tool results smaller than this pass through untouched. */
+	minBytes: number;
+	/** Results larger than this are left alone (too costly even for a cheap model). */
+	maxBytes: number;
+	/** Tool names (lower-case) whose results may be digested. Never errors, never edits/writes. */
+	tools: string[];
+	/** Digest only when the session's current model is at or above this tier. */
+	fromTier: Tier;
+	/** Tier the digest model is picked from (cheapest candidate that fits). */
+	tier: Tier;
+	/** Pin a specific digest model; empty ⇒ pick from `tier`. */
+	model: string;
+	maxOutputTokens: number;
+	/** Skip when the digest itself would cost more than this, USD. */
+	maxCostUsd: number;
+	timeoutMs: number;
+}
+
 /** Usage-report options. */
 export interface ReportConfig {
 	/**
@@ -741,6 +767,7 @@ export interface RouterConfig {
 	compaction: CompactionConfig;
 	budget: BudgetConfig;
 	report: ReportConfig;
+	digest: DigestConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**

package/src/cost/ledger.ts

@@ -351,7 +351,8 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 	const providerSpendStmt = db.query(
 		"SELECT COALESCE(SUM(COALESCE(reported_usd, predicted_usd)), 0) AS total FROM ledger WHERE created_at_ms >= ? AND COALESCE(served_slug, slug) LIKE ?",
 	);
-	const sessionStmt = db.query("SELECT * FROM ledger WHERE omp_session_id = ? AND wasted = 0 ORDER BY created_at_ms DESC LIMIT ?");
+	// Digest rows (requested_model 'digest') are side calls, not the session's turns.
+	const sessionStmt = db.query("SELECT * FROM ledger WHERE omp_session_id = ? AND wasted = 0 AND requested_model <> 'digest' ORDER BY created_at_ms DESC LIMIT ?");
 	// What an escalated retry actually bills, per prompt token, over a window.
 	// attempt > 0 rows are the re-dispatches that followed a rejected attempt;
 	// errored ones carry no usage and are excluded.

package/src/cost/report.ts

@@ -30,6 +30,10 @@ export interface ReportTotals {
 	/** Turns from omp subagents (`features.isSubagent`), and their spend. */
 	subagentDispatches: number;
 	subagentSpendUsd: number;
+	/** Tool-result digests (requestedModel "digest"): count, what they cost, bytes they condensed. */
+	digests: number;
+	digestSpendUsd: number;
+	digestInputTokens: number;
 }
 
 export interface ReportRow {
@@ -201,6 +205,9 @@ export function buildUsageReport(
 				SUM(CASE WHEN ${EST} THEN 1 ELSE 0 END) AS estimated_rows,
 				SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN 1 ELSE 0 END) AS subagent_rows,
 				COALESCE(SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN ${USD} ELSE 0 END), 0) AS subagent_spend,
+				SUM(CASE WHEN requested_model = 'digest' THEN 1 ELSE 0 END) AS digests,
+				COALESCE(SUM(CASE WHEN requested_model = 'digest' THEN ${USD} ELSE 0 END), 0) AS digest_spend,
+				COALESCE(SUM(CASE WHEN requested_model = 'digest' THEN ${PT} ELSE 0 END), 0) AS digest_input,
 				SUM(CASE WHEN escalation_signal IS NOT NULL THEN 1 ELSE 0 END) AS escalations,
 				SUM(CASE WHEN instr(reasons, 'failover:') > 0 THEN 1 ELSE 0 END) AS failovers,
 				SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) AS errors,
@@ -217,6 +224,9 @@ export function buildUsageReport(
 		estimated_rows: number | null;
 		subagent_rows: number | null;
 		subagent_spend: number;
+		digests: number | null;
+		digest_spend: number;
+		digest_input: number;
 		escalations: number | null;
 		failovers: number | null;
 		errors: number | null;
@@ -336,6 +346,9 @@ export function buildUsageReport(
 			cacheEstimated: (t.estimated_rows ?? 0) > 0,
 			subagentDispatches: t.subagent_rows ?? 0,
 			subagentSpendUsd: t.subagent_spend,
+			digests: t.digests ?? 0,
+			digestSpendUsd: t.digest_spend,
+			digestInputTokens: t.digest_input,
 		},
 		providers,
 		models,
@@ -400,6 +413,9 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 				.join(" · ")}`,
 		);
 	}
+	if (t.digests > 0) {
+		summary.push(`digests: ${num(t.digests)} tool results condensed (${num(t.digestInputTokens)} tok read by a cheap model) for ${usd(t.digestSpendUsd)}`);
+	}
 	if (t.subagentDispatches > 0) {
 		summary.push(`subagents: ${num(t.subagentDispatches)} dispatches, ${usd(t.subagentSpendUsd)} (${pct(t.spendUsd > 0 ? t.subagentSpendUsd / t.spendUsd : 0)} of spend)`);
 	}

package/src/server/digest.ts

@@ -0,0 +1,233 @@
+/**
+ * Tool-result digest: a cheap model condenses a large tool output before it
+ * reaches an expensive one.
+ *
+ * Prompt anatomy showed tool results are the bulk of every prompt, and a
+ * prompt is ~96% of spend. A 60KB file read on a hard-tier turn is re-read
+ * by that model on every later turn of the conversation, cached or not.
+ * When the omp extension sees a large read/grep/glob/bash result while the
+ * session's current model sits at or above `digest.fromTier`, it sends the
+ * text here; a simple-tier model rewrites it to what the task needs — exact
+ * paths, line numbers, names, errors, code that would be edited — and the
+ * digest replaces the tool result. The marker on top says how to get the
+ * full output back (re-run the tool, or read a line range), so nothing is
+ * lost, only deferred.
+ *
+ * Guarded: never on errors, never below `minBytes`, never above `maxBytes`,
+ * never past `maxCostUsd`, and every digest is a ledger row
+ * (requestedModel "digest") so the report shows what it cost and saved.
+ */
+
+import type { CatalogModel, CatalogSource } from "../catalog/types.ts";
+import type { DigestConfig, RouterConfig } from "../config/types.ts";
+import { computeCost, forecast } from "../cost/forecast.ts";
+import type { Ledger, LedgerEntry } from "../cost/types.ts";
+import { buildCandidates } from "../router/candidates.ts";
+import { extractFeatures } from "../router/features.ts";
+import { TIER_ORDER, type Tier } from "../router/types.ts";
+import { estimateTokens } from "../tokens/estimate.ts";
+import type { UpstreamClient } from "../upstream/types.ts";
+import type { Logger } from "../util/log.ts";
+import type { NormRequest } from "../wire/types.ts";
+
+export interface DigestRequest {
+	ompSessionId: string;
+	harnessId: string;
+	toolName: string;
+	/** The tool's arguments, echoed into the marker so the model can re-run it. */
+	input: Record<string, unknown>;
+	content: string;
+	/** The user's current ask, so the digest keeps what matters for it. */
+	query: string;
+}
+
+export type DigestResult =
+	| { digested: true; text: string; model: string; usd: number; inputBytes: number; outputChars: number; ms: number }
+	| { digested: false; reason: string };
+
+export interface DigesterDeps {
+	cfg: RouterConfig;
+	catalog: CatalogSource;
+	ledger: Ledger;
+	upstream: UpstreamClient;
+	log: Logger;
+}
+
+const DIGEST_SYSTEM = `You condense tool output for a coding agent that is mid-task. Keep everything the task could need: exact file paths, line numbers, identifiers, signatures, error text, counts and values. Quote verbatim, with line numbers, any code the agent is likely to edit or reference. Drop repetition, boilerplate, generated noise and unrelated regions. Never invent content. Plain text only, no preamble. First line: one sentence saying what was omitted and roughly how much.`;
+
+const tierIdx = (t: string): number => TIER_ORDER.indexOf(t as Tier);
+
+/** Whether a session's current model is expensive enough for a digest to pay off. */
+export function digestApplies(cfg: DigestConfig, toolName: string, bytes: number, isError: boolean, currentTier: string | null): { ok: true } | { ok: false; reason: string } {
+	if (!cfg.enabled) return { ok: false, reason: "digest disabled" };
+	if (isError) return { ok: false, reason: "error results are never digested" };
+	if (!cfg.tools.includes(toolName.toLowerCase())) return { ok: false, reason: `tool ${toolName} not in digest.tools` };
+	if (bytes < cfg.minBytes) return { ok: false, reason: `${bytes} bytes < minBytes ${cfg.minBytes}` };
+	if (bytes > cfg.maxBytes) return { ok: false, reason: `${bytes} bytes > maxBytes ${cfg.maxBytes}` };
+	if (currentTier === null) return { ok: false, reason: "no routed turn in this session yet" };
+	if (tierIdx(currentTier) < tierIdx(cfg.fromTier)) return { ok: false, reason: `session is on ${currentTier}, below digest.fromTier ${cfg.fromTier}` };
+	return { ok: true };
+}
+
+/** The line that replaces the raw output's head: what happened and how to undo it. */
+export function digestMarker(toolName: string, input: Record<string, unknown>, model: string, inputBytes: number, outputChars: number): string {
+	const args = JSON.stringify(input);
+	const shownArgs = args.length > 160 ? `${args.slice(0, 159)}…` : args;
+	return `[digest: ${toolName} output ${inputBytes.toLocaleString("en-US")} bytes → ${outputChars.toLocaleString("en-US")} chars by ${model}. Full output: re-run ${toolName} ${shownArgs}${toolName === "read" ? " (offset/limit for a range)" : ""}]`;
+}
+
+function syntheticRequest(req: DigestRequest, promptText: string): NormRequest {
+	const bytes = Buffer.byteLength(promptText);
+	return {
+		protocol: "openai-chat",
+		conversationKey: `digest:${req.ompSessionId}`,
+		harnessId: req.harnessId,
+		ompSessionId: req.ompSessionId,
+		agentdoxScope: "",
+		isSubagent: true,
+		requestedModel: "digest",
+		messages: [
+			{ role: "system", text: DIGEST_SYSTEM, images: 0, textBytes: Buffer.byteLength(DIGEST_SYSTEM), toolCalls: [] },
+			{ role: "user", text: promptText, images: 0, textBytes: bytes, toolCalls: [] },
+		],
+		tools: [],
+		forcedToolChoice: false,
+		stream: false,
+		hasImages: false,
+		promptBytes: bytes + Buffer.byteLength(DIGEST_SYSTEM),
+		renderUpstreamBody: () => ({}),
+	};
+}
+
+export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest): Promise<DigestResult> } {
+	const { cfg, catalog, ledger, upstream, log } = deps;
+
+	/** Cheapest simple-tier model that fits the prompt, or the configured one. */
+	async function pickModel(req: NormRequest, promptTokens: number): Promise<CatalogModel | null> {
+		const snapshot = await catalog.get();
+		if (cfg.digest.model !== "") return snapshot.models.find((m) => m.slug === cfg.digest.model) ?? null;
+		const features = extractFeatures(req, promptTokens);
+		for (const relaxLevel of [0, 1, 2]) {
+			const built = buildCandidates({
+				req,
+				features,
+				tier: cfg.digest.tier,
+				task: "documentation",
+				snapshot,
+				ledger,
+				cfg,
+				expectedCompletionTokens: cfg.digest.maxOutputTokens,
+				warmSlug: null,
+				relaxLevel,
+			});
+			const first = built.candidates[0];
+			if (first !== undefined) return first.model;
+		}
+		return null;
+	}
+
+	return {
+		async digest(req) {
+			const inputBytes = Buffer.byteLength(req.content);
+			const currentTier = ledger.latestForSession?.(req.ompSessionId)?.tier ?? null;
+			const applies = digestApplies(cfg.digest, req.toolName, inputBytes, false, currentTier);
+			if (!applies.ok) return { digested: false, reason: applies.reason };
+
+			const promptText = `Task: ${req.query === "" ? "(unknown)" : req.query}\nTool: ${req.toolName} ${JSON.stringify(req.input)}\n--- output ---\n${req.content}`;
+			const synthetic = syntheticRequest(req, promptText);
+			const promptTokens = estimateTokens(synthetic.promptBytes, "unknown", ledger);
+			const model = await pickModel(synthetic, promptTokens);
+			if (model === null) return { digested: false, reason: "no digest model available" };
+			const est = forecast(model, { promptTokens, completionTokens: cfg.digest.maxOutputTokens, cacheHitRate: 0, images: 0 });
+			if (est.coldUsd > cfg.digest.maxCostUsd) {
+				return { digested: false, reason: `estimated $${est.coldUsd.toFixed(4)} on ${model.slug} exceeds digest.maxCostUsd $${cfg.digest.maxCostUsd}` };
+			}
+
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), cfg.digest.timeoutMs);
+			const startedAt = Date.now();
+			let text = "";
+			let costUsd: number | null = null;
+			let error: string | null = null;
+			try {
+				const out = await upstream.complete(
+					{
+						model: model.slug,
+						stream: false,
+						max_tokens: cfg.digest.maxOutputTokens,
+						temperature: 0,
+						messages: [
+							{ role: "system", content: DIGEST_SYSTEM },
+							{ role: "user", content: promptText },
+						],
+					},
+					controller.signal,
+				);
+				text = out.text.trim();
+				costUsd = out.costUsd;
+			} catch (err) {
+				error = err instanceof Error ? err.message : String(err);
+			} finally {
+				clearTimeout(timer);
+			}
+			const ms = Date.now() - startedAt;
+			const completionTokens = estimateTokens(Buffer.byteLength(text), model.tokenizer, ledger);
+			const usage = { promptTokens, cachedTokens: 0, cacheWriteTokens: 0, completionTokens, reasoningTokens: 0, images: 0 };
+			const usd = costUsd ?? computeCost(model, usage).total;
+
+			// Every digest is a ledger row: the report shows its cost beside the
+			// prompt tokens it kept out of the expensive model.
+			const entry: LedgerEntry = {
+				id: crypto.randomUUID(),
+				createdAtMs: startedAt,
+				conversationKey: synthetic.conversationKey,
+				sessionId: `digest-${req.ompSessionId}`,
+				turn: 1,
+				requestedModel: "digest",
+				harnessId: req.harnessId,
+				ompSessionId: req.ompSessionId,
+				slug: model.slug,
+				servedSlug: model.slug,
+				tier: cfg.digest.tier,
+				classificationSource: "forced",
+				reasons: [`digest: ${req.toolName} ${inputBytes} bytes → ${text.length} chars for a ${currentTier} session`],
+				features: null,
+				score: null,
+				confidence: null,
+				task: "documentation",
+				classifierReasons: null,
+				exploredFrom: null,
+				holdArm: null,
+				predictedUsd: est.expectedUsd,
+				reportedUsd: error === null ? usd : null,
+				usage,
+				attempt: 0,
+				escalationSignal: null,
+				latencyMs: ms,
+				ttftMs: null,
+				finishReason: error === null ? "stop" : null,
+				wasted: false,
+				upstreamGenerationId: null,
+				error,
+				promptTokensSaved: 0,
+				priceModel: model,
+			};
+			try {
+				ledger.record(entry);
+			} catch (err) {
+				log.debug("digest ledger record failed", { error: err instanceof Error ? err.message : String(err) });
+			}
+			if (error !== null) return { digested: false, reason: `digest model failed: ${error}` };
+			if (text === "" || text.length >= inputBytes * 0.9) return { digested: false, reason: "digest did not shrink the output" };
+			return {
+				digested: true,
+				text: `${digestMarker(req.toolName, req.input, model.slug, inputBytes, text.length)}\n${text}`,
+				model: model.slug,
+				usd,
+				inputBytes,
+				outputChars: text.length,
+				ms,
+			};
+		},
+	};
+}

package/src/server/http.ts

@@ -6,6 +6,7 @@ import { createBridgeFromConfig } from "../context/index.ts";
 import { createFeedbackStore, type Verdict } from "../cost/feedback.ts";
 import { createLedger } from "../cost/ledger.ts";
 import { createSessionOverrides } from "./overrides.ts";
+import { createDigester } from "./digest.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport } from "../cost/report.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
@@ -194,6 +195,7 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	const context = createBridgeFromConfig(cfg, db);
 	const overrides = createSessionOverrides();
 	const feedback = createFeedbackStore(db);
+	const digester = createDigester({ cfg, catalog, ledger, upstream, log });
 	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context, overrides, ollamaCostScale };
 
 	// Hot reload: ranking knobs (tiers, filters, escalation, budgets, …) take
@@ -436,6 +438,26 @@ export function startServer(cfg: RouterConfig): StartedServer {
 						return json({ override: set });
 					}
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/digest/policy") {
+					const d = cfg.digest;
+					return json({ enabled: d.enabled, minBytes: d.minBytes, maxBytes: d.maxBytes, tools: d.tools, fromTier: d.fromTier });
+				}
+				if (req.method === "POST" && url.pathname === "/v1/router/digest") {
+					const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;
+					if (body === null || typeof body.content !== "string" || typeof body.toolName !== "string") {
+						return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "toolName and content required" });
+					}
+					return json(
+						await digester.digest({
+							ompSessionId: typeof body.ompSessionId === "string" ? body.ompSessionId : "",
+							harnessId: typeof body.harnessId === "string" ? body.harnessId : "",
+							toolName: body.toolName,
+							input: typeof body.input === "object" && body.input !== null ? (body.input as Record<string, unknown>) : {},
+							content: body.content,
+							query: typeof body.query === "string" ? body.query : "",
+						}),
+					);
+				}
 				if (req.method === "POST" && url.pathname === "/v1/router/feedback") {
 					// A user verdict on the newest routed turn of an omp session.
 					const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;

package/test/controls.test.ts

@@ -236,3 +236,37 @@ describe("subagent profile", () => {
 		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
 	});
 });
+
+describe("digest endpoints", () => {
+	let handle: StartedServer;
+	let baseUrl = "";
+	beforeAll(() => {
+		const cfg: RouterConfig = {
+			...structuredClone(DEFAULT_CONFIG),
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
+			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
+			logLevel: "silent",
+		};
+		cfg.digest = { ...cfg.digest, enabled: true, minBytes: 10 };
+		handle = startServer(cfg);
+		baseUrl = `http://127.0.0.1:${handle.server.port}`;
+	});
+	afterAll(async () => {
+		await handle.stop();
+	});
+
+	test("policy reflects the config; a digest for a session with no turns is declined, a bad body rejected", async () => {
+		const policy = (await (await fetch(`${baseUrl}/v1/router/digest/policy`)).json()) as { enabled: boolean; minBytes: number; tools: string[] };
+		expect(policy.enabled).toBe(true);
+		expect(policy.minBytes).toBe(10);
+		expect(policy.tools).toContain("read");
+		const bad = await fetch(`${baseUrl}/v1/router/digest`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ toolName: "read" }) });
+		expect(bad.status).toBe(400);
+		const res = await fetch(`${baseUrl}/v1/router/digest`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ ompSessionId: "never", toolName: "read", input: {}, content: "x".repeat(100), query: "q" }),
+		});
+		expect((await res.json()) as unknown).toMatchObject({ digested: false, reason: "no routed turn in this session yet" });
+	});
+});

package/test/digest.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, test } from "bun:test";
+
+import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
+import type { CatalogModel, CatalogSnapshot, CatalogSource } from "../src/catalog/types.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { createLedger } from "../src/cost/ledger.ts";
+import type { LedgerEntry } from "../src/cost/types.ts";
+import { createDigester, digestApplies, digestMarker } from "../src/server/digest.ts";
+import type { UpstreamClient } from "../src/upstream/types.ts";
+import { createLogger } from "../src/util/log.ts";
+import { openDb } from "../src/util/sqlite.ts";
+import { digestToast, parsePolicy, shouldSend, textOf } from "../omp-extension/digest-logic.ts";
+
+/**
+ * The tool-result digest: gates (tool, size, error, session tier, cost),
+ * model choice from the cheap tier, the marker that keeps the full output
+ * reachable, the ledger row every digest leaves, and the extension's
+ * client-side checks.
+ */
+
+const FIXTURE = (await Bun.file("test/fixtures/openrouter-models.json").json()) as { data: unknown[] };
+const MODELS: CatalogModel[] = FIXTURE.data.map(normalizeCatalogModel).filter((m): m is CatalogModel => m !== null);
+const SNAPSHOT: CatalogSnapshot = { models: MODELS, fetchedAtMs: Date.now() };
+const catalog: CatalogSource = {
+	get: async () => SNAPSHOT,
+	refresh: async () => SNAPSHOT,
+	peek: () => SNAPSHOT,
+	find: (slug) => MODELS.find((m) => m.slug === slug),
+};
+const log = createLogger("silent");
+
+function cfgWith(over: Partial<RouterConfig["digest"]> = {}): RouterConfig {
+	const cfg = structuredClone(DEFAULT_CONFIG);
+	cfg.ledger.path = ":memory:";
+	cfg.digest = { ...cfg.digest, enabled: true, minBytes: 100, ...over };
+	return cfg;
+}
+
+function seedSession(ledger: ReturnType<typeof createLedger>, tier: string): void {
+	const e: LedgerEntry = {
+		id: crypto.randomUUID(),
+		createdAtMs: Date.now(),
+		conversationKey: "k",
+		sessionId: "s",
+		turn: 3,
+		requestedModel: "auto",
+		harnessId: "",
+		ompSessionId: "omp-1",
+		slug: "x/y",
+		servedSlug: "x/y",
+		tier,
+		classificationSource: "heuristic",
+		reasons: [],
+		features: null,
+		score: null,
+		confidence: null,
+		task: null,
+		classifierReasons: null,
+		exploredFrom: null,
+		holdArm: null,
+		predictedUsd: 0.01,
+		reportedUsd: 0.01,
+		usage: { promptTokens: 100, cachedTokens: 0, cacheWriteTokens: 0, completionTokens: 10, reasoningTokens: 0, images: 0 },
+		attempt: 0,
+		escalationSignal: null,
+		latencyMs: 100,
+		ttftMs: 50,
+		finishReason: "stop",
+		wasted: false,
+		upstreamGenerationId: null,
+		error: null,
+		promptTokensSaved: 0,
+	};
+	ledger.record(e);
+}
+
+function fakeUpstream(reply: (body: Record<string, unknown>) => string, costUsd: number | null = 0.0004): { upstream: UpstreamClient; calls: Record<string, unknown>[] } {
+	const calls: Record<string, unknown>[] = [];
+	return {
+		calls,
+		upstream: {
+			dispatch: () => Promise.reject(new Error("not used")),
+			complete: async (body) => {
+				calls.push(body);
+				return { text: reply(body), costUsd };
+			},
+			fetchModels: () => Promise.resolve([]),
+			fetchModelsForUser: () => Promise.resolve([]),
+		},
+	};
+}
+
+const BIG = Array.from({ length: 400 }, (_, i) => `${i + 1}: export const value${i} = ${i};`).join("\n");
+
+describe("digestApplies", () => {
+	const d = { ...DEFAULT_CONFIG.digest, enabled: true, minBytes: 100, maxBytes: 1000 };
+	test("gates on switch, error, tool, size and session tier", () => {
+		expect(digestApplies({ ...d, enabled: false }, "read", 500, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 500, true, "hard").ok).toBe(false);
+		expect(digestApplies(d, "edit", 500, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 50, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 5000, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 500, false, null).ok).toBe(false);
+		expect(digestApplies(d, "read", 500, false, "simple").ok).toBe(false); // below fromTier moderate
+		expect(digestApplies(d, "read", 500, false, "moderate").ok).toBe(true);
+		expect(digestApplies(d, "READ", 500, false, "hard").ok).toBe(true);
+	});
+});
+
+describe("createDigester", () => {
+	test("condenses a large read for a hard-tier session on a cheap model and records a ledger row", async () => {
+		const cfg = cfgWith();
+		const db = openDb(":memory:");
+		const ledger = createLedger(db, cfg);
+		seedSession(ledger, "hard");
+		const { upstream, calls } = fakeUpstream(() => "Omitted 380 trivial constants.\n1: export const value0 = 0;\n...");
+		const d = createDigester({ cfg, catalog, ledger, upstream, log });
+		const r = await d.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: { path: "src/values.ts" }, content: BIG, query: "find value0" });
+		expect(r.digested).toBe(true);
+		if (!r.digested) return;
+		expect(r.text.startsWith("[digest: read output")).toBe(true);
+		expect(r.text).toContain("re-run read {\"path\":\"src/values.ts\"} (offset/limit for a range)");
+		expect(r.text).toContain("Omitted 380 trivial constants.");
+		expect(r.usd).toBeCloseTo(0.0004, 6);
+		// The cheap tier picked the model; the call carried the task and the raw output.
+		const call = calls[0]!;
+		expect(typeof call.model).toBe("string");
+		expect(catalog.find(call.model as string)?.price.prompt).toBeLessThanOrEqual(cfg.tiers.simple.maxInputPerMtok! / 1e6);
+		expect(JSON.stringify(call.messages)).toContain("Task: find value0");
+		// A ledger row under requestedModel "digest" with the served model and its cost.
+		const rows = ledger.recentEntries(10).filter((e) => e.requestedModel === "digest");
+		expect(rows).toHaveLength(1);
+		expect(rows[0]!.slug).toBe(call.model as string);
+		expect(rows[0]!.reportedUsd).toBeCloseTo(0.0004, 6);
+		expect(rows[0]!.ompSessionId).toBe("omp-1");
+		db.close();
+	});
+
+	test("declines below the session tier, over the cost guard, when the model fails, or when nothing shrinks", async () => {
+		const db = openDb(":memory:");
+		const cfg = cfgWith();
+		const ledger = createLedger(db, cfg);
+		seedSession(ledger, "simple");
+		const cheap = createDigester({ cfg, catalog, ledger, upstream: fakeUpstream(() => "short").upstream, log });
+		expect(await cheap.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: expect.stringContaining("below digest.fromTier") });
+
+		const db2 = openDb(":memory:");
+		const strict = cfgWith({ maxCostUsd: 0 });
+		const ledger2 = createLedger(db2, strict);
+		seedSession(ledger2, "hard");
+		expect(await createDigester({ cfg: strict, catalog, ledger: ledger2, upstream: fakeUpstream(() => "x").upstream, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: expect.stringContaining("exceeds digest.maxCostUsd") });
+
+		const failing: UpstreamClient = { ...fakeUpstream(() => "x").upstream, complete: () => Promise.reject(new Error("boom")) };
+		expect(await createDigester({ cfg, catalog, ledger: ledger2, upstream: failing, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: "digest model failed: boom" });
+		// The failed attempt is still a ledger row, with the error.
+		expect(ledger2.recentEntries(5).find((e) => e.requestedModel === "digest")?.error).toBe("boom");
+
+		const same = createDigester({ cfg, catalog, ledger: ledger2, upstream: fakeUpstream(() => BIG).upstream, log });
+		expect(await same.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: "digest did not shrink the output" });
+		db.close();
+		db2.close();
+	});
+
+	test("a pinned digest model is used as-is", async () => {
+		const pinned = MODELS.find((m) => m.price.prompt > 0)!.slug;
+		const cfg = cfgWith({ model: pinned });
+		const db = openDb(":memory:");
+		const ledger = createLedger(db, cfg);
+		seedSession(ledger, "hard");
+		const { upstream, calls } = fakeUpstream(() => "digest");
+		await createDigester({ cfg, catalog, ledger, upstream, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "grep", input: { pattern: "x" }, content: BIG, query: "" });
+		expect(calls[0]?.model as string).toBe(pinned);
+		db.close();
+	});
+});
+
+describe("digest marker and extension logic", () => {
+	test("the marker names the tool, sizes, model and how to get the full output", () => {
+		expect(digestMarker("grep", { pattern: "retry" }, "z-ai/glm-5.3-flash", 48_000, 3_000)).toBe(
+			'[digest: grep output 48,000 bytes → 3,000 chars by z-ai/glm-5.3-flash. Full output: re-run grep {"pattern":"retry"}]',
+		);
+	});
+
+	test("textOf joins text parts and flags images", () => {
+		expect(textOf([{ type: "text", text: "a" }, { type: "text", text: "b" }])).toEqual({ text: "a\nb", hasImage: false });
+		expect(textOf([{ type: "image" }, { type: "text", text: "a" }])).toEqual({ text: "a", hasImage: true });
+	});
+
+	test("shouldSend applies the client-side gate; parsePolicy is defensive", () => {
+		const p = parsePolicy({ enabled: true, minBytes: 10, maxBytes: 100, tools: ["Read", "grep"], fromTier: "hard" });
+		expect(p.tools).toEqual(["read", "grep"]);
+		expect(shouldSend(p, "read", false, "x".repeat(50), false)).toBe(true);
+		expect(shouldSend(p, "read", true, "x".repeat(50), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(50), true)).toBe(false);
+		expect(shouldSend(p, "edit", false, "x".repeat(50), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(5), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(500), false)).toBe(false);
+		expect(parsePolicy({ enabled: false }).enabled).toBe(false);
+		expect(parsePolicy("nope").enabled).toBe(false);
+		expect(parsePolicy({ enabled: true }).minBytes).toBe(12_000);
+	});
+
+	test("digestToast is one readable line", () => {
+		expect(digestToast("read", 48 * 1024, 3 * 1024, "ollama/glm-5.3-flash", 0.00042)).toBe("digested read 48KB → 3KB via glm-5.3-flash ($0.0004)");
+	});
+});

package/test/embed-lifecycle.test.ts

@@ -29,7 +29,7 @@ import type { ExtensionAPI, ExtensionContext, ProviderRegistration } from "@oh-m
  */
 
 const registrations: { id: string; baseUrl: string }[] = [];
-const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => void | Promise<void>)[]>();
+const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => unknown)[]>();
 
 const pi: ExtensionAPI = {
 	setLabel: () => {},

package/test/failover.test.ts

@@ -77,6 +77,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [] },
+		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
 		adaptiveTierFloors: true,

package/test/report-hub.test.ts

@@ -78,6 +78,9 @@ function report(over: Partial<UsageReport> = {}): UsageReport {
 			cacheEstimated: false,
 			subagentDispatches: 0,
 			subagentSpendUsd: 0,
+			digests: 0,
+			digestSpendUsd: 0,
+			digestInputTokens: 0,
 		},
 		providers: [row("openrouter", 2), row("ollama", 1)],
 		models: [

package/test/report.test.ts

@@ -227,6 +227,9 @@ describe("buildUsageReport", () => {
 			cacheEstimated: false,
 			subagentDispatches: 0,
 			subagentSpendUsd: 0,
+			digests: 0,
+			digestSpendUsd: 0,
+			digestInputTokens: 0,
 		});
 		expect(r.providers).toEqual([]);
 		expect(r.models).toEqual([]);

package/test/turn.test.ts

@@ -77,6 +77,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [] },
+		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
 		adaptiveTierFloors: true,