auto-model-router 0.4.0 → 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.0",
+    "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.0",
+      "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).
@@ -499,7 +502,7 @@ What it shows, for the window:
 
 | Block | Columns |
 | --- | --- |
-| totals | spend, dispatches, conversations, $/dispatch, prompt and completion tokens, cache hit rate, model switches, escalations, failovers, errors (aborted separately) |
+| totals | spend, dispatches, conversations, $/dispatch, prompt and completion tokens, cache hit rate, model switches, escalations, failovers, errors (aborted separately), subagent dispatches and their share of spend |
 | prompt anatomy | mean share of prompt bytes by role (tool results, assistant, user, system), tool schemas beside them, the older half of the conversation, and tool results older than the newest 20 messages — what compaction can reach. Recorded per turn from v0.3.5. |
 | providers | per upstream (`openrouter`, `ollama`): dispatches, spend, share, cache hit, mean TTFT, tokens/s, escalations, errors |
 | models | per served slug (top 12 by spend): the same plus user feedback (`+good/-bad` from `/router good\|bad`) and the tier mix it was routed for |
@@ -592,6 +595,7 @@ what each one does. All values are optional; omit a key to use its default.
 | `host` | `127.0.0.1` | Bind address. `0.0.0.0`/`::` listen on all interfaces (the provider still advertises loopback). |
 | `port` | `0` | Bind port. `0` = let the OS pick a free ephemeral port (the embedded router's default). |
 | `apiKey` | unset | Optional client bearer token. When set, every request must send `Authorization: Bearer <key>`. |
+| `subagentProfile` | `auto-sub` | Profile omp subagents are routed under when they ask for the default one. The embed extension marks sessions without a UI with `X-Omp-Subagent: 1`; delegated work (reads, searches, summaries) never needs the top tier. Empty disables the remap. |
 | `harnessId` | unset | Harness identity sent as `X-Omp-Harness`; scopes per-harness daily budgets and toasts. |
 
 ### `openrouter`
@@ -663,6 +667,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `deny` | `[]` | Glob denylist; matching slugs are excluded. |
 | `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. |
 | `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. |
@@ -688,6 +693,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `toolAxis` | `coding` | Quality axis for tool-heavy turns. |
 | `chatAxis` | `intelligence` | Quality axis for chat turns. |
 | `agenticLoopDepth` | `3` | Tool-loop depth at which a turn is treated as agentic. |
+| `readOnlyToolWeight` | `0` | Score subtracted when a tool-result continuation follows an assistant turn that used only read-only tools (read, grep, glob, ls, lsp…). Recorded as `features.readOnlyToolTail` either way; enable after `tools/replay.ts` prices it. |
 | `mechanicalRetryFactor` | `0.2` | Fraction of the failed-tool and circular-call weights kept on a tool-result continuation; `1` disables the damping. |
 
 ### `escalation` — mid-stream retry upward
@@ -767,13 +773,37 @@ Each profile is a complete entry (arrays replace wholesale):
 
 | Key | Default | Meaning |
 | --- | --- | --- |
-| `id` | `auto` / `auto-cheap` / `auto-max` | Model id omp selects. |
+| `id` | `auto` / `auto-cheap` / `auto-max` / `auto-sub` | Model id omp selects. `auto-sub` (trivial..moderate) is what subagents get via `server.subagentProfile`. |
 | `name` | `Auto (auto-model-router)` etc. | Display name. |
 | `minTier` / `maxTier` | `trivial`/`hard`, `trivial`/`simple`, `moderate`/`hard` | Tier envelope. |
 | `contextWindow` | `400000` | Advertised context window (drives omp's compaction). |
 | `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/omp-extension/router-embed.ts

@@ -89,7 +89,7 @@ function trackProcessExit(): void {
  * Registers the auto-model-router provider (and its virtual models) into omp's model
  * registry at a specific bound port.
  */
-function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfig, sessionId: string): void {
+function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfig, sessionId: string, subagent: boolean): void {
 	// cwd is omp's workspace, which is what the agentdox scope is derived from
 	// when none is configured explicitly.
 	const providerConfig = buildProviderConfig(port, cfg, process.cwd());
@@ -100,6 +100,9 @@ function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfi
 	// Per-session scoping: lets the toast surface only this session's decisions
 	// even when several omp sessions share one embedded router's ledger.
 	if (sessionId !== "") headers["X-Omp-Session"] = sessionId;
+	// A session without a UI is a subagent (or a headless run): the router
+	// routes its turns under server.subagentProfile.
+	if (subagent) headers["X-Omp-Subagent"] = "1";
 	// Which agentdox project's shared context this workspace's turns draw on.
 	if (providerConfig.agentdoxScope !== undefined && providerConfig.agentdoxScope !== "") {
 		headers["X-Agentdox-Scope"] = providerConfig.agentdoxScope;
@@ -171,7 +174,7 @@ export default function (pi: ExtensionAPI): void {
 		// second bind would take a different port and orphan every model handle
 		// omp already resolved against the first one.
 		if (app !== null && boundPort !== null) {
-			registerRouterProvider(pi, boundPort, cfg, sessionId);
+			registerRouterProvider(pi, boundPort, cfg, sessionId, !ctx.hasUI);
 			return;
 		}
 
@@ -181,7 +184,7 @@ export default function (pi: ExtensionAPI): void {
 			// The main writes the port file before spawning subagents.
 			const shared = readEmbedPort(portFile);
 			if (shared !== null && (await probeEmbed(shared))) {
-				registerRouterProvider(pi, shared, cfg, sessionId);
+				registerRouterProvider(pi, shared, cfg, sessionId, !ctx.hasUI);
 				return;
 			}
 			// No live interactive session (headless batch runs, CI, the
@@ -193,7 +196,7 @@ export default function (pi: ExtensionAPI): void {
 			if (started.server.port === undefined) return;
 			app = started;
 			boundPort = started.server.port;
-			registerRouterProvider(pi, boundPort, cfg, sessionId);
+			registerRouterProvider(pi, boundPort, cfg, sessionId, !ctx.hasUI);
 			return;
 		}
 
@@ -207,7 +210,7 @@ export default function (pi: ExtensionAPI): void {
 		// default — never take this path, so sessions stay independent.
 		if (requestedPort !== 0 && (await probeEmbed(requestedPort))) {
 			writeEmbedPort(portFile, requestedPort);
-			registerRouterProvider(pi, requestedPort, cfg, sessionId);
+			registerRouterProvider(pi, requestedPort, cfg, sessionId, !ctx.hasUI);
 			pi.setLabel(`auto-model-router embed (shared :${requestedPort})`);
 			return;
 		}
@@ -266,7 +269,7 @@ export default function (pi: ExtensionAPI): void {
 
 		// Register BEFORE any await: everything omp resolves after this point
 		// picks up the live URL, so the registration must not sit behind I/O.
-		registerRouterProvider(pi, actualPort, cfg, sessionId);
+		registerRouterProvider(pi, actualPort, cfg, sessionId, !ctx.hasUI);
 		pi.setLabel(`auto-model-router embed :${actualPort}`);
 
 		// NO `session_shutdown` teardown. That event is emitted from session

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.4.0",
+  "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

@@ -114,6 +114,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "server.port", label: "Listen port", kind: "number", min: 1, max: 65535 },
 			{ path: "server.apiKey", label: "Client bearer token", kind: "string", optional: true, secret: true },
 			{ path: "server.harnessId", label: "Default harness id", kind: "string", optional: true },
+			{ path: "server.subagentProfile", label: "Subagent profile", kind: "string", optional: true, hint: "profile id for omp subagents; blank = none" },
 			{ path: "server.maxConcurrentTurns", label: "Max concurrent turns", kind: "number", min: 1, hint: "per process, all sessions" },
 		],
 	},
@@ -182,6 +183,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "filters.includeFree", label: "Include free models", kind: "boolean" },
 			{ 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.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" },
@@ -210,6 +212,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "classifier.chatAxis", label: "Chat axis", kind: "enum", options: AXES },
 			{ path: "classifier.agenticLoopDepth", label: "Agentic loop depth", kind: "number", min: 0, hint: "tool rounds before damping" },
 			{ path: "classifier.mechanicalRetryFactor", label: "Mechanical retry factor", kind: "number", min: 0, max: 1 },
+			{ path: "classifier.readOnlyToolWeight", label: "Read-only tool loop weight", kind: "number", min: 0, hint: "0=record only" },
 			{ path: "classifier.reasoningWeights.medium", label: "Reasoning weight: medium", kind: "number", min: 0 },
 			{ path: "classifier.reasoningWeights.high", label: "Reasoning weight: high", kind: "number", min: 0 },
 			{ path: "classifier.reasoningWeights.xhigh", label: "Reasoning weight: xhigh", kind: "number", min: 0 },
@@ -307,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

@@ -15,6 +15,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// is deterministic, so peers reuse it), so this covers N sessions plus
 		// their subagents. Was effectively 8 per session when each bound its own.
 		maxConcurrentTurns: 24,
+		// omp subagents (no UI) route under this profile: delegated work, capped at moderate.
+		subagentProfile: "auto-sub",
 	},
 	openrouter: {
 		baseUrl: "https://openrouter.ai/api/v1",
@@ -99,6 +101,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		includeFree: false,
 		requireToolSupport: true,
 		minTrust: 0.7,
+		// Verdicts are recorded and reported first; weigh them once there are some.
+		feedbackWeight: 0,
 		minTrustSamples: 12,
 		// Shared trust by default: more samples, demotion guard stays effective
 		// even with a tiny guardrail-narrowed catalog.
@@ -142,6 +146,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// A mechanical retry (failed tool call + tool-result continuation) keeps
 		// only a fifth of the +0.26; a user-visible failure keeps the full weight.
 		mechanicalRetryFactor: 0.2,
+		// Recorded, not acted on, until replay prices it. See ClassifierConfig.readOnlyToolWeight.
+		readOnlyToolWeight: 0,
 		// Shipped reasoning values, unchanged. See ClassifierConfig.reasoningWeights:
 		// a harness that pins the level for a whole session turns these into a
 		// constant tier offset, in which case `medium` belongs near 0.
@@ -286,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"],
@@ -298,6 +317,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		{ id: "auto", name: "Auto (auto-model-router)", minTier: "trivial", maxTier: "hard", contextWindow: 400_000, maxTokens: 32_000 },
 		{ id: "auto-cheap", name: "Auto Cheap (auto-model-router)", minTier: "trivial", maxTier: "simple", contextWindow: 400_000, maxTokens: 32_000 },
 		{ id: "auto-max", name: "Auto Max (auto-model-router)", minTier: "moderate", maxTier: "hard", contextWindow: 400_000, maxTokens: 32_000 },
+		// Subagent envelope (server.subagentProfile): never the top tier for delegated work.
+		{ id: "auto-sub", name: "Auto Subagent (auto-model-router)", minTier: "trivial", maxTier: "moderate", contextWindow: 400_000, maxTokens: 32_000 },
 	],
 	ledger: {
 		// Resolved by loadConfig: empty ⇒ `$AUTO_MODEL_ROUTER_HOME/router.db`.

package/src/config/schema.ts

@@ -20,6 +20,7 @@ const server = z.strictObject({
 	port: z.number().int().min(0).max(65_535).optional(),
 	apiKey: z.string().optional(),
 	harnessId: z.string().optional(),
+	subagentProfile: z.string().optional(),
 	maxConcurrentTurns: z.number().int().positive().max(1_000).optional(),
 });
 
@@ -88,6 +89,7 @@ const filters = z.strictObject({
 	includeFree: z.boolean().optional(),
 	requireToolSupport: z.boolean().optional(),
 	minTrust: z.number().min(0).max(1).optional(),
+	feedbackWeight: z.number().nonnegative().optional(),
 	minTrustSamples: z.number().int().nonnegative().optional(),
 	trustScopedByHarness: z.boolean().optional(),
 	trustWindowDays: z.number().nonnegative().optional(),
@@ -114,6 +116,7 @@ const classifier = z.strictObject({
 	chatAxis: qualityAxis.optional(),
 	agenticLoopDepth: z.number().int().nonnegative().optional(),
 	mechanicalRetryFactor: z.number().min(0).max(1).optional(),
+	readOnlyToolWeight: z.number().nonnegative().optional(),
 	reasoningWeights: z
 		.strictObject({
 			medium: z.number().nonnegative().optional(),
@@ -270,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

@@ -38,6 +38,14 @@ export interface ServerConfig {
 	 * ⇒ no header (single-harness default).
 	 */
 	harnessId?: string;
+	/**
+	 * Profile that requests from omp subagents (`X-Omp-Subagent: 1`, set by
+	 * the embed extension for sessions without a UI) are routed under when they
+	 * ask for the default profile. Subagents do delegated, bounded work — file
+	 * reads, searches, summaries — that rarely needs the top tier. Empty
+	 * disables the remap; a name with no matching profile is ignored.
+	 */
+	subagentProfile: string;
 	/**
 	 * Concurrent in-flight turns this router process will accept; excess gets a
 	 * 429 rather than being queued, so a local flood cannot pile up unbounded
@@ -215,6 +223,15 @@ export interface FilterConfig {
 	requireToolSupport: boolean;
 	/** Drop models whose ledger success rate is below this, once `minTrustSamples` is met. */
 	minTrust: number;
+	/**
+	 * How much a user verdict (/router good|bad) weighs in a model's trust
+	 * rate: each bad verdict counts as this many failures and each good one as
+	 * this many successes, beside escalations and errors. 0 (default) records
+	 * verdicts without acting on them. A person judging an answer wrong is a
+	 * stronger signal than a probe rejection, so values of 2-5 are sensible
+	 * once a week of verdicts is in the report.
+	 */
+	feedbackWeight: number;
 	/** Attempts required before `minTrust` is enforced against a model. */
 	minTrustSamples: number;
 	/**
@@ -347,6 +364,13 @@ export interface ClassifierConfig {
 	 * loops buy the hard tier. 1 preserves the shipped behaviour.
 	 */
 	mechanicalRetryFactor: number;
+	/**
+	 * Score subtracted when the newest assistant turn issued only read-only
+	 * tools (read, grep, glob, ls, lsp…) and this is the tool-result
+	 * continuation: the model is looking, not deciding. 0 (default) records
+	 * the feature without acting on it — enable after a replay prices it.
+	 */
+	readOnlyToolWeight: number;
 	/**
 	 * Score added when the CLIENT asks for a reasoning effort, per level. The
 	 * premise is that asking for reasoning states expected difficulty directly.
@@ -530,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 {
 	/**
@@ -717,6 +767,7 @@ export interface RouterConfig {
 	compaction: CompactionConfig;
 	budget: BudgetConfig;
 	report: ReportConfig;
+	digest: DigestConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**