auto-model-router 0.3.0 → 0.3.1

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.3.0",
+    "version": "0.3.1",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -508,8 +508,10 @@ What it shows, for the window:
 Spend follows the ledger's rule — the provider's reported cost when it gave
 one, else the usage-priced figure the router computed, else the forecast.
 Speed uses only clean streamed rows (TTFT recorded, no error); tokens/s is
-completion tokens over time after first token. Ollama Cloud does not report
-cached tokens, so its cache column reads 0% by construction.
+completion tokens over time after first token. Ollama Cloud caches prompt
+prefixes and bills them at its cached rate but reports no count, so the
+router estimates it (see [Ollama Cloud](#ollama-cloud)); cache rates that
+include such rows are shown with a `~`.
 
 ## Configuring the router
 
@@ -621,6 +623,7 @@ an OpenRouter sibling). See [Ollama Cloud](#ollama-cloud) below.
 | `usagePollMs` | `600000` (10 min) | How often plan usage is re-read. `0` disables it (static bias). Needs the API key; the daemon path without one keeps a static bias. |
 | `quotaCooldownMs` | `900000` | Route around Ollama this long after a 402 (credits exhausted). |
 | `rateLimitCooldownMs` | `60000` | Route around Ollama this long after a 429 (concurrency cap). |
+| `planCreditsUsd` | `0` | Dollar value of the plan's included monthly credits (Pro 60, Max 300). Lets `/health` and `/router status` show ollama.com's plan reading as dollars next to the ledger's figure. `0` shows the share only. |
 
 ### `tiers` — per-tier economic envelope
 
@@ -809,6 +812,20 @@ What happens once it is on:
   is what lets it serve `simple` and above. `ollama.twins` pins a match the
   name normaliser cannot make; an unmatched model is unscored and serves only
   `trivial`.
+- **Cached prefixes are estimated, not reported.** ollama.com caches prompt
+  prefixes automatically and bills them at the published cached-input rate,
+  but neither its OpenAI-compatible usage nor the native API carries a cached
+  token count. Measured 2026-09-07: twelve identical 162k-token requests to
+  `glm-5.3-flash` moved the plan meter by $0.06 against $0.29 at the full
+  input rate, and repeats answered in ~1.5 s. Pricing every token fresh had
+  overstated a week of Ollama spend 3.7x ($23.01 booked, $6.24 metered). The
+  router now applies its own warm-cache rule to Ollama turns: when the same
+  model served the previous turn within `hysteresis.cacheWarmTtlMs`, the
+  previous prompt is taken as the cached prefix and priced at the cached
+  rate; a first turn, a switch, or a longer gap is priced cold. The ledger
+  flags these rows (`usage.cachedEstimated`) and reports show their cache
+  rate as `~N%`. Set `planCreditsUsd` (Pro 60, Max 300) to see ollama.com's
+  own dollar reading in `/router status` as the cross-check.
 - **Same economics, same failover.** Candidates from both providers are ranked
   together; `costBias` tilts the comparison while a plan's included credits
   would otherwise go unused. **Credit-aware by default:** the router reads the

package/omp-extension/report-logic.ts

@@ -75,6 +75,7 @@ export interface HealthSnapshot {
 		cooldownUntilMs?: number | null;
 		lastTrip?: { kind?: string; atMs?: number; message?: string } | null;
 		usage?: { monthlyUsedFraction?: number | null; activityCostUsd?: number | null; fetchedAtMs?: number | null } | null;
+		meter?: { usedUsd?: number; creditsUsd?: number } | null;
 		costBias?: { configured?: number; effective?: number; biasUntilUsage?: number };
 	} | null;
 	catalog?: {
@@ -104,7 +105,8 @@ export function renderStatus(baseUrl: string, h: HealthSnapshot, nowMs = Date.no
 	} else {
 		const avail = o.available === true ? "available" : `COOLING DOWN${o.cooldownUntilMs ? ` until ${new Date(o.cooldownUntilMs).toLocaleTimeString()}` : ""}`;
 		const frac = o.usage?.monthlyUsedFraction;
-		const usage = frac === undefined || frac === null ? "plan usage unknown" : `plan usage ${(frac * 100).toFixed(0)}%`;
+		const meter = o.meter !== undefined && o.meter !== null && o.meter.usedUsd !== undefined ? ` ($${o.meter.usedUsd.toFixed(2)} of $${o.meter.creditsUsd ?? "?"})` : "";
+		const usage = frac === undefined || frac === null ? "plan usage unknown" : `plan usage ${(frac * 100).toFixed(1)}%${meter}`;
 		const bias = o.costBias === undefined ? "" : ` · cost bias ×${o.costBias.effective ?? o.costBias.configured ?? 1} (until ${((o.costBias.biasUntilUsage ?? 1) * 100).toFixed(0)}%)`;
 		const trip = o.lastTrip !== undefined && o.lastTrip !== null ? ` · last trip ${o.lastTrip.kind ?? "?"}${o.lastTrip.atMs ? ` ${mins(nowMs - o.lastTrip.atMs)} ago` : ""}` : "";
 		out.push(`ollama cloud: ${o.models ?? 0} models · ${avail} · key ${o.apiKeySource ?? "?"} · ${usage}${bias}${trip}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/config-wizard.ts

@@ -143,6 +143,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "ollama.usagePollMs", label: "Plan usage poll", kind: "number", min: 0, hint: "ms, 0=off" },
 			{ path: "ollama.quotaCooldownMs", label: "Quota (402) cooldown", kind: "number", min: 0, hint: "ms" },
 			{ path: "ollama.rateLimitCooldownMs", label: "Rate-limit (429) cooldown", kind: "number", min: 0, hint: "ms" },
+			{ path: "ollama.planCreditsUsd", label: "Plan credits per month $", kind: "number", min: 0, hint: "Pro 60, Max 300; 0=unknown" },
 		],
 	},
 	{

package/src/config/defaults.ts

@@ -56,6 +56,9 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		quotaCooldownMs: 15 * 60 * 1000,
 		// Concurrency caps clear as soon as an in-flight request finishes.
 		rateLimitCooldownMs: 60 * 1000,
+		// ollama.com reports usage as a share of the plan; the dollar figure on
+		// its dashboard is that share × the plan's credits. Unknown until set.
+		planCreditsUsd: 0,
 	},
 	benchmarks: {
 		// Keyless BenchLM alone fills real gaps, so this is on by default; the AA

package/src/config/schema.ts

@@ -53,6 +53,7 @@ const ollama = z.strictObject({
 	usagePollMs: z.number().nonnegative().optional(),
 	quotaCooldownMs: z.number().nonnegative().optional(),
 	rateLimitCooldownMs: z.number().nonnegative().optional(),
+	planCreditsUsd: z.number().nonnegative().optional(),
 });
 
 const benchmarks = z.strictObject({

package/src/config/types.ts

@@ -114,6 +114,12 @@ export interface OllamaConfig {
 	quotaCooldownMs: number;
 	/** How long to route around Ollama after a 429 (concurrency cap), ms. */
 	rateLimitCooldownMs: number;
+	/**
+	 * Dollar value of the plan's included monthly credits (Pro 60, Max 300), so
+	 * the plan-relative usage reading can be shown as dollars beside the
+	 * ledger's own Ollama figure. 0 ⇒ unknown: usage is shown as a share only.
+	 */
+	planCreditsUsd: number;
 }
 
 /**

package/src/cost/cache-estimate.ts

@@ -0,0 +1,52 @@
+/**
+ * Cache accounting for upstreams that cache but do not say so.
+ *
+ * Ollama Cloud caches prompt prefixes automatically and bills them at its
+ * published cached-input rate, but neither its OpenAI-compatible usage nor
+ * the native API carries a cached-token count. Measured 2026-09-07: twelve
+ * identical 162k-token requests to glm-5.3-flash moved the plan meter by
+ * $0.06 against $0.29 at the full input rate, and repeats answered in ~1.5s.
+ * Pricing every token fresh overstated a week of Ollama spend 3.7x ($23.01
+ * booked against $6.24 metered).
+ *
+ * The estimate reuses the rule the router already applies when it decides
+ * whether staying on a model keeps a warm cache (select.ts step 4): the
+ * previous turn's prompt is the cached prefix when the same model served the
+ * previous turn within `cacheWarmTtlMs`. Tokens beyond that prefix are fresh.
+ * A conversation's first turn, a model switch, or an idle gap past the TTL
+ * count as fully cold — the same assumption the stay/switch comparison makes.
+ *
+ * Estimated counts are flagged (`cachedEstimated`) so reports can show them
+ * as estimates and never be mistaken for provider-reported figures.
+ */
+
+import type { UsageCounts } from "./types.ts";
+
+export interface CacheEstimateContext {
+	/** Model that served the previous turn of this conversation, if any. */
+	previousSlug: string | null;
+	/** Prompt tokens of that previous turn (0 when unknown). */
+	previousPromptTokens: number;
+	/** When the previous turn settled, ms epoch. */
+	previousAtMs: number;
+	/** Model that served this turn. */
+	servedSlug: string;
+	nowMs: number;
+	/** How long a warm prefix is assumed to survive; `hysteresis.cacheWarmTtlMs`. */
+	cacheWarmTtlMs: number;
+}
+
+/**
+ * Returns usage with `cachedTokens` filled in when the upstream reported no
+ * cache activity and the router's warm-cache rule says a prefix was warm.
+ * Reported cache counts (either field non-zero) are left untouched.
+ */
+export function estimateUnreportedCache(usage: UsageCounts, ctx: CacheEstimateContext): UsageCounts {
+	if (usage.cachedTokens > 0 || usage.cacheWriteTokens > 0) return usage;
+	if (usage.promptTokens <= 0) return usage;
+	if (ctx.previousSlug === null || ctx.previousSlug !== ctx.servedSlug) return usage;
+	if (ctx.previousPromptTokens <= 0) return usage;
+	if (ctx.cacheWarmTtlMs <= 0 || ctx.nowMs - ctx.previousAtMs > ctx.cacheWarmTtlMs) return usage;
+	const cachedTokens = Math.min(ctx.previousPromptTokens, usage.promptTokens);
+	return { ...usage, cachedTokens, cachedEstimated: true };
+}

package/src/cost/report.ts

@@ -24,6 +24,8 @@ export interface ReportTotals {
 	aborted: number;
 	/** Turns that switched model mid-conversation. */
 	modelSwitches: number;
+	/** Any row in the window carries an estimated cache count. */
+	cacheEstimated: boolean;
 }
 
 export interface ReportRow {
@@ -33,6 +35,8 @@ export interface ReportRow {
 	/** Share of window spend, 0-1. */
 	share: number;
 	cacheHitRate: number;
+	/** Some rows carry router-estimated cache counts (Ollama); the rate is then an estimate. */
+	cacheEstimated: boolean;
 	avgPromptTokens: number;
 	/** Mean time to first token, ms, over streamed non-error rows; null without samples. */
 	avgTtftMs: number | null;
@@ -75,12 +79,14 @@ const CT = "json_extract(usage, '$.cachedTokens')";
 const COMP = "json_extract(usage, '$.completionTokens')";
 const PROVIDER = "CASE WHEN slug LIKE 'ollama/%' THEN 'ollama' ELSE 'openrouter' END";
 const STREAMED = "ttft_ms IS NOT NULL AND ttft_ms > 0 AND error IS NULL";
+const EST = "json_extract(usage, '$.cachedEstimated') = 1";
 
 const ROW_SELECT = `
 	COUNT(*) AS dispatches,
 	COALESCE(SUM(${USD}), 0) AS spend,
 	COALESCE(SUM(${PT}), 0) AS prompt_tokens,
 	COALESCE(SUM(${CT}), 0) AS cached_tokens,
+	SUM(CASE WHEN ${EST} THEN 1 ELSE 0 END) AS estimated_rows,
 	COALESCE(AVG(${PT}), 0) AS avg_prompt_tokens,
 	AVG(CASE WHEN ${STREAMED} THEN ttft_ms END) AS ttft_ms,
 	SUM(CASE WHEN ${STREAMED} AND latency_ms > ttft_ms AND ${COMP} > 0 THEN ${COMP} END) AS ctok_sum,
@@ -94,6 +100,7 @@ interface RawRow {
 	spend: number;
 	prompt_tokens: number;
 	cached_tokens: number;
+	estimated_rows: number | null;
 	avg_prompt_tokens: number;
 	ttft_ms: number | null;
 	ctok_sum: number | null;
@@ -109,6 +116,7 @@ function toRow(r: RawRow, windowSpend: number): ReportRow {
 		spendUsd: r.spend,
 		share: windowSpend > 0 ? r.spend / windowSpend : 0,
 		cacheHitRate: r.prompt_tokens > 0 ? r.cached_tokens / r.prompt_tokens : 0,
+		cacheEstimated: (r.estimated_rows ?? 0) > 0,
 		avgPromptTokens: Math.round(r.avg_prompt_tokens),
 		avgTtftMs: r.ttft_ms === null ? null : Math.round(r.ttft_ms),
 		tokensPerSec: r.elapsed_ms !== null && r.elapsed_ms > 0 && r.ctok_sum !== null ? (r.ctok_sum * 1000) / r.elapsed_ms : null,
@@ -137,6 +145,7 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 				COALESCE(SUM(${PT}), 0) AS prompt_tokens,
 				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 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,
@@ -150,6 +159,7 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 		prompt_tokens: number;
 		cached_tokens: number;
 		completion_tokens: number;
+		estimated_rows: number | null;
 		escalations: number | null;
 		failovers: number | null;
 		errors: number | null;
@@ -228,6 +238,7 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 			errors: t.errors ?? 0,
 			aborted: t.aborted ?? 0,
 			modelSwitches: switches,
+			cacheEstimated: (t.estimated_rows ?? 0) > 0,
 		},
 		providers,
 		models,
@@ -241,7 +252,7 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 // ---------------------------------------------------------------------------
 
 const usd = (v: number): string => (v >= 1 ? `$${v.toFixed(2)}` : `$${v.toFixed(4)}`);
-const pct = (v: number): string => `${(v * 100).toFixed(0)}%`;
+const pct = (v: number, estimated = false): string => `${estimated ? "~" : ""}${(v * 100).toFixed(0)}%`;
 const num = (v: number): string => v.toLocaleString("en-US");
 const ms = (v: number | null): string => (v === null ? "–" : v >= 1000 ? `${(v / 1000).toFixed(1)}s` : `${v}ms`);
 const tps = (v: number | null): string => (v === null ? "–" : `${v.toFixed(0)} tok/s`);
@@ -281,7 +292,7 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 	const heading = `last ${r.windowDays}d${r.harnessId === "" ? "" : ` · harness ${r.harnessId}`} · ${new Date(r.generatedAtMs).toISOString().slice(0, 16).replace("T", " ")}Z`;
 	const summary = [
 		`spend ${usd(t.spendUsd)} over ${num(t.dispatches)} dispatches in ${num(t.conversations)} conversations · ${usd(t.dispatches > 0 ? t.spendUsd / t.dispatches : 0)}/dispatch`,
-		`prompt ${num(t.promptTokens)} tok (cache hit ${pct(t.cacheHitRate)}) · completion ${num(t.completionTokens)} tok · switches ${num(t.modelSwitches)} · escalations ${num(t.escalations)} · failovers ${num(t.failovers)} · errors ${num(t.errors)} (${num(t.aborted)} aborted)`,
+		`prompt ${num(t.promptTokens)} tok (cache hit ${pct(t.cacheHitRate, t.cacheEstimated)}) · completion ${num(t.completionTokens)} tok · switches ${num(t.modelSwitches)} · escalations ${num(t.escalations)} · failovers ${num(t.failovers)} · errors ${num(t.errors)} (${num(t.aborted)} aborted)`,
 	];
 	const tables: ReportTable[] = [];
 	if (r.providers.length > 0) {
@@ -289,7 +300,7 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 			id: "providers",
 			title: "providers",
 			headers: ["provider", "dispatches", "spend", "share", "cache", "ttft", "speed", "esc", "err"],
-			rows: r.providers.map((p) => [p.key, num(p.dispatches), usd(p.spendUsd), pct(p.share), pct(p.cacheHitRate), ms(p.avgTtftMs), tps(p.tokensPerSec), num(p.escalations), num(p.errors)]),
+			rows: r.providers.map((p) => [p.key, num(p.dispatches), usd(p.spendUsd), pct(p.share), pct(p.cacheHitRate, p.cacheEstimated), ms(p.avgTtftMs), tps(p.tokensPerSec), num(p.escalations), num(p.errors)]),
 		});
 	}
 	if (r.models.length > 0) {
@@ -302,7 +313,7 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 				num(m.dispatches),
 				usd(m.spendUsd),
 				pct(m.share),
-				pct(m.cacheHitRate),
+				pct(m.cacheHitRate, m.cacheEstimated),
 				ms(m.avgTtftMs),
 				tps(m.tokensPerSec),
 				Object.entries(m.tiers)
@@ -317,7 +328,7 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 			id: "tiers",
 			title: "tiers",
 			headers: ["tier", "dispatches", "spend", "share", "cache", "avg prompt", "esc"],
-			rows: r.tiers.map((x) => [x.key, num(x.dispatches), usd(x.spendUsd), pct(x.share), pct(x.cacheHitRate), num(x.avgPromptTokens), num(x.escalations)]),
+			rows: r.tiers.map((x) => [x.key, num(x.dispatches), usd(x.spendUsd), pct(x.share), pct(x.cacheHitRate, x.cacheEstimated), num(x.avgPromptTokens), num(x.escalations)]),
 		});
 	}
 	if (r.days.length > 1) {

package/src/cost/types.ts

@@ -26,6 +26,12 @@ export interface UsageCounts {
 	reasoningTokens: number;
 	/** Images in the prompt, for per-image surcharges. */
 	images: number;
+	/**
+	 * `cachedTokens` was estimated by the router (see `cache-estimate.ts`)
+	 * because the upstream caches without reporting it (Ollama Cloud). Absent
+	 * or false ⇒ the count came from the provider.
+	 */
+	cachedEstimated?: boolean;
 }
 
 export const EMPTY_USAGE: UsageCounts = {

package/src/server/http.ts

@@ -10,6 +10,7 @@ import { createRouter } from "../router/index.ts";
 import { createConversationStore } from "../router/state.ts";
 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 type { RouterConfig } from "../config/types.ts";
@@ -410,6 +411,8 @@ export function startServer(cfg: RouterConfig): StartedServer {
 										// Plan usage as ollama.com reports it (share of included monthly
 										// credits) and the cost multiplier currently in force.
 										usage: ollamaUsage.peek(),
+										// The dashboard's dollar figure: plan share × included credits, when known.
+										meter: ollamaMeter(ollamaUsage.peek(), cfg.ollama.planCreditsUsd),
 										costBias: { configured: cfg.ollama.costBias, effective: catalog.ollamaBias?.() ?? cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage },
 									},
 						catalog: snap === null

package/src/server/turn.ts

@@ -11,6 +11,7 @@
 import type { CatalogSource } from "../catalog/types.ts";
 import type { ContextBridge } from "../context/types.ts";
 import type { RouterConfig } from "../config/types.ts";
+import { estimateUnreportedCache } from "../cost/cache-estimate.ts";
 import { computeCost } from "../cost/forecast.ts";
 import { EMPTY_USAGE, type Ledger, type UsageCounts } from "../cost/types.ts";
 import { createProbe, type Probe } from "../router/escalate.ts";
@@ -462,7 +463,22 @@ export async function runTurn(
 		// in for a turn that produced 26.
 		if (reportedUsd === null && usage.promptTokens > 0) {
 			const served = deps.catalog.find(servedSlug ?? decision.slug);
-			if (served !== undefined) reportedUsd = computeCost(served, usage).total;
+			if (served !== undefined) {
+				// Ollama caches prompt prefixes and bills them at its cached rate
+				// without reporting a count; estimate it with the router's own
+				// warm-cache rule so the ledger stops booking every token fresh.
+				if (served.provider === "ollama") {
+					usage = estimateUnreportedCache(usage, {
+						previousSlug: state.currentSlug,
+						previousPromptTokens: state.lastPromptTokens,
+						previousAtMs: state.updatedAtMs,
+						servedSlug: served.slug,
+						nowMs: Date.now(),
+						cacheWarmTtlMs: config.hysteresis.cacheWarmTtlMs,
+					});
+				}
+				reportedUsd = computeCost(served, usage).total;
+			}
 		}
 
 		if (sinkDied) {

package/src/upstream/ollama-usage.ts

@@ -155,3 +155,9 @@ export function effectiveOllamaBias(costBias: number, biasUntilUsage: number, us
 	if (used === null) return costBias;
 	return used >= biasUntilUsage ? 1 : costBias;
 }
+
+/** The dashboard's dollar reading: plan share × included credits, when both are known. */
+export function ollamaMeter(usage: OllamaUsage | null, planCreditsUsd: number): { usedUsd: number; creditsUsd: number } | null {
+	if (usage === null || usage.monthlyUsedFraction === null || !(planCreditsUsd > 0)) return null;
+	return { usedUsd: Math.round(usage.monthlyUsedFraction * planCreditsUsd * 100) / 100, creditsUsd: planCreditsUsd };
+}

package/test/cache-estimate.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test";
+
+import { estimateUnreportedCache } from "../src/cost/cache-estimate.ts";
+import { EMPTY_USAGE, type UsageCounts } from "../src/cost/types.ts";
+
+/**
+ * Ollama Cloud caches prompt prefixes and bills them at its cached rate but
+ * reports no count (measured 2026-09-07: 12 identical 162k-token requests
+ * moved the plan meter $0.06 against $0.29 at the full rate). The estimate
+ * follows the router's warm-cache rule: same model as the previous turn
+ * within the TTL ⇒ the previous prompt is the cached prefix.
+ */
+
+const base = (over: Partial<UsageCounts> = {}): UsageCounts => ({ ...EMPTY_USAGE, promptTokens: 120_000, completionTokens: 300, ...over });
+const ctx = { previousSlug: "ollama/glm", previousPromptTokens: 100_000, previousAtMs: 1_000_000, servedSlug: "ollama/glm", nowMs: 1_060_000, cacheWarmTtlMs: 300_000 };
+
+describe("estimateUnreportedCache", () => {
+	test("same model within the TTL: the previous prompt is the cached prefix, flagged as estimated", () => {
+		const out = estimateUnreportedCache(base(), ctx);
+		expect(out.cachedTokens).toBe(100_000);
+		expect(out.cachedEstimated).toBe(true);
+		expect(out.promptTokens).toBe(120_000);
+	});
+
+	test("a shorter prompt than the previous one caps the cached count at the prompt", () => {
+		expect(estimateUnreportedCache(base({ promptTokens: 40_000 }), ctx).cachedTokens).toBe(40_000);
+	});
+
+	test("first turn, model switch, or idle past the TTL count as cold", () => {
+		expect(estimateUnreportedCache(base(), { ...ctx, previousSlug: null }).cachedTokens).toBe(0);
+		expect(estimateUnreportedCache(base(), { ...ctx, previousSlug: "ollama/other" }).cachedTokens).toBe(0);
+		expect(estimateUnreportedCache(base(), { ...ctx, nowMs: ctx.previousAtMs + 300_001 }).cachedTokens).toBe(0);
+		expect(estimateUnreportedCache(base(), { ...ctx, previousPromptTokens: 0 }).cachedTokens).toBe(0);
+		expect(estimateUnreportedCache(base(), { ...ctx, cacheWarmTtlMs: 0 }).cachedTokens).toBe(0);
+	});
+
+	test("provider-reported cache counts are never overwritten", () => {
+		const reported = base({ cachedTokens: 5_000 });
+		expect(estimateUnreportedCache(reported, ctx)).toBe(reported);
+		const written = base({ cacheWriteTokens: 5_000 });
+		expect(estimateUnreportedCache(written, ctx)).toBe(written);
+	});
+
+	test("no prompt tokens: nothing to estimate", () => {
+		const empty = base({ promptTokens: 0 });
+		expect(estimateUnreportedCache(empty, ctx)).toBe(empty);
+	});
+});

package/test/failover.test.ts

@@ -31,7 +31,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
 		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
 		openrouter: { baseUrl: "https://openrouter.ai/api/v1", apiKey: "", title: "test", timeoutMs: 30_000, catalogTtlMs: 3_600_000, catalogRefreshMs: 0 },
-		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0 },
+		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0, planCreditsUsd: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
 		tiers: {
 			trivial: { minQuality: 0, maxInputPerMtok: 0.3, qualityExponent: 0, pin: [] },

package/test/ollama.test.ts

@@ -22,7 +22,7 @@ import { buildCandidates } from "../src/router/candidates.ts";
 import { extractFeatures } from "../src/router/features.ts";
 import { createMultiUpstream } from "../src/upstream/multi.ts";
 import { classifyOllamaStatus, createOllamaClient, toOllamaBody } from "../src/upstream/ollama.ts";
-import { createOllamaUsageSource, effectiveOllamaBias, NO_USAGE, parseOllamaUsage, usageFraction } from "../src/upstream/ollama-usage.ts";
+import { createOllamaUsageSource, effectiveOllamaBias, NO_USAGE, ollamaMeter, parseOllamaUsage, usageFraction } from "../src/upstream/ollama-usage.ts";
 import type { Dispatch, DispatchOptions, UpstreamClient } from "../src/upstream/types.ts";
 import { createLogger } from "../src/util/log.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
@@ -314,7 +314,7 @@ describe("ollama client", () => {
 
 	test("a 429 with a zero cooldown does not trip the breaker", async () => {
 		const fetchImpl = (async (): Promise<Response> => new Response("slow down", { status: 429 }));
-		const client = createOllamaClient(cfgWith({ rateLimitCooldownMs: 0 }), fetchImpl);
+		const client = createOllamaClient(cfgWith({ rateLimitCooldownMs: 0, planCreditsUsd: 0 }), fetchImpl);
 		await client.dispatch({ body: { model: "ollama/x", messages: [] }, sessionId: "s", signal: new AbortController().signal }).catch(() => {});
 		expect(client.available()).toBe(true);
 	});
@@ -504,3 +504,18 @@ describe("ollama plan usage (credit-aware bias)", () => {
 	});
 });
 
+
+describe("ollamaMeter", () => {
+	test("plan share times credits is the dashboard's dollar figure", () => {
+		const usage = { monthlyUsedFraction: 0.104, monthlyUsageRaw: 0.104, activityCostUsd: 0, requestsThisMonth: 1250, fetchedAtMs: 1 };
+		// 10.4% of Pro's $60 is the $6.24 ollama.com shows.
+		expect(ollamaMeter(usage, 60)).toEqual({ usedUsd: 6.24, creditsUsd: 60 });
+	});
+
+	test("unknown credits or usage yields no meter", () => {
+		const usage = { monthlyUsedFraction: 0.5, monthlyUsageRaw: 0.5, activityCostUsd: 0, requestsThisMonth: 1, fetchedAtMs: 1 };
+		expect(ollamaMeter(usage, 0)).toBeNull();
+		expect(ollamaMeter(null, 60)).toBeNull();
+		expect(ollamaMeter({ ...usage, monthlyUsedFraction: null }, 60)).toBeNull();
+	});
+});

package/test/report-hub.test.ts

@@ -51,6 +51,7 @@ function report(over: Partial<UsageReport> = {}): UsageReport {
 		spendUsd: spend,
 		share: 0.5,
 		cacheHitRate: 0.8,
+		cacheEstimated: false,
 		avgPromptTokens: 1000,
 		avgTtftMs: 900,
 		tokensPerSec: 120,
@@ -74,6 +75,7 @@ function report(over: Partial<UsageReport> = {}): UsageReport {
 			errors: 0,
 			aborted: 0,
 			modelSwitches: 1,
+			cacheEstimated: false,
 		},
 		providers: [row("openrouter", 2), row("ollama", 1)],
 		models: [

package/test/report-logic.test.ts

@@ -65,6 +65,7 @@ describe("renderStatus", () => {
 				apiKeySource: "omp",
 				lastTrip: { kind: "quota", atMs: now - 120_000, message: "402" },
 				usage: { monthlyUsedFraction: 0.42, activityCostUsd: 3.1, fetchedAtMs: now },
+				meter: { usedUsd: 25.2, creditsUsd: 60 },
 				costBias: { configured: 0.1, effective: 0.1, biasUntilUsage: 0.9 },
 			},
 			catalog: { models: 240, ageMs: 5 * 60_000, keyScoped: true, shrink: { fromModels: 300, toModels: 120, atMs: now } },
@@ -75,7 +76,7 @@ describe("renderStatus", () => {
 		expect(text).toContain("refreshed 5m ago");
 		expect(text).toContain("SHRANK 300 -> 120");
 		expect(text).toContain("COOLING DOWN");
-		expect(text).toContain("plan usage 42%");
+		expect(text).toContain("plan usage 42.0% ($25.20 of $60)");
 		expect(text).toContain("cost bias ×0.1 (until 90%)");
 		expect(text).toContain("last trip quota 2m ago");
 		expect(text).toContain("scope omp-router");

package/test/report.test.ts

@@ -171,6 +171,7 @@ describe("buildUsageReport", () => {
 			errors: 0,
 			aborted: 0,
 			modelSwitches: 0,
+			cacheEstimated: false,
 		});
 		expect(r.providers).toEqual([]);
 		expect(r.models).toEqual([]);
@@ -189,6 +190,21 @@ describe("buildUsageReport", () => {
 });
 
 describe("renderUsageReport", () => {
+	test("router-estimated cache counts render as an estimate", async () => {
+		const { db, ledger } = seeded();
+		ledger.record(entry({ slug: "ollama/glm", servedSlug: "ollama/glm", usage: { promptTokens: 1000, cachedTokens: 900, cacheWriteTokens: 0, completionTokens: 10, reasoningTokens: 0, images: 0, cachedEstimated: true } }));
+		ledger.record(entry({ usage: { promptTokens: 1000, cachedTokens: 500, cacheWriteTokens: 0, completionTokens: 10, reasoningTokens: 0, images: 0 } }));
+		const r = buildUsageReport(db, { windowDays: 7, nowMs: NOW });
+		expect(r.totals.cacheEstimated).toBe(true);
+		expect(r.providers.find((p) => p.key === "ollama")!.cacheEstimated).toBe(true);
+		expect(r.providers.find((p) => p.key === "openrouter")!.cacheEstimated).toBe(false);
+		const text = renderUsageReport(r);
+		expect(text).toContain("(cache hit ~70%)");
+		expect(text).toMatch(/ollama\s+1\s+\S+\s+\S+\s+~90%/);
+		expect(text).toMatch(/openrouter\s+1\s+\S+\s+\S+\s+50%/);
+		db.close();
+	});
+
 	test("renders every section as plain fixed-width text", () => {
 		const { db, ledger } = seeded();
 		ledger.record(entry({ reportedUsd: 1.25, createdAtMs: NOW - HOUR }));

package/test/turn.test.ts

@@ -31,7 +31,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
 		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
 		openrouter: { baseUrl: "https://openrouter.ai/api/v1", apiKey: "", title: "test", timeoutMs: 30_000, catalogTtlMs: 3_600_000, catalogRefreshMs: 0 },
-		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0 },
+		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0, planCreditsUsd: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
 		tiers: {
 			trivial: { minQuality: 0, maxInputPerMtok: 0.3, qualityExponent: 0, pin: [] },
@@ -846,4 +846,53 @@ describe("latency measurement covers the work the router actually does", () => {
 		expect(finishes[0]!.reportedUsd).toBeCloseTo(0.65, 6);
 	});
 
+	test("an Ollama-served turn after another on the same model prices the previous prompt as cached", async () => {
+		// ollama.com caches prefixes and bills them at the cached rate without
+		// reporting a count; the router estimates it with its warm-cache rule.
+		const ollamaModel: CatalogModel = {
+			slug: "ollama/glm-5.3-flash",
+			provider: "ollama",
+			canonicalSlug: "ollama/glm-5.3-flash",
+			name: "glm",
+			contextLength: 1_000_000,
+			supportsTools: true,
+			supportsReasoning: true,
+			reasoningMandatory: false,
+			supportsToolChoice: false,
+			inputModalities: ["text"],
+			price: { prompt: 0.15 / 1e6, cacheRead: 0.03 / 1e6, completion: 0.5 / 1e6 },
+			priceTiers: [],
+			quality: {},
+			tokenizer: "Other",
+			isFree: false,
+			createdAtMs: 0,
+			author: "ollama",
+		};
+		const priced = { ...catalog, find: (slug: string) => (slug === ollamaModel.slug ? ollamaModel : undefined) };
+		const turn = (prompt: number) => ({
+			kind: "chunks" as const,
+			chunks: [startChunk(ollamaModel.slug), textChunk("ok"), finishChunk("stop"), usageChunk({ promptTokens: prompt, completionTokens: 0 }, null)],
+		});
+		const { router } = mkRouter([mkDecision("simple", ollamaModel.slug)]);
+		const { upstream } = mkUpstream([turn(100_000), turn(120_000)]);
+		const { ledger, entries } = mkLedger();
+		const { store, map } = mkConversations();
+		const deps = { config: mkConfig(), router, upstream, ledger, conversations: store, catalog: priced, context: createDisabledBridge() };
+
+		await runTurn(mkReq(), mkSink().sink, deps, new AbortController().signal);
+		// First turn: nothing to be cached yet, full input rate.
+		expect(entries[0]!.usage.cachedTokens).toBe(0);
+		expect(entries[0]!.usage.cachedEstimated).toBeUndefined();
+		expect(entries[0]!.reportedUsd).toBeCloseTo(0.015, 6);
+
+		await runTurn(mkReq(), mkSink().sink, deps, new AbortController().signal);
+		// Second turn on the same model: the 100k previous prompt is the cached
+		// prefix at $0.03/M, the 20k of growth is fresh at $0.15/M.
+		expect(entries[1]!.usage.cachedTokens).toBe(100_000);
+		expect(entries[1]!.usage.cachedEstimated).toBe(true);
+		expect(entries[1]!.reportedUsd).toBeCloseTo(0.003 + 0.003, 6);
+		// The estimate is evidence enough to keep the Ollama model warm for the stay/switch comparison.
+		expect(map.get("conv-test")!.cacheWarmSlug).toBe(ollamaModel.slug);
+	});
+
 });

package/tools/recompute-ollama-cache.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env bun
+/**
+ * One-off backfill: re-price historical Ollama ledger rows with the router's
+ * cache estimate (`src/cost/cache-estimate.ts`).
+ *
+ * Rows recorded before the estimate existed booked every prompt token at the
+ * full input rate, overstating Ollama spend ~3.7x against ollama.com's meter.
+ * This walks each conversation's Ollama rows in order, applies the same rule
+ * the live path applies (same model as the previous kept row within
+ * `hysteresis.cacheWarmTtlMs` ⇒ the previous prompt is the cached prefix),
+ * and rewrites `usage`, `cost_breakdown` and `reported_usd` for rows whose
+ * cost the router itself computed (Ollama never reports a cost). Rows that
+ * already carry a cache count are left alone, so it is safe to re-run.
+ *
+ * Usage:
+ *   bun tools/recompute-ollama-cache.ts            # dry run: prints the delta
+ *   bun tools/recompute-ollama-cache.ts --apply    # backs up router.db, then writes
+ */
+
+import { copyFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { Database } from "bun:sqlite";
+import { ollamaRateFor } from "../src/catalog/ollama-prices.ts";
+import { loadConfig } from "../src/config/load.ts";
+import { estimateUnreportedCache } from "../src/cost/cache-estimate.ts";
+import type { UsageCounts } from "../src/cost/types.ts";
+
+const apply = process.argv.includes("--apply");
+const cfg = loadConfig({});
+const ttl = cfg.hysteresis.cacheWarmTtlMs;
+
+interface Row {
+	id: string;
+	ck: string;
+	t: number;
+	latency: number;
+	slug: string;
+	usage: string;
+	reported: number | null;
+	wasted: number;
+	error: string | null;
+}
+
+const db = new Database(cfg.ledger.path);
+db.exec("PRAGMA busy_timeout = 5000");
+const rows = db
+	.query(
+		`SELECT id, conversation_key ck, created_at_ms t, latency_ms latency, COALESCE(served_slug, slug) slug, usage, reported_usd reported, wasted, error
+		 FROM ledger WHERE COALESCE(served_slug, slug) LIKE 'ollama/%' ORDER BY conversation_key, created_at_ms`,
+	)
+	.all() as Row[];
+
+let before = 0;
+let after = 0;
+let changed = 0;
+const updates: { id: string; usage: string; breakdown: string; usd: number }[] = [];
+let prev: Row | undefined;
+let prevPrompt = 0;
+for (const r of rows) {
+	const usage = JSON.parse(r.usage) as UsageCounts;
+	const sameConv = prev !== undefined && prev.ck === r.ck;
+	const rate = ollamaRateFor(r.slug.slice("ollama/".length), cfg.ollama.prices);
+	before += r.reported ?? 0;
+	if (rate === null || r.reported === null || r.error !== null) {
+		after += r.reported ?? 0;
+		if (r.error === null) {
+			prev = r;
+			prevPrompt = usage.promptTokens;
+		}
+		continue;
+	}
+	const est = estimateUnreportedCache(usage, {
+		previousSlug: sameConv ? (prev?.slug ?? null) : null,
+		previousPromptTokens: sameConv ? prevPrompt : 0,
+		previousAtMs: sameConv ? (prev?.t ?? 0) : 0,
+		servedSlug: r.slug,
+		nowMs: r.t,
+		cacheWarmTtlMs: ttl,
+	});
+	const input = rate.rate.input / 1e6;
+	const cached = (rate.rate.cachedInput ?? rate.rate.input) / 1e6;
+	const output = rate.rate.output / 1e6;
+	const fresh = Math.max(0, est.promptTokens - est.cachedTokens);
+	const breakdown = {
+		freshPrompt: fresh * input,
+		cacheRead: est.cachedTokens * cached,
+		cacheWrite: 0,
+		completion: est.completionTokens * output,
+		reasoning: 0,
+		images: 0,
+		request: 0,
+		total: 0,
+		tierAtPromptTokens: 0,
+	};
+	breakdown.total = breakdown.freshPrompt + breakdown.cacheRead + breakdown.completion;
+	after += breakdown.total;
+	if (est.cachedTokens !== usage.cachedTokens) {
+		changed++;
+		updates.push({ id: r.id, usage: JSON.stringify(est), breakdown: JSON.stringify(breakdown), usd: breakdown.total });
+	}
+	// The next row's "previous" is this row as dispatched, whether or not it was wasted:
+	// a wasted probe still warmed the prefix.
+	prev = r;
+	prevPrompt = est.promptTokens;
+}
+
+console.log(`ollama rows: ${rows.length}, re-priced: ${changed}`);
+console.log(`ledger Ollama spend: $${before.toFixed(2)} → $${after.toFixed(2)}`);
+if (!apply) {
+	console.log("dry run; pass --apply to write (router.db is backed up first)");
+	db.close();
+	process.exit(0);
+}
+
+const backupDir = join(dirname(cfg.ledger.path), "backups");
+mkdirSync(backupDir, { recursive: true });
+const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "");
+const backup = join(backupDir, `router-pre-ollama-cache-${stamp}.db`);
+db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+copyFileSync(cfg.ledger.path, backup);
+console.log(`backup: ${backup}`);
+
+const stmt = db.prepare("UPDATE ledger SET usage = $usage, cost_breakdown = $breakdown, reported_usd = $usd WHERE id = $id");
+const tx = db.transaction((list: typeof updates) => {
+	for (const u of list) stmt.run({ $usage: u.usage, $breakdown: u.breakdown, $usd: u.usd, $id: u.id });
+});
+tx(updates);
+console.log(`updated ${updates.length} rows`);
+db.close();