auto-model-router 0.3.4 → 0.4.1

package/src/config/defaults.ts

@@ -15,6 +15,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// is deterministic, so peers reuse it), so this covers N sessions plus
 		// their subagents. Was effectively 8 per session when each bound its own.
 		maxConcurrentTurns: 24,
+		// omp subagents (no UI) route under this profile: delegated work, capped at moderate.
+		subagentProfile: "auto-sub",
 	},
 	openrouter: {
 		baseUrl: "https://openrouter.ai/api/v1",
@@ -99,6 +101,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		includeFree: false,
 		requireToolSupport: true,
 		minTrust: 0.7,
+		// Verdicts are recorded and reported first; weigh them once there are some.
+		feedbackWeight: 0,
 		minTrustSamples: 12,
 		// Shared trust by default: more samples, demotion guard stays effective
 		// even with a tiny guardrail-narrowed catalog.
@@ -118,6 +122,9 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// slow models (e.g. deepseek-v4-flash ~20 tok/s) fall under it.
 		latencyReferenceTokensPerSec: 30,
 		latencyMinSamples: 20,
+		// Discount a warm model's stay price by its observed hit rate once this
+		// many warm-expected samples exist. See FilterConfig.cacheReliabilityMinSamples.
+		cacheReliabilityMinSamples: 10,
 		// Off: pricing a model's measured escalation rate at what an escalated
 		// retry actually costs changes rankings, so it is opt-in after a replay
 		// run prices it. See FilterConfig.escalationCostWeight.
@@ -127,6 +134,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		ambiguityThreshold: 0.6,
 		// Cheapest competent slug in the catalog; adjudication prompts are tiny.
 		model: "qwen/qwen3.7-flash",
+		// Off until a model is trained; see tools/train-classifier.ts.
+		learnedModelPath: "",
 		maxCostFraction: 0.02,
 		maxCostUsd: 0.002,
 		timeoutMs: 4_000,
@@ -137,6 +146,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// A mechanical retry (failed tool call + tool-result continuation) keeps
 		// only a fifth of the +0.26; a user-visible failure keeps the full weight.
 		mechanicalRetryFactor: 0.2,
+		// Recorded, not acted on, until replay prices it. See ClassifierConfig.readOnlyToolWeight.
+		readOnlyToolWeight: 0,
 		// Shipped reasoning values, unchanged. See ClassifierConfig.reasoningWeights:
 		// a harness that pins the level for a whole session turns these into a
 		// constant tier offset, in which case `medium` belongs near 0.
@@ -281,6 +292,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		elideSupersededReads: true,
 		collapseDuplicateResults: true,
 	},
+	report: {
+		// The frontier pair most omp users would otherwise run on.
+		baselines: ["anthropic/claude-opus-5", "anthropic/claude-sonnet-5"],
+	},
 	budget: {
 		// No caps by default; at a configured ceiling, downgrade rather than fail.
 		onExceeded: "downgrade",
@@ -289,6 +304,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		{ id: "auto", name: "Auto (auto-model-router)", minTier: "trivial", maxTier: "hard", contextWindow: 400_000, maxTokens: 32_000 },
 		{ id: "auto-cheap", name: "Auto Cheap (auto-model-router)", minTier: "trivial", maxTier: "simple", contextWindow: 400_000, maxTokens: 32_000 },
 		{ id: "auto-max", name: "Auto Max (auto-model-router)", minTier: "moderate", maxTier: "hard", contextWindow: 400_000, maxTokens: 32_000 },
+		// Subagent envelope (server.subagentProfile): never the top tier for delegated work.
+		{ id: "auto-sub", name: "Auto Subagent (auto-model-router)", minTier: "trivial", maxTier: "moderate", contextWindow: 400_000, maxTokens: 32_000 },
 	],
 	ledger: {
 		// Resolved by loadConfig: empty ⇒ `$AUTO_MODEL_ROUTER_HOME/router.db`.

package/src/config/schema.ts

@@ -20,6 +20,7 @@ const server = z.strictObject({
 	port: z.number().int().min(0).max(65_535).optional(),
 	apiKey: z.string().optional(),
 	harnessId: z.string().optional(),
+	subagentProfile: z.string().optional(),
 	maxConcurrentTurns: z.number().int().positive().max(1_000).optional(),
 });
 
@@ -88,6 +89,7 @@ const filters = z.strictObject({
 	includeFree: z.boolean().optional(),
 	requireToolSupport: z.boolean().optional(),
 	minTrust: z.number().min(0).max(1).optional(),
+	feedbackWeight: z.number().nonnegative().optional(),
 	minTrustSamples: z.number().int().nonnegative().optional(),
 	trustScopedByHarness: z.boolean().optional(),
 	trustWindowDays: z.number().nonnegative().optional(),
@@ -96,13 +98,16 @@ const filters = z.strictObject({
 	latencyReferenceMs: z.number().positive().optional(),
 	latencyReferenceTokensPerSec: z.number().positive().optional(),
 	latencyMinSamples: z.number().int().nonnegative().optional(),
+	cacheReliabilityMinSamples: z.number().int().nonnegative().optional(),
 	maxExpectedWaitMs: z.number().positive().optional(),
+	latencyWeightContinuation: z.number().nonnegative().optional(),
 	escalationCostWeight: z.number().min(0).max(1).optional(),
 });
 
 const classifier = z.strictObject({
 	ambiguityThreshold: z.number().min(0).max(1).optional(),
 	model: z.string().min(1).optional(),
+	learnedModelPath: z.string().optional(),
 	maxCostFraction: z.number().min(0).max(1).optional(),
 	maxCostUsd: z.number().nonnegative().optional(),
 	timeoutMs: z.number().positive().optional(),
@@ -111,6 +116,7 @@ const classifier = z.strictObject({
 	chatAxis: qualityAxis.optional(),
 	agenticLoopDepth: z.number().int().nonnegative().optional(),
 	mechanicalRetryFactor: z.number().min(0).max(1).optional(),
+	readOnlyToolWeight: z.number().nonnegative().optional(),
 	reasoningWeights: z
 		.strictObject({
 			medium: z.number().nonnegative().optional(),
@@ -205,6 +211,7 @@ const budget = z.strictObject({
 	perTurnUsd: z.number().nonnegative().optional(),
 	perConversationUsd: z.number().nonnegative().optional(),
 	perDayUsd: z.number().nonnegative().optional(),
+	perMonthUsd: z.number().nonnegative().optional(),
 	onExceeded: z.enum(["downgrade", "reject"]).optional(),
 });
 
@@ -265,6 +272,7 @@ export const configInputSchema = z.strictObject({
 	compaction: compaction.optional(),
 	budget: budget.optional(),
 	profiles: z.array(profile).optional(),
+	report: z.strictObject({ baselines: z.array(z.string()).optional() }).optional(),
 	ledger: ledger.optional(),
 	adaptiveTierFloors: z.boolean().optional(),
 	adaptivePriceCeilings: z.boolean().optional(),

package/src/config/types.ts

@@ -38,6 +38,14 @@ export interface ServerConfig {
 	 * ⇒ no header (single-harness default).
 	 */
 	harnessId?: string;
+	/**
+	 * Profile that requests from omp subagents (`X-Omp-Subagent: 1`, set by
+	 * the embed extension for sessions without a UI) are routed under when they
+	 * ask for the default profile. Subagents do delegated, bounded work — file
+	 * reads, searches, summaries — that rarely needs the top tier. Empty
+	 * disables the remap; a name with no matching profile is ignored.
+	 */
+	subagentProfile: string;
 	/**
 	 * Concurrent in-flight turns this router process will accept; excess gets a
 	 * 429 rather than being queued, so a local flood cannot pile up unbounded
@@ -215,6 +223,15 @@ export interface FilterConfig {
 	requireToolSupport: boolean;
 	/** Drop models whose ledger success rate is below this, once `minTrustSamples` is met. */
 	minTrust: number;
+	/**
+	 * How much a user verdict (/router good|bad) weighs in a model's trust
+	 * rate: each bad verdict counts as this many failures and each good one as
+	 * this many successes, beside escalations and errors. 0 (default) records
+	 * verdicts without acting on them. A person judging an answer wrong is a
+	 * stronger signal than a probe rejection, so values of 2-5 are sensible
+	 * once a week of verdicts is in the report.
+	 */
+	feedbackWeight: number;
 	/** Attempts required before `minTrust` is enforced against a model. */
 	minTrustSamples: number;
 	/**
@@ -264,6 +281,14 @@ export interface FilterConfig {
 	latencyReferenceTokensPerSec: number;
 	/** Streamed samples required before latency is scored against a model. */
 	latencyMinSamples: number;
+	/**
+	 * Warm-expected samples a model needs before its observed cache hit rate
+	 * (ledger `cacheReliability`) discounts the "stay warm" price in the
+	 * stay/switch comparison. Below it, and when 0, a cache is assumed fully
+	 * reliable. Measured 2026-09-06: same-model short-gap turns still ran cold
+	 * 5-6% on glm/gemini, 11% on ling and 50% on nex.
+	 */
+	cacheReliabilityMinSamples: number;
 	/**
 	 * Absolute expected-wait ceiling (ms). A hard drop, mirroring the price
 	 * ceiling: any model whose expected total wait (TTFT + streaming the expected
@@ -277,6 +302,13 @@ export interface FilterConfig {
 	 * Undefined ⇒ off (the default).
 	 */
 	maxExpectedWaitMs?: number;
+	/**
+	 * Latency weight for tool-result continuations (the agent loop's own
+	 * follow-ups, where no person is waiting on first token). Unset ⇒
+	 * `latencyWeight` applies to every turn. Lower it to spend speed only on
+	 * user-facing turns.
+	 */
+	latencyWeightContinuation?: number;
 	/**
 	 * How much of a model's measured escalation risk to price into its effective
 	 * cost, 0-1. 0 (the default) disables the term.
@@ -305,6 +337,13 @@ export interface ClassifierConfig {
 	ambiguityThreshold: number;
 	/** Slug used for adjudication. Must be cheap and fast. */
 	model: string;
+	/**
+	 * Path of a model written by `tools/train-classifier.ts`. When set, every
+	 * heuristic classification also carries the learned P(escalate) in its
+	 * reasons (`learned: p(escalate)=…`) and `Classification.learnedRisk`.
+	 * Advisory: it never moves a tier. Empty ⇒ off.
+	 */
+	learnedModelPath: string;
 	/** Skip adjudication when it would exceed this fraction of the forecast turn cost. */
 	maxCostFraction: number;
 	/** Absolute per-call ceiling, USD. */
@@ -325,6 +364,13 @@ export interface ClassifierConfig {
 	 * loops buy the hard tier. 1 preserves the shipped behaviour.
 	 */
 	mechanicalRetryFactor: number;
+	/**
+	 * Score subtracted when the newest assistant turn issued only read-only
+	 * tools (read, grep, glob, ls, lsp…) and this is the tool-result
+	 * continuation: the model is looking, not deciding. 0 (default) records
+	 * the feature without acting on it — enable after a replay prices it.
+	 */
+	readOnlyToolWeight: number;
 	/**
 	 * Score added when the CLIENT asks for a reasoning effort, per level. The
 	 * premise is that asking for reasoning states expected difficulty directly.
@@ -508,6 +554,17 @@ export interface CacheConfig {
 	milestoneTokens: number;
 }
 
+/** Usage-report options. */
+export interface ReportConfig {
+	/**
+	 * Models to price the window's traffic on as if every turn had used that
+	 * one model, at its list price with the window's own cache hit rate: the
+	 * "what the router saved" counterfactual. Slugs missing from the catalog
+	 * are skipped.
+	 */
+	baselines: string[];
+}
+
 export interface BudgetConfig {
 	/** Reject or downgrade when a turn's cold forecast exceeds this, USD. */
 	perTurnUsd?: number;
@@ -515,6 +572,13 @@ export interface BudgetConfig {
 	perConversationUsd?: number;
 	/** Rolling 24h ceiling, USD. */
 	perDayUsd?: number;
+	/**
+	 * Calendar-month (UTC) target, USD. Paced: the per-day ceiling becomes
+	 * min(perDayUsd, remaining ÷ days left in the month), so a month that runs
+	 * ahead of pace tightens automatically instead of failing on its last day.
+	 * Scoped per harness like perDayUsd.
+	 */
+	perMonthUsd?: number;
 	/** At the ceiling: drop to the cheapest viable model, or fail the request outright. */
 	onExceeded: "downgrade" | "reject";
 }
@@ -676,6 +740,7 @@ export interface RouterConfig {
 	context: ContextConfig;
 	compaction: CompactionConfig;
 	budget: BudgetConfig;
+	report: ReportConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**

package/src/cost/feedback.ts

@@ -0,0 +1,81 @@
+/**
+ * User verdicts on routed turns, from omp (`/router feedback good|bad`).
+ *
+ * The router otherwise learns only from escalation signals. A person saying
+ * a cheap model's answer was wrong — or that it was fine — is the label the
+ * de-escalation question needs. Each verdict is tied to the ledger row it
+ * judged, so it aggregates by served model, tier and task.
+ */
+
+import type { Database } from "bun:sqlite";
+
+export type Verdict = "good" | "bad";
+
+export interface FeedbackRecord {
+	ledgerId: string;
+	ompSessionId: string;
+	slug: string;
+	tier: string;
+	verdict: Verdict;
+	note: string;
+}
+
+export interface FeedbackCounts {
+	good: number;
+	bad: number;
+}
+
+export interface FeedbackStore {
+	record(rec: FeedbackRecord, nowMs?: number): string;
+	/** Verdict counts per served slug since `sinceMs`. */
+	countsBySlug(sinceMs: number, harnessId?: string): Map<string, FeedbackCounts>;
+	/** Verdicts for one ledger row (a user may re-judge). */
+	forLedgerId(ledgerId: string): Array<{ verdict: Verdict; note: string; createdAtMs: number }>;
+}
+
+export function createFeedbackStore(db: Database): FeedbackStore {
+	const insert = db.query(
+		`INSERT INTO feedback (id, ledger_id, omp_session_id, slug, tier, verdict, note, created_at_ms)
+		 VALUES ($id, $ledgerId, $ompSessionId, $slug, $tier, $verdict, $note, $createdAtMs)`,
+	);
+	const bySlug = db.query(
+		`SELECT f.slug, f.verdict, COUNT(*) AS n FROM feedback f
+		 LEFT JOIN ledger l ON l.id = f.ledger_id
+		 WHERE f.created_at_ms >= $since AND ($harness = '' OR l.harness_id = $harness)
+		 GROUP BY f.slug, f.verdict`,
+	);
+	const forRow = db.query("SELECT verdict, note, created_at_ms FROM feedback WHERE ledger_id = ? ORDER BY created_at_ms DESC");
+	return {
+		record(rec, nowMs = Date.now()) {
+			const id = crypto.randomUUID();
+			insert.run({
+				$id: id,
+				$ledgerId: rec.ledgerId,
+				$ompSessionId: rec.ompSessionId,
+				$slug: rec.slug,
+				$tier: rec.tier,
+				$verdict: rec.verdict,
+				$note: rec.note.slice(0, 500),
+				$createdAtMs: nowMs,
+			});
+			return id;
+		},
+		countsBySlug(sinceMs, harnessId = "") {
+			const out = new Map<string, FeedbackCounts>();
+			for (const r of bySlug.all({ $since: sinceMs, $harness: harnessId }) as { slug: string; verdict: string; n: number }[]) {
+				const c = out.get(r.slug) ?? { good: 0, bad: 0 };
+				if (r.verdict === "good") c.good += r.n;
+				else c.bad += r.n;
+				out.set(r.slug, c);
+			}
+			return out;
+		},
+		forLedgerId(ledgerId) {
+			return (forRow.all(ledgerId) as { verdict: Verdict; note: string; created_at_ms: number }[]).map((r) => ({
+				verdict: r.verdict,
+				note: r.note,
+				createdAtMs: r.created_at_ms,
+			}));
+		},
+	};
+}

package/src/cost/ledger.ts

@@ -24,6 +24,7 @@ import type {
 	Ledger,
 	LedgerEntry,
 	LedgerSignals,
+	ModelCacheReliability,
 	ModelLatency,
 	ModelTrust,
 	UsageCounts,
@@ -38,6 +39,14 @@ const MAX_SANE_BYTES_PER_TOKEN = 8;
 const MIN_ESCALATION_SAMPLES = 10;
 /** The escalation-cost aggregate scans a window of rows; memoised for this long. */
 const ESCALATION_COST_MEMO_MS = 60_000;
+
+/**
+ * Cache reliability is one window-function pass over the newest rows, memoised
+ * for a minute: the previous kept turn of each conversation is found with LAG,
+ * and a row counts when that turn was on the same model within the warm TTL.
+ */
+const CACHE_RELIABILITY_ROWS = 6_000;
+const CACHE_RELIABILITY_MEMO_MS = 60_000;
 const DAY_MS = 86_400_000;
 
 // Row shapes below are fixed by our own schema in util/sqlite.ts.
@@ -85,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;
@@ -177,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,
 	};
 }
@@ -236,7 +262,42 @@ function toEntry(row: LedgerRow): LedgerEntry {
 	};
 }
 
+export interface CacheReliabilityRow {
+	slug: string;
+	samples: number;
+	hit: number;
+}
+
+/**
+ * Observed cache hit rates when a warm cache was expected, per served slug.
+ * `sinceMs` bounds the rows scanned (0 ⇒ the newest `limitRows`). Rows whose
+ * cache count the router estimated (`usage.cachedEstimated`) are excluded.
+ */
+export function queryCacheReliability(db: Database, opts: { warmTtlMs: number; sinceMs?: number; limitRows?: number }): CacheReliabilityRow[] {
+	const sinceMs = opts.sinceMs ?? 0;
+	const limitRows = opts.limitRows ?? CACHE_RELIABILITY_ROWS;
+	return db
+		.query(
+			`WITH recent AS (
+				SELECT conversation_key AS ck, created_at_ms AS t, COALESCE(served_slug, slug) AS s,
+					json_extract(usage, '$.promptTokens') AS p, json_extract(usage, '$.cachedTokens') AS c,
+					COALESCE(json_extract(usage, '$.cachedEstimated'), 0) AS est
+				FROM ledger WHERE wasted = 0 AND error IS NULL AND created_at_ms >= $since
+				ORDER BY created_at_ms DESC LIMIT $limit),
+			seq AS (
+				SELECT s, p, c, est, t,
+					LAG(s) OVER w AS prev_s, LAG(p) OVER w AS prev_p, LAG(t) OVER w AS prev_t
+				FROM recent WINDOW w AS (PARTITION BY ck ORDER BY t))
+			SELECT s AS slug, COUNT(*) AS samples, AVG(MIN(1.0, c * 1.0 / MIN(prev_p, p))) AS hit
+			FROM seq
+			WHERE prev_s = s AND p > 1000 AND prev_p > 1000 AND t - prev_t <= $ttl AND est = 0
+			GROUP BY s`,
+		)
+		.all({ $since: sinceMs, $limit: limitRows, $ttl: opts.warmTtlMs }) as CacheReliabilityRow[];
+}
+
 export function createLedger(db: Database, cfg: RouterConfig): Ledger {
+	let cacheMemo: { atMs: number; map: Map<string, ModelCacheReliability> } | null = null;
 	// Prepared once: record() runs on every turn.
 	const insertStmt = db.query(
 		`INSERT INTO ledger (
@@ -268,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})`,
 	);
@@ -276,6 +348,10 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 	);
 	const ratioStmt = db.query("SELECT est_bytes, actual_tokens, samples FROM token_calibration WHERE tokenizer = ?");
 	const recentStmt = db.query("SELECT * FROM ledger ORDER BY created_at_ms DESC LIMIT ?");
+	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 ?");
 	// 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.
@@ -399,13 +475,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 {
@@ -428,13 +508,25 @@ 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),
 				});
 			}
 			return out;
 		},
 
+		cacheReliability(slug: string): ModelCacheReliability | null {
+			const now = Date.now();
+			if (cacheMemo === null || now - cacheMemo.atMs > CACHE_RELIABILITY_MEMO_MS) {
+				const map = new Map<string, ModelCacheReliability>();
+				for (const r of queryCacheReliability(db, { warmTtlMs: cfg.hysteresis.cacheWarmTtlMs })) {
+					map.set(r.slug, { slug: r.slug, samples: r.samples, hitRate: Math.min(1, Math.max(0, r.hit)) });
+				}
+				cacheMemo = { atMs: now, map };
+			}
+			return cacheMemo.map.get(slug) ?? null;
+		},
+
 		escalationCost(windowDays: number): EscalationCost | null {
 			const now = Date.now();
 			if (escalationMemo !== null && escalationMemo.windowDays === windowDays && now - escalationMemo.atMs < ESCALATION_COST_MEMO_MS) {
@@ -459,5 +551,18 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 			const rows = recentStmt.all(limit) as LedgerRow[];
 			return rows.map(toEntry);
 		},
+		providerSpendSince(slugPrefix: string, sinceMs: number): number {
+			const row = providerSpendStmt.get(sinceMs, `${slugPrefix}%`) as { total: number } | null;
+			return row?.total ?? 0;
+		},
+		latestForSession(ompSessionId: string): LedgerEntry | null {
+			if (ompSessionId === "") return null;
+			const row = sessionStmt.get(ompSessionId, 1) as LedgerRow | null;
+			return row === null ? null : toEntry(row);
+		},
+		entriesForSession(ompSessionId: string, limit: number): LedgerEntry[] {
+			if (ompSessionId === "") return [];
+			return (sessionStmt.all(ompSessionId, Math.max(1, limit)) as LedgerRow[]).map(toEntry);
+		},
 	};
 }