auto-model-router 0.4.2 → 0.4.4

package/src/router/select.ts

@@ -8,7 +8,7 @@
 
 import type { CatalogSnapshot } from "../catalog/types.ts";
 import type { ProfileConfig, RouterConfig } from "../config/types.ts";
-import { priceAt } from "../cost/forecast.ts";
+import { forecast, priceAt } from "../cost/forecast.ts";
 import type { Ledger } from "../cost/types.ts";
 import { explorationDraw } from "./explore.ts";
 import type { CompactionEdit, NormRequest, ReasoningLevel } from "../wire/types.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
@@ -606,13 +610,33 @@ export function select(args: SelectArgs): Decision {
 	}
 	const stripAssistantReasoning = !(chosen.model.supportsReasoning && REASONING_REPLAY_AUTHORS[chosen.model.author] === true);
 
+	// The recorded forecast is the EXPECTED price of this dispatch, not the
+	// cold worst case candidates are ranked on. When the chosen model's cache
+	// is warm, the previous prompt's tokens are priced as cache reads at the
+	// model's measured hit rate; coldUsd stays the cold figure the budget
+	// guards used. Before this every recorded forecast was cold while nine
+	// turns in ten were warm: 89% over-predicted, median error 220%.
+	let expectedForecast = chosen.forecast;
+	if (warmSlug !== null && chosen.model.slug === warmSlug && effFeatures.promptTokens > 0 && state.lastPromptTokens > 0) {
+		const cachedShare = Math.min(1, state.lastPromptTokens / effFeatures.promptTokens);
+		let images = 0;
+		if (req.hasImages) for (const m of req.messages) images += m.images;
+		const warm = forecast(chosen.model, {
+			promptTokens: effFeatures.promptTokens,
+			completionTokens: EXPECTED_COMPLETION_TOKENS,
+			cacheHitRate: cacheHitExpectation(chosen.model.slug).rate * cachedShare,
+			images,
+		});
+		expectedForecast = { ...warm, coldUsd: chosen.forecast.coldUsd };
+	}
+
 	return {
 		slug: chosen.model.slug,
 		fallbacks,
 		tier: chosenTier,
 		classification: cls,
 		features,
-		forecast: chosen.forecast,
+		forecast: expectedForecast,
 		sessionId: state.sessionId,
 		sticky,
 		cacheBreakpointMessageIndices,

package/src/server/compaction-digest.ts

@@ -0,0 +1,129 @@
+/**
+ * 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>;
+	/** See Digester.noteToolCalls; optional so a fake need not implement it. */
+	noteToolCalls?(ompSessionId: string, calls: readonly { name: string; argsJson: string }[], nowMs?: number): number;
+}
+
+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

@@ -23,6 +23,7 @@ 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 { primaryArg } from "../router/compaction.ts";
 import { extractFeatures } from "../router/features.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { estimateTokens } from "../tokens/estimate.ts";
@@ -39,6 +40,14 @@ export interface DigestRequest {
 	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 =
@@ -99,8 +108,31 @@ function syntheticRequest(req: DigestRequest, promptText: string): NormRequest {
 	};
 }
 
-export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest): Promise<DigestResult> } {
+/** A digest the agent may still go back on: same tool, same primary argument, within RERUN_WINDOW_MS. */
+interface RecentDigest {
+	tool: string;
+	arg: string | null;
+	atMs: number;
+	ledgerId: string;
+	rerun: boolean;
+}
+const RERUN_WINDOW_MS = 2 * 3_600_000;
+const RECENT_PER_SESSION = 50;
+
+export interface Digester {
+	digest(req: DigestRequest): Promise<DigestResult>;
+	/**
+	 * Quality signal: the tool calls a session just made. One that repeats a
+	 * recent digest (same tool, same primary argument) means the agent went
+	 * back for the full output; that digest's ledger row is marked wasted and
+	 * the report shows the re-run rate. Returns how many were marked.
+	 */
+	noteToolCalls(ompSessionId: string, calls: readonly { name: string; argsJson: string }[], nowMs?: number): number;
+}
+
+export function createDigester(deps: DigesterDeps): Digester {
 	const { cfg, catalog, ledger, upstream, log } = deps;
+	const recent = new Map<string, RecentDigest[]>();
 
 	/** Cheapest simple-tier model that fits the prompt, or the configured one. */
 	async function pickModel(req: NormRequest, promptTokens: number): Promise<CatalogModel | null> {
@@ -129,8 +161,10 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 	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);
+			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}`;
@@ -190,7 +224,7 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 				servedSlug: model.slug,
 				tier: cfg.digest.tier,
 				classificationSource: "forced",
-				reasons: [`digest: ${req.toolName} ${inputBytes} bytes → ${text.length} chars for a ${currentTier} session`],
+				reasons: [`digest (${source}): ${req.toolName} ${inputBytes} bytes → ${text.length} chars for a ${currentTier} ${source === "compaction" ? "turn" : "session"}`],
 				features: null,
 				score: null,
 				confidence: null,
@@ -219,6 +253,11 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 			}
 			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" };
+			if (req.ompSessionId !== "") {
+				const list = recent.get(req.ompSessionId) ?? [];
+				list.push({ tool: req.toolName.toLowerCase(), arg: primaryArg(JSON.stringify(req.input)), atMs: startedAt, ledgerId: entry.id, rerun: false });
+				recent.set(req.ompSessionId, list.slice(-RECENT_PER_SESSION));
+			}
 			return {
 				digested: true,
 				text: `${digestMarker(req.toolName, req.input, model.slug, inputBytes, text.length)}\n${text}`,
@@ -229,5 +268,30 @@ export function createDigester(deps: DigesterDeps): { digest(req: DigestRequest)
 				ms,
 			};
 		},
+		noteToolCalls(ompSessionId, calls, nowMs = Date.now()) {
+			const list = recent.get(ompSessionId);
+			if (list === undefined || list.length === 0) return 0;
+			let marked = 0;
+			for (const c of calls) {
+				const tool = c.name.toLowerCase();
+				const arg = primaryArg(c.argsJson);
+				if (arg === null) continue;
+				for (const d of list) {
+					if (d.rerun || d.tool !== tool || d.arg !== arg || nowMs - d.atMs > RERUN_WINDOW_MS) continue;
+					d.rerun = true;
+					marked++;
+					try {
+						ledger.markWasted?.(d.ledgerId);
+					} catch (err) {
+						log.debug("digest re-run mark failed", { error: err instanceof Error ? err.message : String(err) });
+					}
+					log.info("digest re-run: the agent fetched the full output after all", { tool, arg: arg.slice(0, 80) });
+				}
+			}
+			const kept = list.filter((d) => nowMs - d.atMs <= RERUN_WINDOW_MS);
+			if (kept.length === 0) recent.delete(ompSessionId);
+			else recent.set(ompSessionId, kept);
+			return marked;
+		},
 	};
 }

package/src/server/http.ts

@@ -9,6 +9,7 @@ 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";
@@ -16,7 +17,7 @@ import { UpstreamError } from "../upstream/types.ts";
 import { apiKeySource, ollamaKeySource } from "../config/load.ts";
 import { ollamaMeter } from "../upstream/ollama-usage.ts";
 import { routerConfigPath } from "../cli/config-cmd.ts";
-import { watchConfig } from "../config/hot-reload.ts";
+import { PINNED_CONFIG_PATHS, watchConfig } from "../config/hot-reload.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { createLogger } from "../util/log.ts";
 import { openDb } from "../util/sqlite.ts";
@@ -195,20 +196,22 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	const context = createBridgeFromConfig(cfg, db);
 	const overrides = createSessionOverrides();
 	const feedback = createFeedbackStore(db);
+	const kv = createKv(db);
 	const digester = createDigester({ cfg, catalog, ledger, upstream, log });
-	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context, overrides, ollamaCostScale };
+	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
-	// the shared config object at call time. Construction-captured blocks
-	// (server socket, OpenRouter client, agentdox bridge) are pinned — editing
-	// those still requires a restart, and the watcher says so explicitly.
-	const pinned = { ...cfg };
+	// the shared config object at call time. Construction-captured settings
+	// (server socket, upstream clients, agentdox bridge, ledger file) are
+	// pinned by path (PINNED_CONFIG_PATHS); editing those still requires a
+	// restart. The blocks are deep-copied so a reload cannot mutate the pin.
+	const pinned = structuredClone(cfg);
 	const configWatcher = watchConfig(
 		routerConfigPath(),
 		cfg,
 		pinned,
-		["server", "openrouter", "ollama", "context", "ledger"],
+		PINNED_CONFIG_PATHS,
 		{
 			onReload: ({ changed }) => {
 				log.info("config reloaded", { changed: changed.join(", ") });
@@ -267,6 +270,20 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	}, 60_000);
 	pruneTimer.unref();
 
+	// Ledger retention: hourly, and once at boot so a lowered setting takes
+	// effect without waiting. Reads the live config, so it hot-reloads.
+	const retain = (): void => {
+		try {
+			const dropped = ledger.prune?.(cfg.ledger.retentionDays) ?? 0;
+			if (dropped > 0) log.info("pruned ledger rows past retention", { dropped, retentionDays: cfg.ledger.retentionDays });
+		} catch (err) {
+			log.warn("ledger retention prune failed", { error: err instanceof Error ? err.message : String(err) });
+		}
+	};
+	const retentionTimer = setInterval(retain, 3_600_000);
+	retentionTimer.unref();
+	setTimeout(retain, 5_000).unref();
+
 	// Periodically refetch the (key-scoped) catalog in the background so
 	// guardrail/preference changes are picked up without needing traffic and a
 	// TTL expiry. catalogRefreshMs === 0 disables this.
@@ -398,6 +415,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);
@@ -514,6 +554,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/providers.ts

@@ -54,6 +54,7 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 			costBias: cfg.ollama.costBias,
 			biasUntilUsage: cfg.ollama.biasUntilUsage,
 			usage: ollamaUsage,
+			live: () => ({ costBias: cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage }),
 		}),
 		ollama,
 		ollamaUsage,

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. */
@@ -111,6 +114,17 @@ export async function runTurn(
 	const log = createLogger(config.logLevel);
 	const state = conversations.load(req.conversationKey);
 	const turnNumber = state.turn + 1;
+	// Digest quality signal: the calls the agent just made, matched against
+	// recent digests of this session (a re-run of a digested read means the
+	// digest was not enough). The last assistant message holds this turn's calls.
+	if (deps.digester?.noteToolCalls !== undefined && req.ompSessionId !== "") {
+		for (let i = req.messages.length - 1; i >= 0; i--) {
+			const m = req.messages[i];
+			if (m === undefined || m.role !== "assistant") continue;
+			if (m.toolCalls.length > 0) deps.digester.noteToolCalls(req.ompSessionId, m.toolCalls.map((c) => ({ name: c.name, argsJson: c.argsJson })));
+			break;
+		}
+	}
 	// Request header wins; the configured default covers harnesses that send none.
 	const doxScope = req.agentdoxScope !== "" ? req.agentdoxScope : config.context.defaultScope;
 	const doxActive = bridge.enabled && doxScope !== "";
@@ -135,6 +149,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 +176,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 +246,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/cache-control.test.ts

@@ -93,7 +93,7 @@ describe("planCacheBreakpoints", () => {
 	test("milestones follow post-compaction sizes", () => {
 		const req = loop(30);
 		const tail = req.messages.length - 1;
-		const plan = planCompaction(req.messages, BASE.compaction, req.promptBytes * 0.3, req.promptBytes);
+		const plan = planCompaction(req.messages, { ...BASE.compaction, enabled: true }, req.promptBytes * 0.3, req.promptBytes);
 		expect(plan.edits.length).toBeGreaterThan(0);
 		const options = cfg({ maxBreakpoints: 64, milestoneTokens: 4_000 });
 		const raw = planCacheBreakpoints(req, MODEL, options).filter((i) => i !== 0 && i !== tail);

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));
+	});
+});