auto-model-router 0.4.0 → 0.4.2

package/src/cost/ledger.ts

@@ -94,6 +94,15 @@ interface TrustRow {
 	mean_cost_error: number | null;
 }
 
+interface FeedbackRow {
+	good: number | null;
+	bad: number | null;
+}
+
+/** Verdict counts per served slug since a cutoff (optionally one harness). */
+const FEEDBACK_SELECT = `COALESCE(SUM(CASE WHEN f.verdict = 'good' THEN 1 ELSE 0 END), 0) AS good,
+		COALESCE(SUM(CASE WHEN f.verdict = 'bad' THEN 1 ELSE 0 END), 0) AS bad`;
+
 interface LatencyRow {
 	samples: number;
 	ttft_ms: number | null;
@@ -186,15 +195,23 @@ function errorKindOf(error: string | null): string | null {
 	return error.slice(0, sep);
 }
 
-function toTrust(slug: string, row: TrustRow): ModelTrust {
+function toTrust(slug: string, row: TrustRow, fb: FeedbackRow | null = null, feedbackWeight = 0): ModelTrust {
 	// Laplace smoothing: an untried model scores a neutral 1/2, and a failure
 	// is an attempt superseded by an escalation or ended in an upstream error.
+	// A user verdict counts as feedbackWeight extra attempts of that outcome.
+	const good = fb?.good ?? 0;
+	const bad = fb?.bad ?? 0;
+	const w = feedbackWeight > 0 ? feedbackWeight : 0;
+	const attempts = row.attempts + w * (good + bad);
+	const failures = row.failures + w * bad;
 	return {
 		slug,
 		attempts: row.attempts,
 		escalations: row.escalations,
 		errors: row.errors,
-		successRate: (row.attempts - row.failures + 1) / (row.attempts + 2),
+		feedbackGood: good,
+		feedbackBad: bad,
+		successRate: (attempts - failures + 1) / (attempts + 2),
 		meanCostError: row.mean_cost_error ?? 0,
 	};
 }
@@ -312,6 +329,17 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 	const trustStmt = db.query(`SELECT ${TRUST_SELECT} FROM ledger WHERE slug = ? AND created_at_ms > ?`);
 	const trustHarnessStmt = db.query(`SELECT ${TRUST_SELECT} FROM ledger WHERE slug = ? AND harness_id = ? AND created_at_ms > ?`);
 	const allTrustStmt = db.query(`SELECT slug, ${TRUST_SELECT} FROM ledger WHERE created_at_ms > ? GROUP BY slug`);
+	const feedbackStmt = db.query(`SELECT ${FEEDBACK_SELECT} FROM feedback f WHERE f.slug = ? AND f.created_at_ms > ?`);
+	const feedbackHarnessStmt = db.query(
+		`SELECT ${FEEDBACK_SELECT} FROM feedback f JOIN ledger l ON l.id = f.ledger_id WHERE f.slug = ? AND l.harness_id = ? AND f.created_at_ms > ?`,
+	);
+	const allFeedbackStmt = db.query(`SELECT f.slug, ${FEEDBACK_SELECT} FROM feedback f WHERE f.created_at_ms > ? GROUP BY f.slug`);
+	const feedbackFor = (slug: string, harnessId: string | undefined, cutoff: number): FeedbackRow | null => {
+		if (cfg.filters.feedbackWeight <= 0) return null;
+		return harnessId !== undefined && harnessId !== ""
+			? (feedbackHarnessStmt.get(slug, harnessId, cutoff) as FeedbackRow | null)
+			: (feedbackStmt.get(slug, cutoff) as FeedbackRow | null);
+	};
 	const latencyStmt = db.query(
 		`SELECT ${LATENCY_SELECT} FROM (SELECT * FROM ledger WHERE slug = ? ORDER BY created_at_ms DESC LIMIT ${LATENCY_WINDOW_ROWS})`,
 	);
@@ -323,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.
@@ -447,13 +476,17 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 					? (trustHarnessStmt.get(slug, harnessId, cutoff) as TrustRow | null)
 					: (trustStmt.get(slug, cutoff) as TrustRow | null);
 			if (row === null || row.attempts === 0) return null;
-			return toTrust(slug, row);
+			return toTrust(slug, row, feedbackFor(slug, harnessId, cutoff), cfg.filters.feedbackWeight);
 		},
 
 		allTrust(): ModelTrust[] {
 			const cutoff = cfg.filters.trustWindowDays > 0 ? Date.now() - cfg.filters.trustWindowDays * DAY_MS : 0;
 			const rows = allTrustStmt.all(cutoff) as (TrustRow & { slug: string })[];
-			return rows.map((row) => toTrust(row.slug, row));
+			const fb = new Map<string, FeedbackRow>();
+			if (cfg.filters.feedbackWeight > 0) {
+				for (const r of allFeedbackStmt.all(cutoff) as (FeedbackRow & { slug: string })[]) fb.set(r.slug, r);
+			}
+			return rows.map((row) => toTrust(row.slug, row, fb.get(row.slug) ?? null, cfg.filters.feedbackWeight));
 		},
 
 		latency(slug: string, harnessId?: string): ModelLatency | null {
@@ -476,7 +509,7 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 					? (latencyHarnessStmt.get(slug, harnessId) as LatencyRow | null)
 					: (latencyStmt.get(slug) as LatencyRow | null);
 				out.set(slug, {
-					trust: trustRow === null || trustRow.attempts === 0 ? null : toTrust(slug, trustRow),
+					trust: trustRow === null || trustRow.attempts === 0 ? null : toTrust(slug, trustRow, feedbackFor(slug, harnessId, cutoff), cfg.filters.feedbackWeight),
 					latency: latencyRow === null ? null : toLatency(slug, latencyRow),
 				});
 			}

package/src/cost/report.ts

@@ -27,6 +27,13 @@ export interface ReportTotals {
 	modelSwitches: number;
 	/** Any row in the window carries an estimated cache count. */
 	cacheEstimated: boolean;
+	/** 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 {
@@ -196,6 +203,11 @@ export function buildUsageReport(
 				COALESCE(SUM(${CT}), 0) AS cached_tokens,
 				COALESCE(SUM(${COMP}), 0) AS completion_tokens,
 				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,
@@ -210,6 +222,11 @@ export function buildUsageReport(
 		cached_tokens: number;
 		completion_tokens: number;
 		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;
@@ -327,6 +344,11 @@ export function buildUsageReport(
 			aborted: t.aborted ?? 0,
 			modelSwitches: switches,
 			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,
@@ -391,6 +413,12 @@ 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)`);
+	}
 	const a = r.anatomy;
 	if (a !== null) {
 		summary.push(

package/src/cost/types.ts

@@ -177,8 +177,11 @@ export interface ModelTrust {
 	escalations: number;
 	/** Attempts that ended in an upstream error. */
 	errors: number;
-	/** Laplace-smoothed success rate, 0-1. */
+	/** Laplace-smoothed success rate, 0-1; user verdicts weigh in at filters.feedbackWeight. */
 	successRate: number;
+	/** User verdicts in the window (/router good|bad). */
+	feedbackGood?: number;
+	feedbackBad?: number;
 	/** Mean absolute relative prediction error, for forecast calibration. */
 	meanCostError: number;
 }

package/src/router/classify.ts

@@ -166,6 +166,9 @@ export function scoreHeuristic(f: Features, cfg: RouterConfig): Classification {
 	// the served model must still accept image input — is enforced separately
 	// on `req.hasImages` in candidate selection, exactly as `classifyTask` does.
 	if (f.hasNewImage) add(W_IMAGES, "new image input");
+	if (f.readOnlyToolTail === true && cfg.classifier.readOnlyToolWeight > 0) {
+		add(-cfg.classifier.readOnlyToolWeight, "read-only tool loop (the model is looking, not deciding)");
+	}
 	if (f.toolCount > 0) add(W_TOOLS_OFFERED, `${f.toolCount} tools offered`);
 
 	score = Math.min(1, Math.max(0, score));

package/src/router/features.ts

@@ -242,6 +242,19 @@ export function extractFeatures(req: NormRequest, promptTokens: number): Feature
 		else anatomy.toolBytes += m.textBytes;
 	}
 
+	// Read-only tool loop: the assistant call behind a tool-result tail used
+	// only tools that look at things. Tool names are the harness's own; the
+	// set covers omp's built-ins and their common aliases.
+	let readOnlyToolTail = false;
+	if (isToolResultContinuation) {
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const m = messages[i];
+			if (m === undefined || m.role !== "assistant") continue;
+			if (m.toolCalls.length > 0) readOnlyToolTail = m.toolCalls.every((tc) => READ_ONLY_TOOLS.has(tc.name.toLowerCase()));
+			break;
+		}
+	}
+
 	return {
 		promptTokens,
 		newContentTokens,
@@ -265,5 +278,31 @@ export function extractFeatures(req: NormRequest, promptTokens: number): Feature
 		questionCount,
 		isTerseInstruction,
 		anatomy,
+		isSubagent: req.isSubagent,
+		readOnlyToolTail,
 	};
 }
+
+/** Tools that read state without changing it, in omp, Claude Code and Hermes naming. */
+export const READ_ONLY_TOOLS: ReadonlySet<string> = new Set([
+	"read",
+	"read_file",
+	"grep",
+	"glob",
+	"ls",
+	"list",
+	"list_dir",
+	"find",
+	"lsp",
+	"ast_grep",
+	"search",
+	"web_search",
+	"web_fetch",
+	"webfetch",
+	"websearch",
+	"fetch",
+	"cat",
+	"view",
+	"inspect_image",
+	"todo",
+]);

package/src/router/index.ts

@@ -38,11 +38,18 @@ export interface RouterDeps {
  */
 const NEUTRAL_TOKENIZER = "gpt";
 
-function resolveProfile(cfg: RouterConfig, requestedModel: string): ProfileConfig {
-	const exact = cfg.profiles.find((p) => p.id === requestedModel);
-	if (exact !== undefined) return exact;
+export function resolveProfile(cfg: RouterConfig, requestedModel: string, isSubagent = false): ProfileConfig {
 	const fallback = cfg.profiles[0];
 	if (fallback === undefined) throw new Error("no router profiles configured");
+	// A subagent asking for the default profile is routed under the subagent
+	// profile when one is configured and exists; an explicit other profile
+	// (auto-max, auto-cheap) is honoured as asked.
+	const exact = cfg.profiles.find((p) => p.id === requestedModel);
+	if (isSubagent && cfg.server.subagentProfile !== "" && (exact === undefined || exact.id === fallback.id)) {
+		const sub = cfg.profiles.find((p) => p.id === cfg.server.subagentProfile);
+		if (sub !== undefined) return sub;
+	}
+	if (exact !== undefined) return exact;
 	return fallback;
 }
 
@@ -96,7 +103,7 @@ export function createRouter(deps: RouterDeps): Router {
 				req,
 				features,
 				classification,
-				profile: resolveProfile(config, req.requestedModel),
+				profile: resolveProfile(config, req.requestedModel, req.isSubagent),
 				state,
 				snapshot,
 				ledger,

package/src/router/types.ts

@@ -97,6 +97,14 @@ export interface Features {
 	 * recorded before it existed.
 	 */
 	anatomy?: PromptAnatomy;
+	/** The request came from an omp subagent (`X-Omp-Subagent`). */
+	isSubagent?: boolean;
+	/**
+	 * This is a tool-result continuation and the newest assistant turn issued
+	 * only read-only tools (read, grep, glob, ls, lsp…): the model is looking,
+	 * not deciding. Recorded for replay; scored at classifier.readOnlyToolWeight.
+	 */
+	readOnlyToolTail?: boolean;
 }
 
 /** Prompt bytes by message role and by age, plus the tool-schema bytes beside them. */

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/src/wire/openai/request.ts

@@ -292,6 +292,9 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	// ⇒ the server falls back to its configured default scope.
 	const agentdoxScope = (headers.get("x-agentdox-scope") ?? "").trim();
 
+	// Subagent marker from the embed extension (sessions without a UI).
+	const isSubagent = (headers.get("x-omp-subagent") ?? "").trim() === "1";
+
 	if (typeof b.model !== "string" || b.model.length === 0) {
 		throw invalidRequest("model must be a non-empty string");
 	}
@@ -352,6 +355,7 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		harnessId,
 		ompSessionId,
 		agentdoxScope,
+		isSubagent,
 		requestedModel,
 		messages,
 		tools,

package/src/wire/types.ts

@@ -82,6 +82,8 @@ export interface NormRequest {
 	 * and if that is empty too the bridge stays inert for this request.
 	 */
 	agentdoxScope: string;
+	/** `X-Omp-Subagent: 1`: the caller is an omp subagent (a session without a UI). */
+	isSubagent: boolean;
 	/** Virtual model the client selected, e.g. `auto`, `auto-cheap`, `auto-max`. */
 	requestedModel: string;
 	messages: NormMessage[];

package/test/classify.test.ts

@@ -458,3 +458,16 @@ describe("classifyTask", () => {
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "explain the architecture of the system" }], []))).toBe("documentation");
 	});
 });
+
+describe("classifier.readOnlyToolWeight", () => {
+	test("subtracts only when enabled and the tail is a read-only loop", () => {
+		const base = { ...featuresFor([{ role: "user", content: "look" }]), isToolResultContinuation: true, readOnlyToolTail: true };
+		const off = scoreHeuristic(base, DEFAULT_CONFIG);
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		cfg.classifier.readOnlyToolWeight = 0.1;
+		const on = scoreHeuristic(base, cfg);
+		expect(on.score).toBeCloseTo(Math.max(0, off.score - 0.1), 6);
+		expect(on.reasons.some((r) => r.includes("read-only tool loop"))).toBe(true);
+		expect(scoreHeuristic({ ...base, readOnlyToolTail: false }, cfg).score).toBeCloseTo(off.score, 6);
+	});
+});

package/test/config-wizard.test.ts

@@ -280,6 +280,7 @@ describe("runWizard", () => {
 			"", // keep apiKey
 			"", // keep harnessId
 			"", // keep maxConcurrentTurns
+			"", // keep subagentProfile
 			"s",
 		]);
 		expect(partial).toEqual({ server: { port: 9000 } });
@@ -358,7 +359,7 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles).toHaveLength(3);
+		expect(profiles).toHaveLength(4);
 		expect(profiles[0]).toMatchObject({ id: "auto", contextWindow: 500000 });
 		expect(profiles[1]).toMatchObject({ id: "auto-cheap", contextWindow: 400000 });
 	});
@@ -379,8 +380,8 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles).toHaveLength(4);
-		expect(profiles[3]).toEqual({
+		expect(profiles).toHaveLength(5);
+		expect(profiles[4]).toEqual({
 			id: "auto-fast",
 			name: "Auto Fast",
 			minTier: "trivial",
@@ -400,11 +401,11 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles.map((p) => (p as Record<string, unknown>)["id"])).toEqual(["auto", "auto-max"]);
+		expect(profiles.map((p) => (p as Record<string, unknown>)["id"])).toEqual(["auto", "auto-max", "auto-sub"]);
 	});
 
 	test("refuses to delete the last remaining profile", async () => {
-		const { out } = await drive(["p", "x3", "x2", "x1", "b", "q"]);
+		const { out } = await drive(["p", "x4", "x3", "x2", "x1", "b", "q"]);
 		expect(out).toContain("cannot delete the last profile");
 	});