auto-model-router 0.4.7 → 0.4.9

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.4.7",
+    "version": "0.4.9",
     "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.4.7",
+      "version": "0.4.9",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -410,8 +410,12 @@ user-visible notice channel; use `/router why`), the automatic daily summary
 
 ### Codex CLI
 
-Codex talks to custom providers over the chat-completions wire. Run the
-router (`auto-model-router serve --port 8788`) and add a provider:
+Codex (0.150 and later) speaks only the Responses API, which the router
+serves at `POST /v1/responses`: the body is translated to the chat shape
+the router routes on (`instructions` → system, `input` items → messages,
+function calls and outputs → tool calls and tool messages) and the upstream
+stream is rendered back as Responses events. Run the router
+(`auto-model-router serve --port 8788`) and add a provider:
 
 ```toml
 # ~/.codex/config.toml
@@ -421,13 +425,19 @@ model_provider = "auto-model-router"
 [model_providers.auto-model-router]
 name = "auto-model-router"
 base_url = "http://127.0.0.1:8788/v1"
-wire_api = "chat"
+env_key = "AUTO_MODEL_ROUTER_API_KEY"   # any value; the router is keyless
+wire_api = "responses"
 http_headers = { "X-Omp-Harness" = "codex" }
 ```
 
-The router drops the OpenAI-platform-only parameters Codex sends (`store`,
-`prompt_cache_key`, `service_tier`) before dispatch. No session id or hooks:
-reports are per harness, and there is no toast, digest or `/router`.
+Verified live with codex 0.153, text and tool-call turns: the captured
+request is `test/fixtures/harness/codex-responses.json`. Stateless only —
+Codex sends `store: false` and the full input each turn; `previous_response_id`
+is rejected. Reasoning summaries and encrypted reasoning are not produced.
+Codex's thread id (sent in the body) becomes the session id and its agent
+name marks subagents, so per-session reports, feedback over the HTTP API and
+the subagent profile work without a plugin. No hooks: there is no toast,
+digest or `/router`.
 
 ### Aider
 
@@ -437,8 +447,20 @@ export OPENAI_API_KEY=local
 aider --model openai/auto
 ```
 
-Aider sends no tool calls, so every turn classifies on its text alone. No
-session id or hooks.
+Verified live with aider 0.86 (captured request:
+`test/fixtures/harness/aider.json`). Aider sends no tool calls, so every turn
+classifies on its text alone. It sends no custom headers by default; a model
+settings file in the project adds the harness id (verified live):
+
+```yaml
+# .aider.model.settings.yml
+- name: openai/auto
+  extra_params:
+    extra_headers:
+      X-Omp-Harness: aider
+```
+
+No session id or hooks.
 
 ### Cline, Roo Code, Kilo Code
 
@@ -468,9 +490,28 @@ digest applies only through summarising compaction
 }
 ```
 
-OpenCode's tool names (`read`, `grep`, `glob`, `bash`, `webfetch`) match the
-router's canonical list. Its plugin API has tool and message hooks, so a
-native port (session identity, digest) is the next candidate after Hermes.
+Verified live with opencode 1.18 (captured request:
+`test/fixtures/harness/opencode.json`). OpenCode's AI SDK validates every
+SSE frame, which is why the router's final summary frame is shaped as a
+chunk with no choices. Its tool names (`read`, `grep`, `glob`, `bash`,
+`webfetch`) match the router's canonical list.
+
+**Native features (OpenCode plugin API).** Copy
+`opencode-plugin/auto-model-router.ts` to `~/.config/opencode/plugin/` (or a
+project's `.opencode/plugin/`); OpenCode loads it on start. It adds:
+
+- **Session identity** — `X-Omp-Session`, `X-Omp-Harness` (`opencode`, or
+  `OMP_HARNESS_ID`) and `X-Omp-Subagent` for sessions with a parent, through
+  the `chat.headers` hook.
+- **Routing toast** — when a session goes idle, its last routed turn's
+  provider, model, tier and cost appear as a TUI toast.
+- **Tool-result digest** — large `read`, `grep`, `glob`, `bash` and
+  `webfetch` results go to `/v1/router/digest` through `tool.execute.after`
+  and the model gets the digest. Off unless `digest.enabled`.
+
+No `/router` command (OpenCode commands are markdown files, not plugin
+hooks): use `auto-model-router report` on the terminal, or the router's
+HTTP endpoints.
 
 ### The OpenRouter key
 
@@ -1070,6 +1111,25 @@ there); and the switch happens at prompt boundaries, never mid-turn.
 
 ## Multiple coding harnesses, one router
 
+**One router process for everything.** omp's embed extension binds a private
+router on an ephemeral port per session by default, while Hermes, Codex,
+OpenCode and Aider talk to a standalone router on port 8788. Those are two
+processes over two homes, and per-process state (pins, the digest re-run
+memory) and reports stay apart. To share one router:
+
+1. Run it once, before the harnesses start: `auto-model-router serve --port 8788`
+   (against the default home, `~/.auto-model-router`).
+2. Set `AUTO_MODEL_ROUTER_PORT=8788` in omp's environment. The embed then
+   attaches to the router already answering on that port instead of binding
+   its own (it still binds 8788 itself if nothing is there, which the others
+   then reuse).
+3. Point Hermes, Codex, OpenCode and Aider at `http://127.0.0.1:8788/v1` as
+   in their recipes. Hermes's provider plugin only spawns a router when
+   nothing listens on 8788, so it joins the shared one too.
+
+Each harness keeps its own `X-Omp-Harness` id, so budgets and reports stay
+per harness while the ledger, catalog and conversation state are shared.
+
 What each harness gets today. "Config only" means the OpenAI-compatible wire
 plus a harness header; the rest needs the harness's own hook API.
 
@@ -1077,10 +1137,10 @@ plus a harness header; the rest needs the harness's own hook API.
 | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | omp | native provider | yes | yes | yes | yes | full hub | yes | yes | experimental |
 | Hermes | provider plugin | yes | yes (native plugin) | yes (native plugin) | no | text | yes (native plugin) | on demand | no |
-| Codex CLI | config only | yes | no | no | no | no | compaction only | no | no |
-| Aider | config only | yes | no | no | no | no | no tools | no | no |
+| Codex CLI | Responses API wire | yes | yes (from body) | yes (from body) | no | no | compaction only | no | no |
+| Aider | config only | via model settings | no | no | no | no | no tools | no | no |
 | Cline / Roo / Kilo | config only | if headers supported | no | no | no | no | compaction only | no | no |
-| OpenCode | config only | yes | no | no | no | no | compaction only | no | no |
+| OpenCode | config + plugin | yes | yes (plugin) | yes (plugin) | yes (plugin) | no | yes (plugin) | no | no |
 | Claude Code | needs an Anthropic Messages wire module | — | — | — | — | — | — | — | — |
 
 A single embedded router can serve several omp sessions without them stepping

package/hermes-plugin/native/selftest.py

@@ -0,0 +1,103 @@
+"""Self-test for the Hermes native plugin's pure functions.
+
+Run by test/hermes-plugin.test.ts when a Python interpreter is on PATH (the
+Bun suite cannot import Python), and directly:
+
+    python hermes-plugin/native/selftest.py
+
+Exercises identity headers, the digest gate and replacement, and the /router
+command rendering against fake transports. Exits non-zero on the first
+failure with the assertion that failed.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+spec = importlib.util.spec_from_file_location("amr_native", os.path.join(HERE, "__init__.py"))
+m = importlib.util.module_from_spec(spec)
+assert spec.loader is not None
+spec.loader.exec_module(m)
+
+
+def test_identity_headers() -> None:
+    m.on_pre_llm_call(session_id="s1", parent_session_id="")
+    m.on_pre_llm_call(session_id="s2", parent_session_id="s1")
+    r = m.on_llm_request(request={"model": "auto", "extra_headers": {"A": "b"}}, provider="auto-model-router", session_id="s2")
+    assert r["request"]["extra_headers"] == {"A": "b", "X-Omp-Harness": m.HARNESS_ID, "X-Omp-Session": "s2", "X-Omp-Subagent": "1"}, r
+    main = m.on_llm_request(request={"model": "auto"}, provider="auto-model-router", session_id="s1")
+    assert "X-Omp-Subagent" not in main["request"]["extra_headers"], main
+    assert m.on_llm_request(request={}, provider="anthropic", session_id="s1") is None
+    assert m._CURRENT["session_id"] == "s1"
+
+
+def test_digest() -> None:
+    m.POLICY.value = {"enabled": True, "minBytes": 10, "maxBytes": 100000, "tools": ["read", "grep", "bash"], "toolAliases": {"read_file": "read", "terminal": "bash"}, "fromTier": "moderate"}
+    m.POLICY._at = 10**12
+    calls = []
+
+    def fake_post(path, payload, timeout=0):
+        calls.append((path, payload["toolName"], len(payload["content"])))
+        return {"digested": True, "text": "[digest] short"}
+
+    big = json.dumps({"content": "x" * 500, "path": "a.ts"})
+    out = m.maybe_digest(big, "read_file", {"path": "a.ts"}, "s1", post=fake_post)
+    assert json.loads(out)["content"] == "[digest] short", out
+    assert json.loads(out)["path"] == "a.ts"
+    assert calls == [("/v1/router/digest", "read_file", 500)], calls
+    err = json.dumps({"error": "nope", "content": "x" * 500})
+    assert m.maybe_digest(err, "read_file", {}, "s1", post=fake_post) == err
+    assert m.maybe_digest(json.dumps({"content": "x" * 500}), "write_file", {}, "s1", post=fake_post).startswith('{"content": "xxx')
+    plain = "plain text " * 100
+    assert m.maybe_digest(plain, "read_file", {}, "s1", post=fake_post) == plain
+    assert len(calls) == 1
+    assert m.canonical_tool(m.POLICY.value, "TERMINAL") == "bash"
+    assert m.largest_string_field({"a": "x" * 90, "b": "y" * 5}) == "a"
+    assert m.largest_string_field({"a": "x" * 50, "b": "y" * 50}) is None
+
+
+def test_router_command() -> None:
+    def fake_get(path, timeout=5.0, text=False):
+        if path.startswith("/v1/router/report"):
+            return "REPORT " + path
+        if path.startswith("/v1/router/summary"):
+            return "SUMMARY " + path
+        if path.startswith("/health"):
+            return {"status": "ok", "apiKeyConfigured": True, "apiKeySource": "env", "catalog": {"models": 3}, "ollama": None, "softFailures": {"spikes": [{"slug": "a/b", "recentRate": 0.5, "recentDispatches": 8, "baselineRate": 0.05}]}}
+        if path.startswith("/v1/router/decisions"):
+            return {"entries": [{"slug": "a/b", "tier": "hard", "classificationSource": "heuristic", "confidence": 0.7, "reportedUsd": 0.0000097, "usage": {"promptTokens": 100, "cachedTokens": 50}, "latencyMs": 900, "reasons": ["r1"]}]}
+        return {}
+
+    def fake_post(path, payload, timeout=5.0):
+        if path == "/v1/router/feedback":
+            return {"slug": "a/b", "tier": "hard"}
+        return {"override": {"slug": payload.get("slug"), "tier": payload.get("tier"), "turnsLeft": payload.get("turns")}}
+
+    assert m.router_command("report 30 --all", get=fake_get, post=fake_post) == "REPORT /v1/router/report?days=30&format=text"
+    assert m.router_command("report", get=fake_get, post=fake_post).endswith(f"days=7&format=text&harness={m.HARNESS_ID}")
+    assert m.router_command("summary", get=fake_get, post=fake_post).startswith("SUMMARY /v1/router/summary?format=text&harness=")
+    status = m.router_command("status", get=fake_get, post=fake_post)
+    assert "soft failures SPIKING (1)" in status and "a/b: 50% of 8" in status, status
+    why = m.router_command("why", get=fake_get, post=fake_post)
+    assert "last turn: a/b [hard]" in why and "$0.00001" in why and "cache hit 50%" in why, why
+    assert m.router_command("good nice", get=fake_get, post=fake_post) == "recorded good for a/b [hard]"
+    assert m.router_command("pin a/b", get=fake_get, post=fake_post) == "pin: a/b"
+    assert m.router_command("tier hard 5", get=fake_get, post=fake_post) == "tier: hard for 5 turns"
+    assert m.router_command("tier off", get=fake_get, post=fake_post) == "tier: cleared"
+    assert m.router_command("bogus", get=fake_get, post=fake_post) == m.USAGE
+
+    def down(path, timeout=5.0, text=False):
+        raise OSError("connection refused")
+
+    assert m.router_command("status", get=down, post=fake_post).startswith("router unreachable at")
+
+
+if __name__ == "__main__":
+    for name, fn in [(n, f) for n, f in globals().items() if n.startswith("test_")]:
+        fn()
+        print(f"ok {name}")
+    sys.exit(0)

package/opencode-plugin/auto-model-router.ts

@@ -0,0 +1,151 @@
+/**
+ * OpenCode plugin: auto-model-router native features.
+ *
+ * OpenCode reaches the router through an OpenAI-compatible provider block
+ * (see README, "OpenCode"). This plugin adds what the provider block cannot:
+ *
+ * - **Session identity** — `chat.headers` adds `X-Omp-Session`,
+ *   `X-Omp-Harness` and, for a session with a parent (a subagent),
+ *   `X-Omp-Subagent`, so per-session reports, feedback and the router's
+ *   subagent profile work as in omp.
+ * - **Routing toast** — when a session goes idle, the model, tier and cost of
+ *   its last routed turn are shown as a TUI toast (nothing in `run` mode).
+ * - **Tool-result digest** — `tool.execute.after` sends a large read, grep,
+ *   glob, bash or webfetch result to the router's `/v1/router/digest` and
+ *   hands the model the digest instead. The router decides (policy, session
+ *   tier, cost guard). Off unless `digest.enabled` is set in the router config.
+ *
+ * Install: copy this file to `~/.config/opencode/plugin/auto-model-router.ts`
+ * (or `.opencode/plugin/` in a project). OpenCode loads it on start. The
+ * router URL is `AUTO_MODEL_ROUTER_URL`, else port `AUTO_MODEL_ROUTER_PORT`
+ * (default 8788) on localhost.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+
+const PROVIDER_ID = "auto-model-router";
+const BASE_URL = process.env.AUTO_MODEL_ROUTER_URL ?? `http://127.0.0.1:${process.env.AUTO_MODEL_ROUTER_PORT ?? "8788"}`;
+const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "opencode";
+const POLICY_TTL_MS = 60_000;
+
+interface DigestPolicy {
+	enabled: boolean;
+	minBytes: number;
+	maxBytes: number;
+	tools: string[];
+	toolAliases: Record<string, string>;
+}
+const DISABLED: DigestPolicy = { enabled: false, minBytes: 0, maxBytes: 0, tools: [], toolAliases: {} };
+
+function parsePolicy(json: unknown): DigestPolicy {
+	if (json === null || typeof json !== "object") return DISABLED;
+	const p = json as Record<string, unknown>;
+	if (p.enabled !== true) return DISABLED;
+	return {
+		enabled: true,
+		minBytes: typeof p.minBytes === "number" ? p.minBytes : 12_000,
+		maxBytes: typeof p.maxBytes === "number" ? p.maxBytes : 400_000,
+		tools: Array.isArray(p.tools) ? p.tools.filter((t): t is string => typeof t === "string").map((t) => t.toLowerCase()) : [],
+		toolAliases: p.toolAliases !== null && typeof p.toolAliases === "object" ? Object.fromEntries(Object.entries(p.toolAliases as Record<string, unknown>).filter((e): e is [string, string] => typeof e[1] === "string")) : {},
+	};
+}
+
+/** Whether a tool result is worth sending: policy on, eligible tool, size in the window. */
+export function shouldDigest(policy: DigestPolicy, tool: string, text: string): boolean {
+	if (!policy.enabled) return false;
+	const lower = tool.toLowerCase();
+	if (!policy.tools.includes(policy.toolAliases[lower] ?? lower)) return false;
+	const bytes = Buffer.byteLength(text);
+	return bytes >= policy.minBytes && bytes <= policy.maxBytes;
+}
+
+/** One toast line for the last routed turn of a session. */
+export function toastLine(e: { slug?: string; servedSlug?: string; tier?: string; reportedUsd?: number | null; predictedUsd?: number }): string {
+	const slug = e.servedSlug ?? e.slug ?? "?";
+	const provider = slug.startsWith("ollama/") ? "ollama" : "openrouter";
+	const usd = e.reportedUsd ?? e.predictedUsd ?? 0;
+	return `${provider} · ${slug.replace(/^ollama\//, "")} [${e.tier ?? "?"}] · $${usd.toFixed(5)}`;
+}
+
+export const AutoModelRouter: Plugin = async ({ client }) => {
+	let policy = DISABLED;
+	let policyAtMs = 0;
+	const parents = new Map<string, string | null>();
+	const lastToasted = new Map<string, string>();
+
+	async function refreshPolicy(): Promise<DigestPolicy> {
+		if (Date.now() - policyAtMs < POLICY_TTL_MS) return policy;
+		policyAtMs = Date.now();
+		try {
+			const res = await fetch(`${BASE_URL}/v1/router/digest/policy`, { signal: AbortSignal.timeout(2_000) });
+			policy = res.ok ? parsePolicy(await res.json()) : DISABLED;
+		} catch {
+			policy = DISABLED;
+		}
+		return policy;
+	}
+
+	async function parentOf(sessionID: string): Promise<string | null> {
+		const known = parents.get(sessionID);
+		if (known !== undefined) return known;
+		let parent: string | null = null;
+		try {
+			const res = await client.session.get({ path: { id: sessionID } });
+			parent = res.data?.parentID ?? null;
+		} catch {
+			parent = null;
+		}
+		parents.set(sessionID, parent);
+		return parent;
+	}
+
+	async function toast(sessionID: string): Promise<void> {
+		try {
+			const res = await fetch(`${BASE_URL}/v1/router/decisions?limit=1&session=${encodeURIComponent(sessionID)}`, { signal: AbortSignal.timeout(2_000) });
+			if (!res.ok) return;
+			const body = (await res.json()) as { entries?: { id: string; slug?: string; servedSlug?: string; tier?: string; reportedUsd?: number | null; predictedUsd?: number }[] };
+			const entry = body.entries?.[0];
+			if (entry === undefined || lastToasted.get(sessionID) === entry.id) return;
+			lastToasted.set(sessionID, entry.id);
+			await client.tui.showToast({ body: { title: "auto-model-router", message: toastLine(entry), variant: "info", duration: 4_000 } });
+		} catch {
+			// No TUI (run mode) or router down: nothing to show.
+		}
+	}
+
+	return {
+		"chat.headers": async (input, output) => {
+			if (input.model.providerID !== PROVIDER_ID) return;
+			output.headers["X-Omp-Session"] = input.sessionID;
+			output.headers["X-Omp-Harness"] = HARNESS_ID;
+			if ((await parentOf(input.sessionID)) !== null) output.headers["X-Omp-Subagent"] = "1";
+		},
+		event: async ({ event }) => {
+			if (event.type === "session.created") {
+				const info = (event as { properties: { info: { id: string; parentID?: string } } }).properties.info;
+				parents.set(info.id, info.parentID ?? null);
+			} else if (event.type === "session.idle") {
+				await toast((event as { properties: { sessionID: string } }).properties.sessionID);
+			}
+		},
+		"tool.execute.after": async (input, output) => {
+			const p = await refreshPolicy();
+			if (typeof output.output !== "string" || !shouldDigest(p, input.tool, output.output)) return;
+			try {
+				const res = await fetch(`${BASE_URL}/v1/router/digest`, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ ompSessionId: input.sessionID, harnessId: HARNESS_ID, toolName: input.tool, input: input.args ?? {}, content: output.output, query: "" }),
+					signal: AbortSignal.timeout(30_000),
+				});
+				if (!res.ok) return;
+				const r = (await res.json()) as { digested: boolean; text?: string };
+				if (r.digested && typeof r.text === "string") output.output = r.text;
+			} catch {
+				// Router unreachable or slow: the raw result stands.
+			}
+		},
+	};
+};
+
+export default AutoModelRouter;

package/opencode-plugin/opencode-plugin.d.ts

@@ -0,0 +1,39 @@
+/**
+ * LOCAL ambient stub for OpenCode's plugin API — not the vendor's types.
+ *
+ * `@opencode-ai/plugin` is resolved by OpenCode when it loads the plugin; it
+ * is not a dependency of this repo. This declares only the surface
+ * auto-model-router.ts uses, so the plugin is type-checked with the rest of
+ * the tree (tsconfig.all.json). The real types live in the package OpenCode
+ * installs under ~/.config/opencode/node_modules/@opencode-ai/plugin; treat a
+ * change here as a claim about that API that only a live session confirms.
+ */
+declare module "@opencode-ai/plugin" {
+	export interface SessionInfo {
+		id: string;
+		parentID?: string;
+	}
+	export interface OpencodeClient {
+		session: {
+			get(options: { path: { id: string } }): Promise<{ data?: SessionInfo }>;
+		};
+		tui: {
+			showToast(options: { body: { title?: string; message: string; variant: "info" | "success" | "warning" | "error"; duration?: number } }): Promise<unknown>;
+		};
+	}
+	export interface PluginInput {
+		client: OpencodeClient;
+		directory: string;
+		worktree: string;
+	}
+	export type Event =
+		| { type: "session.created"; properties: { info: SessionInfo } }
+		| { type: "session.idle"; properties: { sessionID: string } }
+		| { type: string; properties?: unknown };
+	export interface Hooks {
+		event?: (input: { event: Event }) => Promise<void>;
+		"chat.headers"?: (input: { sessionID: string; agent: string; model: { providerID?: string; id?: string } }, output: { headers: Record<string, string> }) => Promise<void>;
+		"tool.execute.after"?: (input: { tool: string; sessionID: string; callID: string; args: unknown }, output: { title: string; output: string; metadata: unknown }) => Promise<void>;
+	}
+	export type Plugin = (input: PluginInput) => Promise<Hooks>;
+}

package/package.json

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

package/src/cost/ledger.ts

@@ -376,6 +376,9 @@ 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 pruneStmt = db.query("DELETE FROM ledger WHERE created_at_ms < ?");
+	// Ollama meter samples (one per usage poll) only matter for the current
+	// billing cycle's calibration; they age out with the ledger rows.
+	const pruneMeterStmt = db.query("DELETE FROM ollama_meter_samples WHERE at_ms < ?");
 	const wasteStmt = db.query("UPDATE ledger SET wasted = 1 WHERE id = ?");
 	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 ?",
@@ -627,7 +630,9 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 		},
 		prune(retentionDays: number, nowMs = Date.now()): number {
 			if (retentionDays <= 0) return 0;
-			return pruneStmt.run(nowMs - retentionDays * DAY_MS).changes;
+			const cutoff = nowMs - retentionDays * DAY_MS;
+			pruneMeterStmt.run(cutoff);
+			return pruneStmt.run(cutoff).changes;
 		},
 		markWasted(id: string): void {
 			wasteStmt.run(id);

package/src/cost/summary.ts

@@ -28,6 +28,7 @@ export interface SummaryWindow {
 	modelSwitches: number;
 	digests: number;
 	digestSpendUsd: number;
+	digestReruns: number;
 	subagentSpendUsd: number;
 }
 
@@ -81,6 +82,7 @@ function windowOf(r: UsageReport): SummaryWindow {
 		modelSwitches: t.modelSwitches,
 		digests: t.digests,
 		digestSpendUsd: t.digestSpendUsd,
+		digestReruns: t.digestReruns,
 		subagentSpendUsd: t.subagentSpendUsd,
 	};
 }
@@ -172,7 +174,7 @@ export function renderDailySummary(s: DailySummary): string {
 			out.push(b.savedShare >= 0 ? `saved ${pct(b.savedShare)} vs ${b.slug} (${usd(b.usd)} at list)` : `cost ${pct(-b.savedShare)} MORE than ${b.slug} (${usd(b.usd)} at list)`);
 		}
 		const extras: string[] = [];
-		if (c.digests > 0) extras.push(`${c.digests} digests for ${usd(c.digestSpendUsd)}`);
+		if (c.digests > 0) extras.push(`${c.digests} digests for ${usd(c.digestSpendUsd)} (re-run rate ${pct(c.digestReruns / c.digests)})`);
 		if (c.subagentSpendUsd > 0) extras.push(`subagents ${usd(c.subagentSpendUsd)}`);
 		if (extras.length > 0) out.push(extras.join(" · "));
 	}

package/src/server/http.ts

@@ -25,8 +25,9 @@ import { openDb } from "../util/sqlite.ts";
 import { WireErrorException, renderErrorEnvelope } from "../wire/openai/errors.ts";
 import { renderModelList } from "../wire/openai/models.ts";
 import { parseChatRequest } from "../wire/openai/request.ts";
+import { createResponsesBufferedSink, createResponsesStreamingSink, parseResponsesRequest } from "../wire/openai/responses.ts";
 import { createBufferedSink, createStreamingSink } from "../wire/openai/sink.ts";
-import type { NormRequest, WireError } from "../wire/types.ts";
+import type { NormRequest, ResponseSink, WireError } from "../wire/types.ts";
 import { runTurn } from "./turn.ts";
 
 export interface StartedServer {
@@ -321,10 +322,19 @@ export function startServer(cfg: RouterConfig): StartedServer {
 		inFlightTurns--;
 	};
 
-	const handleChatCompletions = async (req: Request): Promise<Response> => {
+	/** A wire: how a request body becomes a NormRequest and how the turn is rendered back. */
+	interface Wire {
+		parse(body: unknown, headers: Headers): NormRequest;
+		streaming(model: string): { sink: ResponseSink; response: Response };
+		buffered(model: string): { sink: ResponseSink; response: Promise<Response> };
+	}
+	const CHAT_WIRE: Wire = { parse: parseChatRequest, streaming: createStreamingSink, buffered: createBufferedSink };
+	const RESPONSES_WIRE: Wire = { parse: parseResponsesRequest, streaming: createResponsesStreamingSink, buffered: createResponsesBufferedSink };
+
+	const handleTurn = async (req: Request, wire: Wire): Promise<Response> => {
 		let normReq: NormRequest;
 		try {
-			normReq = parseChatRequest(await req.json(), req.headers);
+			normReq = wire.parse(await req.json(), req.headers);
 		} catch (err) {
 			// The slot was acquired before parsing; a rejected body never reaches
 			// runTurn's `finally`, so it must be released here or every malformed
@@ -338,9 +348,7 @@ export function startServer(cfg: RouterConfig): StartedServer {
 			});
 		}
 
-		const { sink, response } = normReq.stream
-			? createStreamingSink(normReq.requestedModel)
-			: createBufferedSink(normReq.requestedModel);
+		const { sink, response } = normReq.stream ? wire.streaming(normReq.requestedModel) : wire.buffered(normReq.requestedModel);
 
 		// The client signal aborts the upstream dispatch on disconnect. runTurn is
 		// expected to render its own failures into the sink; this catch is the last
@@ -399,7 +407,14 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					if (!acquireTurn()) {
 						return wireErrorResponse({ status: 429, code: "too_many_requests", message: "too many concurrent turns" });
 					}
-					return await handleChatCompletions(req);
+					return await handleTurn(req, CHAT_WIRE);
+				}
+				if (req.method === "POST" && url.pathname === "/v1/responses") {
+					// The Responses API wire (Codex CLI). Same turn, different rendering.
+					if (!acquireTurn()) {
+						return wireErrorResponse({ status: 429, code: "too_many_requests", message: "too many concurrent turns" });
+					}
+					return await handleTurn(req, RESPONSES_WIRE);
 				}
 				if (req.method === "GET" && url.pathname === "/v1/models") {
 					return json(renderModelList(cfg, ledger.blendedRate(cfg.ledger.blendWindowDays)));

package/src/util/sse.ts

@@ -4,7 +4,7 @@
  * frame is emitted per token on the hot path.
  */
 
-const encoder = new TextEncoder();
+export const encoder = new TextEncoder();
 
 /** One `data:` frame carrying a JSON payload, terminated by a blank line. */
 export function sseDataFrame(value: unknown): string {