auto-model-router 0.4.1 → 0.4.3

package/src/router/select.ts

@@ -361,7 +361,11 @@ export function select(args: SelectArgs): Decision {
 	// query per signal kind, instead of per-model individual lookups.
 	const candidateSignals =
 		ledger !== null && snapshot.models.length > 0
-			? ledger.signals?.(snapshot.models.map((m) => m.slug), cfg.filters.trustScopedByHarness ? req.harnessId : undefined)
+			? ledger.signals?.(
+					snapshot.models.map((m) => m.slug),
+					cfg.filters.trustScopedByHarness ? req.harnessId : undefined,
+					cfg.filters.feedbackByTask ? classification.task : undefined,
+				)
 			: undefined;
 	// What an escalated retry has actually been billing per prompt token, for
 	// the escalation-cost term in candidate scoring. Read once per turn; null

package/src/server/compaction-digest.ts

@@ -0,0 +1,127 @@
+/**
+ * Summarising compaction: when the compaction plan gains new edits, a cheap
+ * model digests the tool results those edits would otherwise truncate or stub,
+ * and the digest rides in the persisted plan in place of the breadcrumb.
+ *
+ * Plain compaction keeps a head and a tail of a stale tool result; a digest
+ * keeps what the task needs from all of it (paths, identifiers, errors, the
+ * code the agent will edit) in a few hundred chars. The digest is stored on
+ * the edit, so the bytes sent stay identical on every later turn until the
+ * plan changes — the same byte-stability plain edits have, which is what keeps
+ * the prompt cache warm.
+ *
+ * Bounded: at most `compaction.digestMaxPerTurn` digests per turn, each under
+ * the digest's own cost guard and timeout, largest results first. A digest
+ * that fails or declines leaves the plain edit in place; nothing is lost.
+ */
+
+import type { RouterConfig } from "../config/types.ts";
+import { compactedBytes } from "../router/compaction.ts";
+import type { Logger } from "../util/log.ts";
+import type { CompactionEdit, NormRequest } from "../wire/types.ts";
+import type { DigestRequest, DigestResult } from "./digest.ts";
+
+export interface CompactionDigester {
+	digest(req: DigestRequest): Promise<DigestResult>;
+}
+
+export interface DigestCompactionArgs {
+	req: NormRequest;
+	/** The plan this turn dispatches with; edits gain `digest` in place. */
+	plan: CompactionEdit[];
+	/** The tier this turn routed to: the digest pays off only above `digest.fromTier`. */
+	tier: string;
+	cfg: RouterConfig;
+	digester: CompactionDigester;
+	/** Per-turn memo (index:bytes → digest) so a retry does not pay twice. */
+	memo: Map<string, string>;
+	/** The user's current ask, steering what the digest keeps. */
+	query: string;
+	log: Logger;
+}
+
+/** Tool name and parsed arguments for a tool-result message, via its call id. */
+function toolOf(req: NormRequest, index: number): { name: string; input: Record<string, unknown> } | null {
+	const m = req.messages[index];
+	if (m === undefined || m.role !== "tool") return null;
+	let name = m.toolName ?? "";
+	let input: Record<string, unknown> = {};
+	if (m.toolCallId !== undefined) {
+		for (const a of req.messages) {
+			if (a.role !== "assistant") continue;
+			const tc = a.toolCalls.find((c) => c.id === m.toolCallId);
+			if (tc === undefined) continue;
+			if (name === "") name = tc.name;
+			try {
+				const parsed: unknown = JSON.parse(tc.argsJson);
+				if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) input = parsed as Record<string, unknown>;
+			} catch {
+				// Unparseable args: the marker just names the tool.
+			}
+			break;
+		}
+	}
+	return name === "" ? null : { name, input };
+}
+
+/**
+ * Digests the plan's new (undigested) edits, largest first, up to the per-turn
+ * cap. Returns the change in bytes saved versus the plain edits: positive when
+ * the digests are smaller than what truncation would have kept, negative when
+ * a digest keeps more than head+tail did (it usually does, and that is the point).
+ */
+export async function digestCompactionEdits(args: DigestCompactionArgs): Promise<number> {
+	const { req, plan, tier, cfg, digester, memo, query, log } = args;
+	const max = cfg.compaction.digestMaxPerTurn;
+	if (max <= 0) return 0;
+	const pending = plan.filter((e) => e.digest === undefined).sort((a, b) => b.bytes - a.bytes);
+	let delta = 0;
+	const work: CompactionEdit[] = [];
+	for (const e of pending) {
+		const key = `${e.index}:${e.bytes}`;
+		const remembered = memo.get(key);
+		if (remembered !== undefined) {
+			delta += compactedBytes(e.bytes, e) - Buffer.byteLength(remembered);
+			e.digest = remembered;
+			continue;
+		}
+		if (work.length >= max) break;
+		work.push(e);
+	}
+	if (work.length === 0) return delta;
+
+	const results = await Promise.all(
+		work.map(async (e): Promise<{ edit: CompactionEdit; result: DigestResult }> => {
+			const tool = toolOf(req, e.index);
+			const m = req.messages[e.index];
+			if (tool === null || m === undefined) return { edit: e, result: { digested: false, reason: "tool result has no tool name" } };
+			try {
+				const result = await digester.digest({
+					ompSessionId: req.ompSessionId,
+					harnessId: req.harnessId,
+					toolName: tool.name,
+					input: tool.input,
+					content: m.text,
+					query,
+					tier,
+					source: "compaction",
+				});
+				return { edit: e, result };
+			} catch (err) {
+				return { edit: e, result: { digested: false, reason: err instanceof Error ? err.message : String(err) } };
+			}
+		}),
+	);
+	for (const { edit, result } of results) {
+		if (!result.digested) {
+			log.debug("compaction digest declined", { index: edit.index, bytes: edit.bytes, reason: result.reason });
+			continue;
+		}
+		const plain = compactedBytes(edit.bytes, edit);
+		edit.digest = result.text;
+		memo.set(`${edit.index}:${edit.bytes}`, result.text);
+		delta += plain - Buffer.byteLength(result.text);
+		log.info("compaction digest", { index: edit.index, bytes: edit.bytes, chars: result.outputChars, model: result.model, usd: result.usd });
+	}
+	return delta;
+}

package/src/server/digest.ts

@@ -0,0 +1,243 @@
+/**
+ * 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;
+	/** The tier to judge `digest.fromTier` against; default: the session's last routed tier. */
+	tier?: string;
+	/**
+	 * Who asked. `tool_result` (default) is the omp extension and is gated on
+	 * `digest.enabled`; `compaction` is summarising compaction inside a turn
+	 * and is gated on `compaction.digestToolResults` instead.
+	 */
+	source?: "tool_result" | "compaction";
+}
+
+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 source = req.source ?? "tool_result";
+			const currentTier = req.tier ?? ledger.latestForSession?.(req.ompSessionId)?.tier ?? null;
+			const gate = source === "compaction" ? { ...cfg.digest, enabled: cfg.compaction.digestToolResults } : cfg.digest;
+			const applies = digestApplies(gate, 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 (${source}): ${req.toolName} ${inputBytes} bytes → ${text.length} chars for a ${currentTier} ${source === "compaction" ? "turn" : "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,8 +6,10 @@ 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 { buildDailySummary, createKv, markSummaryShown, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
 import { createRouter } from "../router/index.ts";
 import { createConversationStore } from "../router/state.ts";
@@ -194,7 +196,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	const context = createBridgeFromConfig(cfg, db);
 	const overrides = createSessionOverrides();
 	const feedback = createFeedbackStore(db);
-	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context, overrides, ollamaCostScale };
+	const kv = createKv(db);
+	const digester = createDigester({ cfg, catalog, ledger, upstream, log });
+	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context, overrides, ollamaCostScale, digester };
 
 	// Hot reload: ranking knobs (tiers, filters, escalation, budgets, …) take
 	// effect on the next turn without a restart, because every consumer reads
@@ -396,6 +400,29 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					const harnessId = url.searchParams.get("harness") ?? "";
 					return json(buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) }));
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/summary") {
+					// The last 24 hours in a few lines. `auto=1` is the session-start
+					// caller: it gets `due: false` unless report.dailySummary is on, no
+					// summary was posted for this harness in the last 20h, and there is
+					// something to say; posting is then marked so other windows skip it.
+					const harnessId = url.searchParams.get("harness") ?? "";
+					const auto = url.searchParams.get("auto") === "1";
+					if (auto && !cfg.report.dailySummary) return json({ due: false, reason: "report.dailySummary is off", summary: null });
+					if (auto && !summaryDue(kv, harnessId)) return json({ due: false, reason: "posted in the last 20h", summary: null });
+					const meter = ollamaMeter(ollamaUsage.peek(), cfg.ollama.planCreditsUsd);
+					const runway = ollamaRunway(meter, ledger.providerSpendSince?.("ollama/", Date.now() - 7 * 86_400_000) ?? 0, ollamaUsage.calibration()?.factor ?? 1);
+					const ollamaSummary: SummaryOllama | null =
+						ollama === null || meter === null ? null : { plan: meter.plan ?? null, usedUsd: meter.usedUsd, creditsUsd: meter.creditsUsd, runwayDays: runway?.days ?? null };
+					const summary = buildDailySummary(db, {
+						harnessId,
+						baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)),
+						spikes: ledger.softFailureSpikes?.() ?? [],
+						ollama: ollamaSummary,
+					});
+					if (auto && !summaryHasNews(summary)) return json({ due: false, reason: "nothing to report", summary: null });
+					if (auto) markSummaryShown(kv, harnessId);
+					return json({ due: true, summary });
+				}
 				if (req.method === "GET" && url.pathname === "/v1/router/decisions") {
 					const rawLimit = url.searchParams.get("limit");
 					const parsed = rawLimit === null ? 50 : Number.parseInt(rawLimit, 10);
@@ -436,6 +463,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;
@@ -492,6 +539,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 										runway: ollamaRunway(ollamaMeter(ollamaUsage.peek(), cfg.ollama.planCreditsUsd), ledger.providerSpendSince?.("ollama/", Date.now() - 7 * 86_400_000) ?? 0, ollamaUsage.calibration()?.factor ?? 1),
 										costBias: { configured: cfg.ollama.costBias, effective: catalog.ollamaBias?.() ?? cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage },
 									},
+						// Models failing well above their own baseline in the last hour.
+						// Visibility only: nothing routes around a spike.
+						softFailures: { recentMs: 3_600_000, baselineDays: 7, spikes: ledger.softFailureSpikes?.() ?? [] },
 						catalog: snap === null
 							? null
 							: {

package/src/server/turn.ts

@@ -28,6 +28,7 @@ import {
 } from "../router/types.ts";
 import { UpstreamError, type Dispatch, type UpstreamClient } from "../upstream/types.ts";
 import type { SessionOverrides } from "./overrides.ts";
+import { digestCompactionEdits, type CompactionDigester } from "./compaction-digest.ts";
 import { createLogger } from "../util/log.ts";
 import type { NormRequest, ResponseSink, TurnSummary, UpstreamChunk } from "../wire/types.ts";
 
@@ -71,6 +72,8 @@ export interface TurnDeps {
 	overrides?: SessionOverrides;
 	/** Ledger-vs-meter calibration for Ollama's estimated costs; absent ⇒ 1. */
 	ollamaCostScale?: () => number;
+	/** Cheap-model digester for summarising compaction (`compaction.digestToolResults`). Absent ⇒ plain edits. */
+	digester?: CompactionDigester;
 }
 
 /** A dead client connection surfaces as the sink throwing mid-stream. */
@@ -135,6 +138,8 @@ export async function runTurn(
 	// A failover decision already routed inside onUpstreamError; the next
 	// loop iteration dispatches it instead of routing again.
 	let pendingDecision: Decision | null = null;
+	// Digests made this turn, by edit; a retry re-plans and must not pay twice.
+	const digestMemo = new Map<string, string>();
 
 	for (let attempt = 0; attempt < maxAttempts; attempt++) {
 		// Client disconnected before anything was dispatched: spend nothing.
@@ -160,6 +165,27 @@ export async function runTurn(
 			}
 		}
 
+		// Summarising compaction: new edits get a cheap-model digest before the
+		// plan is applied and persisted. Bounded per turn; a decline leaves the
+		// plain edit. Accounted in the estimate adjustment below.
+		let compactionSavedBytes = decision.compactionSavedBytes;
+		if (deps.digester !== undefined && config.compaction.digestToolResults && decision.compactionPlan.length > 0) {
+			try {
+				compactionSavedBytes += await digestCompactionEdits({
+					req,
+					plan: decision.compactionPlan,
+					tier: decision.tier,
+					cfg: config,
+					digester: deps.digester,
+					memo: digestMemo,
+					query: relevanceQuery(req),
+					log,
+				});
+			} catch (err) {
+				log.warn("compaction digest failed; dispatching plain edits", { error: err instanceof Error ? err.message : String(err) });
+			}
+		}
+
 		// Resolve the shared context block. The bridge refreshes only when this
 		// turn's prefix is already cold — a model switch or a retry — so the
 		// injected bytes stay identical while the cache is worth keeping.
@@ -209,7 +235,7 @@ export async function runTurn(
 		// — not the raw request the estimate was taken from.
 		adjustPendingEstimate(
 			req.conversationKey,
-			req.promptBytes - decision.compactionSavedBytes + (contextBlock === undefined ? 0 : Buffer.byteLength(contextBlock)),
+			req.promptBytes - compactionSavedBytes + (contextBlock === undefined ? 0 : Buffer.byteLength(contextBlock)),
 		);
 
 		// Our own abort composes with the client's: escalation teardown and

package/src/util/sqlite.ts

@@ -141,6 +141,13 @@ CREATE TABLE IF NOT EXISTS feedback (
 CREATE INDEX IF NOT EXISTS idx_feedback_created ON feedback (created_at_ms);
 CREATE INDEX IF NOT EXISTS idx_feedback_ledger ON feedback (ledger_id);
 
+-- Small durable markers (e.g. when the daily summary was last posted, per harness).
+CREATE TABLE IF NOT EXISTS router_kv (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at_ms INTEGER NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS agentdox_sessions (
   conversation_key TEXT PRIMARY KEY,
   scope TEXT NOT NULL,

package/src/wire/openai/request.ts

@@ -199,6 +199,10 @@ function applyCompaction(messages: Record<string, unknown>[], edits: readonly Co
 		if (msg === undefined) continue;
 		const content = msg.content;
 		if (typeof content !== "string") continue;
+		if (edit.digest !== undefined) {
+			msg.content = edit.digest;
+			continue;
+		}
 		if (edit.mode === "stub") {
 			msg.content = `[omp-router: ${edit.note} elided to save context; re-run the tool to restore]`;
 			continue;

package/src/wire/types.ts

@@ -158,6 +158,13 @@ export interface CompactionEdit {
 	 * the edit instead of corrupting the prompt.
 	 */
 	bytes: number;
+	/**
+	 * A cheap-model digest of the original content (marker line first), set
+	 * by summarising compaction. When present it replaces the content outright
+	 * instead of the head/tail or stub breadcrumb, and persists with the plan
+	 * so the dispatched bytes stay identical turn to turn.
+	 */
+	digest?: string;
 }
 
 export type FinishReason = "stop" | "length" | "tool_calls" | "content_filter" | "error";

package/test/compaction.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import type { CompactionConfig } from "../src/config/types.ts";
-import { planCompaction, validatePlan } from "../src/router/compaction.ts";
+import { compactedBytes, planCompaction, validatePlan } from "../src/router/compaction.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 import type { NormMessage } from "../src/wire/types.ts";
 
@@ -16,7 +16,7 @@ const CFG: CompactionConfig = {
 	keepHeadBytes: 10,
 	keepTailBytes: 10,
 	elideSupersededReads: true,
-	collapseDuplicateResults: true,
+	collapseDuplicateResults: true, digestToolResults: false, digestMaxPerTurn: 2,
 };
 
 function user(text: string): NormMessage {
@@ -78,7 +78,7 @@ describe("planCompaction", () => {
 			toolMsg("c2", "read", big("V2")), // different content, same path → supersedes c1
 			...PAD,
 		];
-		const { edits } = planCompaction(msgs, { ...CFG, collapseDuplicateResults: false }, 10_000, 10_000);
+		const { edits } = planCompaction(msgs, { ...CFG, collapseDuplicateResults: false, digestToolResults: false, digestMaxPerTurn: 2, }, 10_000, 10_000);
 		expect(edits.map((e) => e.index)).toEqual([2]);
 		expect(edits[0]?.mode).toBe("stub");
 	});
@@ -270,3 +270,40 @@ describe("plan byte-stability across turns", () => {
 		expect(next.edits.filter((e) => e.index === 2)).toEqual(carried);
 	});
 });
+
+describe("summarising compaction (edit.digest)", () => {
+	const bodyWith = (messages: unknown[]): Record<string, unknown> => ({ model: "auto", messages });
+	const MUT = { slug: "x/y", fallbacks: [], sessionId: "s", cacheBreakpointMessageIndices: [], reasoning: undefined, maxTokens: undefined, stripAssistantReasoning: false };
+	const DIGEST = "[digest: read output 208 bytes → 40 chars by cheap/model. Full output: re-run read {}]\nA: two hundred x's.";
+
+	test("a digested edit replaces the content with the digest, whatever its mode", () => {
+		const raw = [
+			{ role: "user", content: "go" },
+			{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: "{}" } }] },
+			{ role: "tool", tool_call_id: "c1", content: "HEAD" + "x".repeat(500) + "TAIL" },
+		];
+		const req = parseChatRequest(bodyWith(raw), new Headers());
+		for (const mode of ["truncate", "stub"] as const) {
+			const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode, keepHead: 4, keepTail: 4, note: "large read result", bytes: 508, digest: DIGEST }] });
+			expect((out.messages as { content: string }[])[2]?.content).toBe(DIGEST);
+		}
+	});
+
+	test("compactedBytes sizes a digested edit by its digest, never above the original", () => {
+		const plain = { index: 2, mode: "truncate" as const, keepHead: 10, keepTail: 10, note: "n", bytes: 5_000 };
+		expect(compactedBytes(5_000, { ...plain, digest: DIGEST })).toBe(Buffer.byteLength(DIGEST));
+		expect(compactedBytes(5_000, { ...plain, digest: "y".repeat(9_000) })).toBe(5_000);
+	});
+
+	test("the digest survives validation and a re-plan, so the bytes stay stable", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
+		const digested = edits.map((e) => ({ ...e, digest: DIGEST }));
+		expect(validatePlan(digested, msgs)[0]?.digest).toBe(DIGEST);
+		const replanned = planCompaction(msgs, CFG, 1, 10_000, validatePlan(digested, msgs));
+		expect(replanned.edits).toHaveLength(1);
+		expect(replanned.edits[0]?.digest).toBe(DIGEST);
+		// Savings count the digest's size, not the head+tail the plain edit would have kept.
+		expect(replanned.savedBytes).toBe(Buffer.byteLength(big("A")) - Buffer.byteLength(DIGEST));
+	});
+});