auto-model-router 0.14.0 → 0.15.0

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

package/README.md

@@ -710,8 +710,12 @@ escalation signal, error. Three views aggregate it, all from the same
   and model (dispatches, tokens, spend, escalations, errors) as CSV. Also
   `GET /v1/router/export?days=&harness=[&format=json]`; `GET /v1/router/spend?sinceMs=&harness=`
   gives spend over a harness set since an instant, and `GET /v1/router/feedback?days=&harness=`
-  lists verdicts by model and the recent ones with the harness that gave them. These are what
-  a front door such as the team edition reads instead of the ledger file.
+  lists verdicts by model and the recent ones with the harness that gave them, and
+  `GET /v1/router/decisions?harness=&days=|since=&slug=&tier=&limit=` is the decision trail
+  itself, newest first, each turn with its reasons, the classifier's view, forecast against
+  bill, escalation signal and verdicts (`?session=` narrows to one omp session, as `/router
+  why` does). These are what a front door such as the team edition reads instead of the
+  ledger file.
 - `GET /v1/router/report?days=7&harness=<id>` for dashboards (`harness` may be
   a comma-separated set of ids, for a group).
 - `GET /v1/router/summary?harness=<id>` — the daily summary as JSON (`auto=1`

package/package.json

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

package/src/cost/ledger.ts

@@ -65,7 +65,7 @@ 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.
-interface LedgerRow {
+export interface LedgerRow {
 	id: string;
 	created_at_ms: number;
 	conversation_key: string;
@@ -240,7 +240,7 @@ function toLatency(slug: string, row: LatencyRow): ModelLatency | null {
 	return { slug, samples: row.samples, ttftMs: row.ttft_ms, tokensPerSec };
 }
 
-function toEntry(row: LedgerRow): LedgerEntry {
+export function toEntry(row: LedgerRow): LedgerEntry {
 	return {
 		id: row.id,
 		createdAtMs: row.created_at_ms,

package/src/cost/views.ts

@@ -10,7 +10,9 @@
 
 import { providerOfSlug } from "./report.ts";
 import type { Database } from "bun:sqlite";
+import { toEntry, type LedgerRow } from "./ledger.ts";
 import { harnessFilter } from "./report.ts";
+import type { LedgerEntry } from "./types.ts";
 
 /** `null` means every harness; an empty set matches nothing. */
 export type HarnessScope = readonly string[] | null;
@@ -61,6 +63,68 @@ function scope(harness: HarnessScope, column: string): { sql: string[]; bind: Re
 	return { sql: f.sql.map((s) => s.replace(/^harness_id/, column)), bind: f.bind };
 }
 
+/** A ledger entry as the decision explorer shows it: the entry itself plus the verdicts given on it. */
+export type DecisionEntry = LedgerEntry & { feedback: { verdict: "good" | "bad"; note: string; createdAtMs: number }[] };
+
+export interface DecisionFilter {
+	/** Entries at or after this instant; 0 for everything the ledger still holds. */
+	sinceMs: number;
+	/** The harness set; null for every harness, an empty list for none. */
+	harness: HarnessScope;
+	/** At most this many, newest first; 1..1000. */
+	limit?: number;
+	/** Only turns dispatched to (or served by) this slug. */
+	slug?: string;
+	/** Only turns classified at this tier. */
+	tier?: string;
+	/** Only one omp session (`/router why`). */
+	ompSessionId?: string;
+}
+
+/**
+ * Turns, newest first, over a harness set: what `GET /v1/router/decisions` serves and what a
+ * front door reads from the ledger file. Every field the decision trail needs is here — the
+ * reasons, the classifier's view, the cost forecast against the bill, the escalation signal —
+ * and the verdicts `/router good|bad` recorded against each turn ride along.
+ */
+export function decisionEntries(db: Database, filter: DecisionFilter): DecisionEntry[] {
+	const s = scope(filter.harness, "harness_id");
+	if (s === null) return [];
+	const where = ["created_at_ms >= $since", ...s.sql];
+	const bind: Record<string, string | number> = { $since: filter.sinceMs, ...s.bind };
+	if (filter.slug !== undefined && filter.slug !== "") {
+		where.push("(slug = $slug OR served_slug = $slug)");
+		bind.$slug = filter.slug;
+	}
+	if (filter.tier !== undefined && filter.tier !== "") {
+		where.push("tier = $tier");
+		bind.$tier = filter.tier;
+	}
+	if (filter.ompSessionId !== undefined && filter.ompSessionId !== "") {
+		where.push("omp_session_id = $session");
+		bind.$session = filter.ompSessionId;
+	}
+	const limit = Math.min(Math.max(filter.limit ?? 50, 1), 1_000);
+	const rows = db.query(`SELECT * FROM ledger WHERE ${where.join(" AND ")} ORDER BY created_at_ms DESC LIMIT ${limit}`).all(bind) as LedgerRow[];
+	const entries = rows.map(toEntry);
+	if (entries.length === 0) return [];
+	// Verdicts, when the feedback table exists (it does not on a ledger no one has judged).
+	const hasFeedback = (db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'feedback'").get() as { name: string } | null) !== null;
+	const verdicts = new Map<string, DecisionEntry["feedback"]>();
+	if (hasFeedback) {
+		const ids = entries.map((e) => e.id);
+		const marks = ids.map((_, i) => `$f${i}`).join(", ");
+		const fb: Record<string, string> = {};
+		ids.forEach((id, i) => (fb[`$f${i}`] = id));
+		for (const r of db.query(`SELECT ledger_id, verdict, note, created_at_ms FROM feedback WHERE ledger_id IN (${marks}) ORDER BY created_at_ms ASC`).all(fb) as { ledger_id: string; verdict: string; note: string; created_at_ms: number }[]) {
+			const list = verdicts.get(r.ledger_id) ?? [];
+			list.push({ verdict: r.verdict === "good" ? "good" : "bad", note: r.note, createdAtMs: r.created_at_ms });
+			verdicts.set(r.ledger_id, list);
+		}
+	}
+	return entries.map((e) => ({ ...e, feedback: verdicts.get(e.id) ?? [] }));
+}
+
 /** Spend (reported where present, predicted otherwise) since `sinceMs`, digest calls included as the ledger counts them. */
 export function spendUsdSince(db: Database, sinceMs: number, harness: HarnessScope): number {
 	const s = scope(harness, "harness_id");

package/src/lib.ts

@@ -22,7 +22,7 @@ export type { DeepPartial } from "./config/load.ts";
 export { buildUsageReport, renderUsageReport, type UsageReport, type ReportTotals } from "./cost/report.ts";
 export { buildDailySummary, renderDailySummary, type DailySummary } from "./cost/summary.ts";
 export { openDb } from "./util/sqlite.ts";
-export { spendUsdSince, feedbackView, exportRows, exportCsv, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView } from "./cost/views.ts";
+export { spendUsdSince, feedbackView, exportRows, exportCsv, decisionEntries, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView, type DecisionEntry, type DecisionFilter } from "./cost/views.ts";
 export { createLedger } from "./cost/ledger.ts";
 export { createFeedbackStore, type FeedbackStore, type FeedbackRecord } from "./cost/feedback.ts";
 export { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget, EXECUTABLE_TARGETS, type ExecutableTarget, type BuildExecutableResult } from "./cli/build-executable.ts";

package/src/server/http.ts

@@ -10,7 +10,7 @@ import { createDigester } from "./digest.ts";
 import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport, renderUsageReport } from "../cost/report.ts";
-import { exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../cost/views.ts";
+import { decisionEntries, exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../cost/views.ts";
 import { anthropicErrorResponse, countAnthropicTokens, createMessagesWire } from "../wire/anthropic/messages.ts";
 import { buildDailySummary, createKv, markSummaryShown, renderDailySummary, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
@@ -555,13 +555,24 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					return json({ due: true, summary });
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/decisions") {
+					// The decision trail, newest first. ?session=<omp session id> narrows to one
+					// session (/router why); ?harness=a,b to a harness set (a team's user or group),
+					// ?since=<ms> or ?days=N to a window, ?slug= and ?tier= to a model or a tier.
 					const rawLimit = url.searchParams.get("limit");
 					const parsed = rawLimit === null ? 50 : Number.parseInt(rawLimit, 10);
 					const limit = Number.isInteger(parsed) ? Math.min(Math.max(parsed, 1), 1_000) : 50;
-					// ?session=<omp session id> narrows to one session (/router why).
-					const session = url.searchParams.get("session") ?? "";
-					const entries = session === "" ? ledger.recentEntries(limit) : (ledger.entriesForSession?.(session, limit) ?? []);
-					return json({ entries: entries.map((e) => ({ ...e, feedback: feedback.forLedgerId(e.id) })) });
+					const sinceRaw = Number.parseInt(url.searchParams.get("since") ?? "", 10);
+					const daysRaw = url.searchParams.get("days");
+					const sinceMs = Number.isFinite(sinceRaw) ? sinceRaw : daysRaw === null ? 0 : Date.now() - clampDays(daysRaw, 30) * 86_400_000;
+					const entries = decisionEntries(db, {
+						sinceMs,
+						harness: harnessScopeParam(url.searchParams.get("harness")),
+						limit,
+						slug: url.searchParams.get("slug") ?? "",
+						tier: url.searchParams.get("tier") ?? "",
+						ompSessionId: url.searchParams.get("session") ?? "",
+					});
+					return json({ entries });
 				}
 				if (url.pathname === "/v1/router/override") {
 					// Per-session pin / tier overrides from omp. GET shows, POST sets or clears.

package/test/views.test.ts

@@ -148,6 +148,12 @@ describe("view routes", () => {
 		expect((await fetch(`http://127.0.0.1:${handle.server.port}/v1/router/spend?sinceMs=0`)).status).toBe(401);
 		expect((await get("/v1/router/spend")).status).toBe(400);
 		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&harness=u_x`)).json()) as { usd: number }).usd).toBeCloseTo(0.25, 6);
+		// The decision trail over a harness set: a team asks with its user or group ids and sees only theirs.
+		const mine = (await (await get("/v1/router/decisions?harness=u_x&days=1")).json()) as { entries: { id: string; feedback: unknown[] }[] };
+		expect(mine.entries.map((e) => e.id)).toEqual(["r1"]);
+		expect(mine.entries[0]?.feedback).toEqual([]);
+		expect((((await (await get("/v1/router/decisions?harness=u_other&days=1")).json()) as { entries: unknown[] }).entries)).toEqual([]);
+		expect((((await (await get("/v1/router/decisions?limit=1")).json()) as { entries: { id: string }[] }).entries.map((e) => e.id))).toEqual(["r1"]); // no filter: everything, as before
 		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&harness=u_other`)).json()) as { usd: number }).usd).toBe(0);
 		const fb = (await (await get("/v1/router/feedback?days=7")).json()) as { days: number; byModel: unknown[]; recent: unknown[] };
 		expect(fb).toEqual({ days: 7, byModel: [], recent: [] });
@@ -159,3 +165,28 @@ describe("view routes", () => {
 		expect(js.rows[0]?.harnessId).toBe("u_x");
 	});
 });
+
+describe("decision entries", () => {
+	const db = seeded();
+	const since = NOW - DAY;
+
+	test("newest first over a harness set, with the verdicts given on each turn", () => {
+		const { decisionEntries } = require("../src/cost/views.ts") as typeof import("../src/cost/views.ts");
+		const ada = decisionEntries(db, { sinceMs: since, harness: ["u_ada"] });
+		expect(ada.map((e) => e.id)).toEqual(["l1", "l2"]); // same instant in the fixture; insertion order within it is stable
+		expect(ada.find((e) => e.id === "l1")?.feedback).toEqual([{ verdict: "good", note: "", createdAtMs: NOW - 1000 }]);
+		expect(ada.find((e) => e.id === "l2")?.escalationSignal).toBe("circular");
+		// Everyone, within the window: the 40-day-old row stays out; the digest row is a turn like any other.
+		expect(decisionEntries(db, { sinceMs: since, harness: null }).map((e) => e.id).sort()).toEqual(["l1", "l2", "l3", "l4"]);
+		expect(decisionEntries(db, { sinceMs: 0, harness: null }).length).toBe(5);
+		// A model, a tier, nobody, and a cap.
+		expect(decisionEntries(db, { sinceMs: since, harness: null, slug: "ollama/glm-5.3-flash" }).map((e) => e.id).sort()).toEqual(["l3", "l4"]);
+		expect(decisionEntries(db, { sinceMs: since, harness: null, tier: "hard" })).toEqual([]);
+		expect(decisionEntries(db, { sinceMs: since, harness: [] })).toEqual([]);
+		expect(decisionEntries(db, { sinceMs: since, harness: null, limit: 1 }).length).toBe(1);
+		// The error on l3 and its note ride along, so an explorer can show why a turn went wrong.
+		const bob = decisionEntries(db, { sinceMs: since, harness: ["u_bob"], slug: "ollama/glm-5.3-flash" });
+		expect(bob.find((e) => e.id === "l3")?.error).toBe("boom");
+		expect(bob.find((e) => e.id === "l3")?.feedback[0]?.note).toBe("looped");
+	});
+});