auto-model-router 0.17.0 → 0.19.0

package/.claude/skills/agentdox/SKILL.md

@@ -5,7 +5,7 @@ description: "Use agentdox — the shared memory, docs, and context server — t
 
 # agentdox — the standard interaction protocol
 
-agentdox is a shared memory + docs + conversation store at `http://localhost:3003`. It is what
+agentdox is a shared memory + docs + conversation store at `http://localhost:8790/agentdox`. It is what
 stops you rediscovering the same project facts every session.
 
 **Follow this protocol identically every time.** Consistency is the point: the value of the
@@ -55,7 +55,7 @@ Deterministic, so the same folder always resolves to the same slug:
    repo root:
 
    ```ini
-   AGENTDOX_URL=http://localhost:3003
+   AGENTDOX_URL=http://localhost:8790/agentdox
    AGENTDOX_SCOPE=<slug>
    AGENTDOX_TOKEN=<the global PAT>
    ```
@@ -104,6 +104,16 @@ determine the scope, ask — do not guess, and do not fall back to a default.
 
 ## 1. Pick your transport — MCP or REST
 
+> **Where the store lives (since 2026-09-10).** The store is the team edition's embedded agentdox,
+> reached through the team: REST at `http://localhost:8790/agentdox/...` and MCP at
+> `http://localhost:8790/mcp`, with a **team member key** (`amrt_…`) as `AGENTDOX_TOKEN`. The team maps
+> the key to the member's grants (write on every project of their groups, read on the group's
+> context), so a 401 means the key and a 403 means the project belongs to another group — not a PAT.
+> agentdox's own `/auth` routes are not reachable through the team; projects are created on the
+> team's Groups page or appear on a workspace's first turn. The old dev container on :3003 is retired.
+> A member key updates entries (`PATCH /memory/:id`) but cannot delete them (agentdox wants admin on the
+> scope for that): to retire a fact, lower its importance or leave it to the team's retention pass.
+
 Both hit the same live store with the same RBAC. **Check which you have, then use it:**
 
 - **MCP tools present** — use them. Claude Code and Cursor mount them as `memory_add`,
@@ -129,7 +139,7 @@ inline JSON and avoids quoting pain in `curl`:
 ```ts
 const tok = /AGENTDOX_TOKEN=(.+)/.exec(await Bun.file(".env.agentdox").text())?.[1]?.trim() ?? "";
 const H = { Authorization: `Bearer ${tok}`, "content-type": "application/json" };
-await fetch("http://localhost:3003/memory", { method: "POST", headers: H,
+await fetch("http://localhost:8790/agentdox/memory", { method: "POST", headers: H,
   body: JSON.stringify({ content: "…", category: "<scope>", importance: 0.9 }) });
 ```
 

package/.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "agentdox": {
       "type": "http",
-      "url": "http://localhost:3003/mcp",
+      "url": "http://localhost:8790/mcp",
       "headers": {
         "Authorization": "Bearer ${AGENTDOX_TOKEN}"
       }

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

package/CLAUDE.md

@@ -24,7 +24,7 @@ tips). Read it before using agentdox; do not improvise from this summary.
 | --- | --- |
 | Token, URL, scope | `.env.agentdox` in this repo root (gitignored — never commit) |
 | What `.mcp.json` reads | the `AGENTDOX_TOKEN` **environment variable** (Windows *User* scope; shells opened before it was set lack it) |
-| Server | `http://localhost:3003` — Docker container `agentdox-server`; endpoints in `E:/projects/agentdox/packages/server/src/index.ts` |
+| Server | `http://localhost:8790/agentdox` — the team edition's embedded agentdox (the `agentdox-server` container is retired); endpoints in `E:/projects/agentdox/packages/server/src/index.ts` |
 | Admin token (re-mint) | `E:/projects/agentdox/deploy/.env` |
 
 Two rules that cause silent mistakes: **memory calls take `category`, everything else takes
@@ -46,7 +46,7 @@ behind them are recorded there as they are made.
 Turning the bridge on for the router itself (distinct from the MCP wiring above):
 
 ```bash
-export AGENTDOX_URL=http://localhost:3003
+export AGENTDOX_URL=http://localhost:8790/agentdox
 export AGENTDOX_TOKEN=<the global PAT, same value .mcp.json uses>
 export AGENTDOX_SCOPE=omp-router
 ```

package/README.md

@@ -694,7 +694,9 @@ virtual profile it picked. Every routed response carries
 
 The ledger records every dispatch: model decided and served, tier, provider,
 tokens (including cached), reported cost, time to first token, total latency,
-escalation signal, error. Three views aggregate it, all from the same
+escalation signal, error, and the agentdox context scope the turn carried (the
+project it belongs to; NULL for a turn that carried none, and for every row
+written before v0.19.0). Three views aggregate it, all from the same
 `buildUsageReport` in `src/cost/report.ts`:
 
 - `/router report` in omp — a fullscreen hub with the `/models` look: views
@@ -706,16 +708,28 @@ escalation signal, error. Three views aggregate it, all from the same
   transcript. Falls back to reading the ledger directly if the router is
   unreachable.
 - `auto-model-router report --days 7 [--harness <id>] [--json]` on the terminal.
-- `auto-model-router export --days 30 [--harness a,b] [--json]`: one row per day, harness
-  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=`
+- `auto-model-router export --days 30 [--harness a,b] [--json]`: one row per day, harness,
+  model and context scope (dispatches, tokens, spend, escalations, errors) as CSV — the
+  `scope` column is last, and is empty for a turn that carried none. Also
+  `GET /v1/router/export?days=&harness=[&format=json]`; `GET /v1/router/spend?sinceMs=&harness=[&scope=]`
+  gives spend over a harness set since an instant, narrowed to one context scope when `scope`
+  is given (a project's own bill), and `GET /v1/router/feedback?days=&harness=`
   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/catalog[?policy=<X-Omp-Policy JSON>]` — the model catalog as data: every
+  model the router knows, sorted by slug, with provider (`openrouter`, `ollama`, a named
+  upstream's id), vendor, context, capabilities, prices in USD per million tokens and quality
+  scores; a model whose upstream cannot serve right now (no key, disabled, in cooldown) is
+  listed too. With `policy` every model also carries `admitted` and, when out, `reason`
+  (`not in the allow list`, `denied by <glob>`, `pinned to <slug>`, the router's own filters,
+  or the upstream's state), judged by the same matcher a turn uses, so the view never drifts
+  from what a turn gets; tiers are per turn and do not take part. A malformed policy is a
+  400; before the first fetch it answers `{ "fetchedAtMs": 0, "models": [] }` rather than
+  waiting. A team front door reads it for its model governance views.
 - `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`
@@ -1287,7 +1301,8 @@ request allow list replaces the configured one, a deny list adds to it.
 widen it. `pin` forces one model the way `/router pin` does, unless a session
 override already pinned one. Every field is optional; a malformed header is
 ignored rather than failing the turn. The decision trail records what the
-policy changed (`policy: …`).
+policy changed (`policy: …`), and `GET /v1/router/catalog?policy=…` shows what a
+policy admits, model by model, without routing a turn.
 
 ## Using a remote router
 
@@ -1544,6 +1559,20 @@ a team posts exactly what it always did, so its block is byte-identical; an olde
 agentdox ignores the keys it does not know. `context.layers: false` is the kill
 switch — the headers are still parsed but nothing new goes to agentdox.
 
+### Charging spend back to a project
+
+Every ledger row records the scope the bridge resolved for that turn — the
+request's `X-Agentdox-Scope`, or `context.defaultScope` behind it — so the money
+and the project are the same row. That is what a front door bills from: it names
+a project's scope on the turns it forwards, then reads its share back with
+`GET /v1/router/spend?sinceMs=&scope=<scope>` (composable with `harness=`, so one
+member's spend on one project is one call), or takes the whole split from
+`GET /v1/router/export`, whose rows now group by day, harness, model **and**
+scope and carry the scope as their last CSV column. `decisionEntries` (and
+`GET /v1/router/decisions`) carry it on each turn too. Rows written before
+v0.19.0, and turns that carried no scope at all, store NULL and export as `""` —
+old ledgers open and gain the column, they just have nothing to charge.
+
 ### The origin fingerprint
 
 The scope is the folder's name, and folder names collide: two unrelated repositories

package/package.json

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

package/src/catalog/composite.ts

@@ -46,7 +46,7 @@ export function createCompositeCatalog(
 	ollama: OllamaCatalogSource,
 	availability: OllamaAvailability,
 	bias: CompositeBias = { costBias: 1, biasUntilUsage: 1, usage: NO_USAGE },
-): CatalogSource & { ollamaModels(): CatalogModel[]; ollamaBias(): number } {
+): CatalogSource & { ollamaModels(): CatalogModel[]; ollamaBias(): number; peekAll(): CatalogSnapshot | null } {
 	let lastBase: CatalogSnapshot | null = null;
 	let lastOllama: readonly CatalogModel[] = [];
 	let lastAvailable = true;
@@ -118,6 +118,17 @@ export function createCompositeCatalog(
 			return combine(base, ollama.peek());
 		},
 		find,
+		/**
+		 * Every model the catalog knows, whether or not its upstream can take a
+		 * turn now: OpenRouter's without a key, Ollama's in cooldown, a named
+		 * upstream's in cooldown. `peek()` is what routes; this is what a front
+		 * door lists so it can say why a model is out. No network.
+		 */
+		peekAll(): CatalogSnapshot | null {
+			const base = openrouter.peek();
+			if (base === null) return null;
+			return { ...base, models: [...base.models, ...ollama.peek(), ...(bias.named?.models(base.models) ?? NO_NAMED)] };
+		},
 		lastShrink(): CatalogShrink | null {
 			return openrouter.lastShrink?.() ?? null;
 		},

package/src/cost/ledger.ts

@@ -99,6 +99,7 @@ export interface LedgerRow {
 	upstream_generation_id: string | null;
 	error: string | null;
 	prompt_tokens_saved: number | null;
+	scope: string | null;
 }
 
 interface TrustRow {
@@ -274,6 +275,9 @@ export function toEntry(row: LedgerRow): LedgerEntry {
 		upstreamGenerationId: row.upstream_generation_id,
 		error: row.error,
 		promptTokensSaved: row.prompt_tokens_saved ?? 0,
+		// Optional under exactOptionalPropertyTypes: an old row (or a scopeless
+		// turn) simply has no `scope`, rather than an explicit undefined.
+		...(row.scope === null || row.scope === undefined ? {} : { scope: row.scope }),
 	};
 }
 
@@ -319,8 +323,8 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 			id, created_at_ms, conversation_key, session_id, turn, requested_model, harness_id, omp_session_id, slug, served_slug,
 			tier, classification_source, reasons, predicted_usd, reported_usd, usage, cost_breakdown,
 			attempt, escalation_signal, latency_ms, ttft_ms, finish_reason, wasted, upstream_generation_id, error,
-			error_kind, features, score, confidence, task, classifier_reasons, explored_from, hold_arm, prompt_tokens_saved
-		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			error_kind, features, score, confidence, task, classifier_reasons, explored_from, hold_arm, prompt_tokens_saved, scope
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 	);
 	const calibrationStmt = db.query(
 		`INSERT INTO token_calibration (tokenizer, est_bytes, actual_tokens, samples) VALUES (?, ?, ?, 1)
@@ -473,6 +477,9 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 				entry.exploredFrom,
 				entry.holdArm,
 				entry.promptTokensSaved,
+				// A turn that carried no scope stores NULL, exactly as every row
+				// written before v18 did; "" and absent are the same fact.
+				entry.scope === undefined || entry.scope === "" ? null : entry.scope,
 			);
 			// Always consume the pending estimate, even when the turn failed, so a
 			// dead turn's bytes can never pair with a later turn's tokens. Only

package/src/cost/types.ts

@@ -146,6 +146,13 @@ export interface LedgerEntry {
 	error: string | null;
 	/** Prompt tokens removed by compaction before dispatch. 0 when none. NULL before v12. */
 	promptTokensSaved: number;
+	/**
+	 * The agentdox context scope this turn carried — what the bridge resolved
+	 * for it (the request's `X-Agentdox-Scope`, or `context.defaultScope`).
+	 * Absent, or empty, when the turn carried none, and stored as NULL; a front
+	 * door charges the row's spend back to that project with it. NULL before v18.
+	 */
+	scope?: string;
 	/**
 	 * The catalog model that served, for the cost split. The ledger can price
 	 * OpenRouter slugs from its own cached catalog payload; a model from another

package/src/cost/views.ts

@@ -44,6 +44,8 @@ export interface ExportRow {
 	day: string;
 	harnessId: string;
 	slug: string;
+	/** The agentdox context scope the turns carried; "" for rows that carried none (every row before v18). */
+	scope: string;
 	provider: string;
 	dispatches: number;
 	promptTokens: number;
@@ -125,12 +127,21 @@ export function decisionEntries(db: Database, filter: DecisionFilter): DecisionE
 	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 {
+/**
+ * Spend (reported where present, predicted otherwise) since `sinceMs`, digest calls included
+ * as the ledger counts them. `contextScope`, when given, narrows to the turns that carried
+ * exactly that agentdox scope — what a front door charges back to one project.
+ */
+export function spendUsdSince(db: Database, sinceMs: number, harness: HarnessScope, contextScope?: string): number {
 	const s = scope(harness, "harness_id");
 	if (s === null) return 0;
-	const where = ["created_at_ms >= $since", ...s.sql].join(" AND ");
-	const row = db.query(`SELECT COALESCE(SUM(${USD}), 0) AS usd FROM ledger WHERE ${where}`).get({ $since: sinceMs, ...s.bind }) as { usd: number };
+	const where = ["created_at_ms >= $since", ...s.sql];
+	const bind: Record<string, string | number> = { $since: sinceMs, ...s.bind };
+	if (contextScope !== undefined && contextScope !== "") {
+		where.push("scope = $scope");
+		bind.$scope = contextScope;
+	}
+	const row = db.query(`SELECT COALESCE(SUM(${USD}), 0) AS usd FROM ledger WHERE ${where.join(" AND ")}`).get(bind) as { usd: number };
 	return row.usd;
 }
 
@@ -163,14 +174,19 @@ export function feedbackView(db: Database, sinceMs: number, harness: HarnessScop
 	return { byModel, recent };
 }
 
-/** One row per UTC day, harness and served model since `sinceMs`; digest calls are excluded as in the report. */
+/**
+ * One row per UTC day, harness, served model and context scope since `sinceMs`; digest calls
+ * are excluded as in the report. The scope splits a harness's day by project, so a front door
+ * can charge each project its own share; rows from before v18 (and turns that carried no
+ * scope) group under "".
+ */
 export function exportRows(db: Database, sinceMs: number, harness: HarnessScope): ExportRow[] {
 	const s = scope(harness, "harness_id");
 	if (s === null) return [];
 	const where = ["created_at_ms >= $since", "requested_model <> 'digest'", ...s.sql].join(" AND ");
 	const rows = db
 		.query(
-			`SELECT strftime('%Y-%m-%d', created_at_ms / 1000, 'unixepoch') AS day, harness_id, COALESCE(served_slug, slug) AS slug,
+			`SELECT strftime('%Y-%m-%d', created_at_ms / 1000, 'unixepoch') AS day, harness_id, COALESCE(served_slug, slug) AS slug, COALESCE(scope, '') AS scope,
 				COUNT(*) AS dispatches,
 				COALESCE(SUM(json_extract(usage, '$.promptTokens')), 0) AS prompt_tokens,
 				COALESCE(SUM(json_extract(usage, '$.cachedTokens')), 0) AS cached_tokens,
@@ -178,13 +194,14 @@ export function exportRows(db: Database, sinceMs: number, harness: HarnessScope)
 				COALESCE(SUM(${USD}), 0) AS spend,
 				SUM(CASE WHEN escalation_signal IS NOT NULL THEN 1 ELSE 0 END) AS escalations,
 				SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) AS errors
-			 FROM ledger WHERE ${where} GROUP BY day, harness_id, slug ORDER BY day ASC, harness_id ASC, spend DESC`,
+			 FROM ledger WHERE ${where} GROUP BY day, harness_id, slug, scope ORDER BY day ASC, harness_id ASC, spend DESC`,
 		)
-		.all({ $since: sinceMs, ...s.bind }) as { day: string; harness_id: string; slug: string; dispatches: number; prompt_tokens: number; cached_tokens: number; completion_tokens: number; spend: number; escalations: number; errors: number }[];
+		.all({ $since: sinceMs, ...s.bind }) as { day: string; harness_id: string; slug: string; scope: string; dispatches: number; prompt_tokens: number; cached_tokens: number; completion_tokens: number; spend: number; escalations: number; errors: number }[];
 	return rows.map((r) => ({
 		day: r.day,
 		harnessId: r.harness_id,
 		slug: r.slug,
+		scope: r.scope,
 		provider: providerOfSlug(r.slug),
 		dispatches: r.dispatches,
 		promptTokens: r.prompt_tokens,
@@ -196,7 +213,7 @@ export function exportRows(db: Database, sinceMs: number, harness: HarnessScope)
 	}));
 }
 
-export const EXPORT_COLUMNS = ["day", "harness", "model", "provider", "dispatches", "prompt_tokens", "cached_tokens", "completion_tokens", "spend_usd", "escalations", "errors"] as const;
+export const EXPORT_COLUMNS = ["day", "harness", "model", "provider", "dispatches", "prompt_tokens", "cached_tokens", "completion_tokens", "spend_usd", "escalations", "errors", "scope"] as const;
 
 export function csvCell(v: string | number): string {
 	const s = String(v);
@@ -206,7 +223,7 @@ export function csvCell(v: string | number): string {
 /** CSV of export rows; spend to 6 decimals so sub-cent rows survive. */
 export function exportCsv(rows: readonly ExportRow[]): string {
 	const lines = [EXPORT_COLUMNS.join(",")];
-	for (const r of rows) lines.push([r.day, r.harnessId, r.slug, r.provider, r.dispatches, r.promptTokens, r.cachedTokens, r.completionTokens, r.spendUsd.toFixed(6), r.escalations, r.errors].map(csvCell).join(","));
+	for (const r of rows) lines.push([r.day, r.harnessId, r.slug, r.provider, r.dispatches, r.promptTokens, r.cachedTokens, r.completionTokens, r.spendUsd.toFixed(6), r.escalations, r.errors, r.scope].map(csvCell).join(","));
 	return `${lines.join("\n")}\n`;
 }
 

package/src/lib.ts

@@ -28,4 +28,5 @@ export { createFeedbackStore, type FeedbackStore, type FeedbackRecord } from "./
 export { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget, EXECUTABLE_TARGETS, type ExecutableTarget, type BuildExecutableResult } from "./cli/build-executable.ts";
 export { parseSkillsBundle, type SkillsBundle } from "./cli/skills.ts";
 export type { RequestPolicy } from "./wire/types.ts";
+export type { CatalogView, CatalogViewModel } from "./server/catalog-view.ts";
 export type { Ledger, LedgerEntry } from "./cost/types.ts";

package/src/router/candidates.ts

@@ -48,12 +48,37 @@ export interface BuildCandidatesArgs {
 	excludeSlugs?: readonly string[];
 }
 
-/** Tiny glob: `*` matches any run of characters; everything else is literal. */
-function globToRe(glob: string): RegExp {
+/**
+ * Tiny glob: `*` matches any run of characters; everything else is literal.
+ * The one matcher behind `filters.allow`/`filters.deny` and a request
+ * policy's lists; the catalog view (`GET /v1/router/catalog`) judges with it
+ * too, so what a front door shows never drifts from what a turn gets.
+ */
+export function globToRe(glob: string): RegExp {
 	const escaped = glob.replace(/[.*+?^${}()|[\]\\]/g, (ch) => (ch === "*" ? ".*" : `\\${ch}`));
 	return new RegExp(`^${escaped}$`);
 }
 
+/**
+ * The denials that precede any user configuration, as the reason text, or
+ * null when the model may be a candidate. These slugs can never serve an
+ * interactive turn:
+ *  - "~vendor/model-latest": floating aliases whose identity changes
+ *    underneath us, poisoning ledger trust statistics.
+ *  - ":batch": asynchronous batch endpoints, unusable for streaming.
+ *  - "stealth/": cloaked models with no stable identity.
+ *  - "openrouter/": their meta-routers do our job at unknown cost.
+ *  - a negative price: OpenRouter's unknown/dynamic sentinel (-1), never a discount.
+ */
+export function builtInDenial(model: CatalogModel): string | null {
+	const slug = model.slug;
+	if (slug.startsWith("~") || slug.endsWith(":batch") || slug.startsWith("stealth/") || model.author === "openrouter") {
+		return "built-in deny: floating alias, batch endpoint, stealth, or meta-router";
+	}
+	if (model.price.prompt < 0 || model.price.completion < 0) return "dynamic pricing sentinel";
+	return null;
+}
+
 /**
  * Quality fallback chain: score the preferred axis first, then the general
  * intelligence index (the most widely published), then the remaining axis.
@@ -182,20 +207,10 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 			continue;
 		}
 
-		// Hard-coded denials, before any user configuration. These slugs can
-		// never serve an interactive turn:
-		//  - "~vendor/model-latest": floating aliases whose identity changes
-		//    underneath us, poisoning ledger trust statistics.
-		//  - ":batch": asynchronous batch endpoints, unusable for streaming.
-		//  - "stealth/": cloaked models with no stable identity.
-		//  - "openrouter/": their meta-routers do our job at unknown cost.
-		if (slug.startsWith("~") || slug.endsWith(":batch") || slug.startsWith("stealth/") || model.author === "openrouter") {
-			rejected.push({ slug, reason: "denylisted", detail: "built-in deny: floating alias, batch endpoint, stealth, or meta-router" });
-			continue;
-		}
-		// A negative price is OpenRouter's unknown/dynamic sentinel (-1), never a discount.
-		if (model.price.prompt < 0 || model.price.completion < 0) {
-			rejected.push({ slug, reason: "denylisted", detail: "dynamic pricing sentinel" });
+		// Hard-coded denials, before any user configuration.
+		const builtIn = builtInDenial(model);
+		if (builtIn !== null) {
+			rejected.push({ slug, reason: "denylisted", detail: builtIn });
 			continue;
 		}
 		if (allowRes.length > 0 && !allowRes.some((re) => re.test(slug))) {

package/src/server/catalog-view.ts

@@ -0,0 +1,130 @@
+/**
+ * The router's model catalog as data, with a policy's verdict per model: what
+ * `GET /v1/router/catalog` answers. A team front door renders it for its
+ * governance views ("which models can this group reach, and why not the
+ * rest"), so admission is decided by the SAME matcher and in the SAME order
+ * as `buildCandidates` — the built-in denials, then allow, deny, free and
+ * tool support — over the filters `applyRequestPolicy` produced, and a pin
+ * takes effect only when the pinned model itself survives them, exactly as
+ * `select` treats a forced slug. Tiers are per turn and take no part.
+ */
+
+import type { CatalogModel, Modality, QualityScores } from "../catalog/types.ts";
+import type { FilterConfig } from "../config/types.ts";
+import { builtInDenial, globToRe } from "../router/candidates.ts";
+
+export interface CatalogViewModel {
+	slug: string;
+	canonicalSlug: string;
+	name: string;
+	/** The upstream that serves it: `openrouter`, `ollama`, or a named upstream's id. */
+	provider: string;
+	/**
+	 * The slug's namespace before the first `/` (`anthropic`). For a named
+	 * upstream's `<id>/<model>` the vendor is the model id's own namespace when
+	 * it carries one (`vllm/meta-llama/x` ⇒ `meta-llama`), else the upstream id.
+	 */
+	vendor: string;
+	contextLength: number;
+	maxCompletionTokens?: number;
+	supportsTools: boolean;
+	supportsReasoning: boolean;
+	reasoningMandatory: boolean;
+	inputModalities: Modality[];
+	/** USD per MILLION tokens, the catalog's own units. */
+	price: { prompt: number; completion: number; cacheRead?: number; cacheWrite?: number };
+	quality: QualityScores;
+	isFree: boolean;
+	/** Present only when a policy was asked about. */
+	admitted?: boolean;
+	/** Present only when not admitted: which filter kept the model out. */
+	reason?: string;
+}
+
+export interface CatalogView {
+	/** When the catalog was last fetched; 0 before the first fetch. */
+	fetchedAtMs: number;
+	/** Sorted by slug. */
+	models: CatalogViewModel[];
+}
+
+/** The filters a turn routes under: the configured ones, or those `applyRequestPolicy` merged a policy into. */
+export type AdmissionFilters = Pick<FilterConfig, "allow" | "deny" | "includeFree" | "requireToolSupport">;
+
+export interface CatalogViewArgs {
+	models: readonly CatalogModel[];
+	fetchedAtMs: number;
+	/** When given, every model carries `admitted` and, if out, `reason`. */
+	verdict?: { filters: AdmissionFilters; pin?: string };
+	/** Why a provider cannot take a turn now, or null when it can. */
+	unserved: (provider: string) => string | null;
+}
+
+/** Per-token catalog prices as USD per million, rounded so `0.22` does not come out as `0.22000000000000003`. */
+function perMillion(usdPerToken: number): number {
+	return Math.round(usdPerToken * 1e6 * 1e6) / 1e6;
+}
+
+export function vendorOf(model: Pick<CatalogModel, "slug" | "provider">): string {
+	const slash = model.slug.indexOf("/");
+	const head = slash === -1 ? model.slug : model.slug.slice(0, slash);
+	if (model.provider === "openrouter" || model.provider === "ollama" || head !== model.provider) return head;
+	const rest = model.slug.slice(slash + 1);
+	const inner = rest.indexOf("/");
+	return inner === -1 ? model.provider : rest.slice(0, inner);
+}
+
+/**
+ * Why the filters keep a model out, or null when it passes. The order is
+ * `buildCandidates`' so the first reason is the one a turn would record.
+ */
+function filterReason(model: CatalogModel, filters: AdmissionFilters, allowRes: readonly RegExp[], denyRes: readonly RegExp[]): string | null {
+	const builtIn = builtInDenial(model);
+	if (builtIn !== null) return builtIn;
+	if (allowRes.length > 0 && !allowRes.some((re) => re.test(model.slug))) return "not in the allow list";
+	const denied = denyRes.findIndex((re) => re.test(model.slug));
+	if (denied !== -1) return `denied by ${filters.deny[denied]}`;
+	if (model.isFree && !filters.includeFree) return "free models excluded (filters.includeFree)";
+	if (filters.requireToolSupport && !model.supportsTools) return "no tool support (filters.requireToolSupport)";
+	return null;
+}
+
+export function catalogView(args: CatalogViewArgs): CatalogView {
+	const sorted = [...args.models].sort((a, b) => (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0));
+	const verdict = args.verdict;
+	const allowRes = verdict === undefined ? [] : verdict.filters.allow.map(globToRe);
+	const denyRes = verdict === undefined ? [] : verdict.filters.deny.map(globToRe);
+	// One reason per slug before the pin is considered: the pin only bites when
+	// the pinned model itself is in, as `select` ignores a pin the filters drop.
+	const reasons = new Map<string, string | null>();
+	if (verdict !== undefined) for (const m of sorted) reasons.set(m.slug, args.unserved(m.provider) ?? filterReason(m, verdict.filters, allowRes, denyRes));
+	const pin = verdict?.pin !== undefined && reasons.get(verdict.pin) === null ? verdict.pin : undefined;
+	const models = sorted.map((m): CatalogViewModel => {
+		const price: CatalogViewModel["price"] = { prompt: perMillion(m.price.prompt), completion: perMillion(m.price.completion) };
+		if (m.price.cacheRead !== undefined) price.cacheRead = perMillion(m.price.cacheRead);
+		if (m.price.cacheWrite !== undefined) price.cacheWrite = perMillion(m.price.cacheWrite);
+		const out: CatalogViewModel = {
+			slug: m.slug,
+			canonicalSlug: m.canonicalSlug,
+			name: m.name,
+			provider: m.provider,
+			vendor: vendorOf(m),
+			contextLength: m.contextLength,
+			...(m.maxCompletionTokens === undefined ? {} : { maxCompletionTokens: m.maxCompletionTokens }),
+			supportsTools: m.supportsTools,
+			supportsReasoning: m.supportsReasoning,
+			reasoningMandatory: m.reasoningMandatory,
+			inputModalities: [...m.inputModalities],
+			price,
+			quality: { ...m.quality },
+			isFree: m.isFree,
+		};
+		if (verdict !== undefined) {
+			const reason = reasons.get(m.slug) ?? (pin !== undefined && m.slug !== pin ? `pinned to ${pin}` : null);
+			out.admitted = reason === null;
+			if (reason !== null) out.reason = reason;
+		}
+		return out;
+	});
+	return { fetchedAtMs: args.fetchedAtMs, models };
+}

package/src/server/http.ts

@@ -6,6 +6,10 @@ import { createBridgeFromConfig } from "../context/index.ts";
 import { createFeedbackStore, type Verdict } from "../cost/feedback.ts";
 import { createLedger } from "../cost/ledger.ts";
 import { createSessionOverrides } from "./overrides.ts";
+import { catalogView } from "./catalog-view.ts";
+import { buildUpstreamModels } from "../catalog/static-catalog.ts";
+import { applyRequestPolicy, resolveProfile } from "../router/index.ts";
+import { parsePolicyHeader } from "../wire/openai/request.ts";
 import { createDigester } from "./digest.ts";
 import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
@@ -484,12 +488,48 @@ export function startServer(cfg: RouterConfig): StartedServer {
 				if (req.method === "GET" && url.pathname === "/v1/router/stats") {
 					return json(computeStats(ledger));
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/catalog") {
+					// The catalog as data, judged under `?policy=` (the X-Omp-Policy
+					// JSON) when one is given: a front door's governance view. Never
+					// blocks on a fetch; before the first one it is empty.
+					const rawPolicy = url.searchParams.get("policy");
+					let verdict: { filters: RouterConfig["filters"]; pin?: string } | undefined;
+					if (rawPolicy !== null) {
+						// The header parser forgives a malformed value (a turn must not
+						// fail on it); a view asked about one must say so instead.
+						let parsed: unknown;
+						try {
+							parsed = JSON.parse(rawPolicy);
+						} catch {
+							parsed = undefined;
+						}
+						if (parsed === undefined || parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+							return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "policy must be a JSON object (the X-Omp-Policy shape)" });
+						}
+						const policed = applyRequestPolicy(resolveProfile(cfg, "auto"), cfg, parsePolicyHeader(rawPolicy), undefined);
+						verdict = { filters: policed.cfg.filters, ...(policed.forceSlug === undefined ? {} : { pin: policed.forceSlug }) };
+					}
+					const snap = catalog.peekAll?.() ?? catalog.peek();
+					// A disabled named upstream's models are not built for routing; list them too, so "why not" has an answer.
+					const disabled = snap === null ? [] : cfg.upstreams.filter((u) => !u.enabled).flatMap((u) => buildUpstreamModels(u, snap.models));
+					const unserved = (provider: string): string | null => {
+						if (provider === "openrouter") return cfg.openrouter.apiKey === "" ? "upstream openrouter has no API key" : null;
+						if (provider === "ollama") return !cfg.ollama.enabled ? "upstream ollama is disabled" : ollama.available() ? null : "upstream ollama is in cooldown";
+						const entry = cfg.upstreams.find((u) => u.id === provider);
+						if (entry === undefined) return `upstream ${provider} is not configured`;
+						if (!entry.enabled) return `upstream ${provider} is disabled`;
+						return providers.named(provider)?.available() ?? true ? null : `upstream ${provider} is in cooldown`;
+					};
+					return json(catalogView({ models: snap === null ? [] : [...snap.models, ...disabled], fetchedAtMs: snap?.fetchedAtMs ?? 0, ...(verdict === undefined ? {} : { verdict }), unserved }));
+				}
 				if (req.method === "GET" && url.pathname === "/v1/router/spend") {
 					// Spend since an instant over a harness set: what a front door's
 					// budget check needs when it cannot read the ledger file.
 					const since = Number.parseInt(url.searchParams.get("sinceMs") ?? "", 10);
 					if (!Number.isFinite(since)) return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "sinceMs required" });
-					return json({ sinceMs: since, usd: spendUsdSince(db, since, harnessScopeParam(url.searchParams.get("harness"))) });
+					// `scope` narrows to one agentdox context scope: a project's own spend.
+					const contextScope = url.searchParams.get("scope") ?? "";
+					return json({ sinceMs: since, usd: spendUsdSince(db, since, harnessScopeParam(url.searchParams.get("harness")), contextScope), ...(contextScope === "" ? {} : { scope: contextScope }) });
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/feedback") {
 					const days = clampDays(url.searchParams.get("days"), 30);

package/src/server/providers.ts

@@ -11,7 +11,7 @@ import { createAnthropicClient } from "../upstream/anthropic.ts";
 import { createCompatClient, type NamedUpstreamClient } from "../upstream/compat.ts";
 import { createOllamaCatalog } from "../catalog/ollama-catalog.ts";
 import { createCatalog } from "../catalog/openrouter-catalog.ts";
-import type { CatalogSource } from "../catalog/types.ts";
+import type { CatalogSnapshot, CatalogSource } from "../catalog/types.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { createMultiUpstream } from "../upstream/multi.ts";
 import { createOllamaClient, type OllamaClient } from "../upstream/ollama.ts";
@@ -24,7 +24,7 @@ import { createLogger, type Logger } from "../util/log.ts";
 
 export interface Providers {
 	upstream: UpstreamClient;
-	catalog: CatalogSource & { ollamaModels?(): unknown[]; ollamaBias?(): number };
+	catalog: CatalogSource & { ollamaModels?(): unknown[]; ollamaBias?(): number; peekAll?(): CatalogSnapshot | null };
 	/** Always present: it carries the circuit breaker. Whether it SERVES follows `cfg.ollama.enabled`. */
 	ollama: OllamaClient;
 	/** True while Ollama Cloud is enabled and out of cooldown, read live. */

package/src/server/turn.ts

@@ -304,6 +304,10 @@ export async function runTurn(
 				turn: turnNumber,
 				requestedModel: req.requestedModel,
 				harnessId: req.harnessId,
+				// The context scope this turn carried, so a front door can charge the
+				// row back to a project. The resolved one the bridge used, header or
+				// configured default; "" stores as NULL.
+				scope: doxScope,
 				ompSessionId: req.ompSessionId,
 				slug: decision.slug,
 				servedSlug,

package/src/util/sqlite.ts

@@ -18,7 +18,7 @@ import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 
 /** Bump when a migration is added; guarded below so reopening never regresses it. */
-const USER_VERSION = 17;
+const USER_VERSION = 18;
 
 const MIGRATIONS = `
 CREATE TABLE IF NOT EXISTS catalog_cache (
@@ -286,6 +286,16 @@ const MIGRATE_V17 = `
 ALTER TABLE conversations ADD COLUMN upgrade_deferred_tier TEXT;
 `;
 
+// v18: ledger records the agentdox context scope the turn carried — the scope
+// the bridge resolved for it (the request header, or the configured default).
+// A front door charges spend back to a project with it: the team edition names
+// a project's scope on every turn, so `scope` is the only column that says
+// which project a row belongs to. NULL on every row written before this, and
+// on any turn that carried no scope at all; there is nothing to backfill from.
+const MIGRATE_V18 = `
+ALTER TABLE ledger ADD COLUMN scope TEXT;
+`;
+
 // v9: benchmark_cache holds the external benchmark feeds (Artificial Analysis,
 // BenchLM) that backfill quality scores OpenRouter leaves unpublished. It is a
 // whole new table, created idempotently by the MIGRATIONS block above, so there
@@ -327,6 +337,7 @@ export function openDb(path: string): Database {
 		if (!ledgerCols.some((c) => c.name === "explored_from")) db.exec(MIGRATE_V7);
 		if (!ledgerCols.some((c) => c.name === "hold_arm")) db.exec(MIGRATE_V8);
 		if (!ledgerCols.some((c) => c.name === "prompt_tokens_saved")) db.exec(MIGRATE_V12);
+		if (!ledgerCols.some((c) => c.name === "scope")) db.exec(MIGRATE_V18);
 		const convCols = db.query("PRAGMA table_info(conversations)").all() as { name: string }[];
 		if (!convCols.some((c) => c.name === "context_version")) db.exec(MIGRATE_V11);
 		if (!convCols.some((c) => c.name === "compaction_plan")) db.exec(MIGRATE_V13);

package/test/catalog-view.test.ts

@@ -0,0 +1,249 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
+import { buildUpstreamModels } from "../src/catalog/static-catalog.ts";
+import type { CatalogModel } from "../src/catalog/types.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { completeUpstreamEntry } from "../src/config/upstreams.ts";
+import { catalogView, vendorOf, type CatalogView, type CatalogViewModel } from "../src/server/catalog-view.ts";
+import { startServer, type StartedServer } from "../src/server/http.ts";
+import { openDb } from "../src/util/sqlite.ts";
+
+/**
+ * The catalog as data for a front door's governance views: every model the
+ * router knows, and under a policy whether a turn could reach it and why not.
+ * Pinned over the pure view and over `GET /v1/router/catalog`, which judges
+ * with the router's own matcher — the same globs, the same order as
+ * `buildCandidates`, a pin that only bites when the pinned model is in.
+ */
+
+const FIXTURE = (await Bun.file("test/fixtures/openrouter-models.json").json()) as { data: unknown[] };
+
+function model(over: Partial<CatalogModel> & { slug: string }): CatalogModel {
+	return {
+		provider: "openrouter",
+		canonicalSlug: `${over.slug}-20260101`,
+		name: over.slug,
+		contextLength: 200_000,
+		supportsTools: true,
+		supportsReasoning: false,
+		reasoningMandatory: false,
+		supportsToolChoice: true,
+		inputModalities: ["text"],
+		price: { prompt: 0.000003, completion: 0.000015 },
+		priceTiers: [],
+		quality: { intelligence: 60 },
+		tokenizer: "Claude",
+		isFree: false,
+		createdAtMs: 0,
+		author: over.slug.split("/")[0] ?? "",
+		...over,
+	};
+}
+
+const vllm = completeUpstreamEntry({ id: "vllm", kind: "openai", baseUrl: "http://vllm:8000/v1", apiKey: "", models: [{ id: "meta-llama/Llama-3", input: 0, output: 0, contextLength: 8_000 }] });
+const azure = completeUpstreamEntry({ id: "azure-eu", kind: "azure", enabled: false, baseUrl: "https://r.openai.azure.com", apiKey: "k", models: [{ id: "gpt-4o-deploy", input: 2.5, output: 10, cachedInput: 1.25 }] });
+
+const MODELS: CatalogModel[] = [
+	model({ slug: "openai/gpt-5", quality: { intelligence: 70, coding: 72 }, maxCompletionTokens: 128_000, price: { prompt: 0.00000125, completion: 0.00001, cacheRead: 0.000000125 } }),
+	model({ slug: "anthropic/claude-sonnet-5", supportsReasoning: true }),
+	model({ slug: "anthropic/claude-haiku-5" }),
+	model({ slug: "anthropic/claude-opus-5:batch" }),
+	model({ slug: "liquid/lfm:free", isFree: true, price: { prompt: 0, completion: 0 } }),
+	model({ slug: "tencent/translator", supportsTools: false }),
+	model({ slug: "ollama/glm-5.3-flash", provider: "ollama", author: "ollama" }),
+	...buildUpstreamModels(vllm, []),
+	...buildUpstreamModels(azure, []),
+];
+
+const served = () => null;
+const bySlug = (view: CatalogView): Map<string, CatalogViewModel> => new Map(view.models.map((m) => [m.slug, m]));
+
+describe("catalogView", () => {
+	test("sorted by slug, prices per million, vendor per slug, and no verdict without a policy", () => {
+		const view = catalogView({ models: MODELS, fetchedAtMs: 123, unserved: served });
+		expect(view.fetchedAtMs).toBe(123);
+		expect(view.models.map((m) => m.slug)).toEqual([...MODELS.map((m) => m.slug)].sort());
+		const gpt = bySlug(view).get("openai/gpt-5")!;
+		expect(gpt).toEqual({
+			slug: "openai/gpt-5",
+			canonicalSlug: "openai/gpt-5-20260101",
+			name: "openai/gpt-5",
+			provider: "openrouter",
+			vendor: "openai",
+			contextLength: 200_000,
+			maxCompletionTokens: 128_000,
+			supportsTools: true,
+			supportsReasoning: false,
+			reasoningMandatory: false,
+			inputModalities: ["text"],
+			price: { prompt: 1.25, completion: 10, cacheRead: 0.125 },
+			quality: { intelligence: 70, coding: 72 },
+			isFree: false,
+		});
+		expect("admitted" in gpt).toBe(false);
+		expect("reason" in gpt).toBe(false);
+		expect("maxCompletionTokens" in bySlug(view).get("anthropic/claude-haiku-5")!).toBe(false);
+		// A named upstream's prices are per million already; they round-trip.
+		expect(bySlug(view).get("azure-eu/gpt-4o-deploy")!.price).toEqual({ prompt: 2.5, completion: 10, cacheRead: 1.25 });
+	});
+
+	test("vendor: the namespace before the first slash; a named upstream's model id may carry its own", () => {
+		expect(vendorOf({ slug: "anthropic/claude-sonnet-5", provider: "openrouter" })).toBe("anthropic");
+		expect(vendorOf({ slug: "ollama/glm-5.3-flash", provider: "ollama" })).toBe("ollama");
+		expect(vendorOf({ slug: "vllm/meta-llama/Llama-3", provider: "vllm" })).toBe("meta-llama");
+		expect(vendorOf({ slug: "azure-eu/gpt-4o-deploy", provider: "azure-eu" })).toBe("azure-eu");
+		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, unserved: served }));
+		expect(view.get("vllm/meta-llama/Llama-3")!.vendor).toBe("meta-llama");
+		expect(view.get("azure-eu/gpt-4o-deploy")!.vendor).toBe("azure-eu");
+	});
+
+	test("an empty policy still judges: the router's own filters and the upstream's state", () => {
+		const unserved = (p: string) => (p === "azure-eu" ? "upstream azure-eu is disabled" : null);
+		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters: DEFAULT_CONFIG.filters }, unserved }));
+		expect(view.get("openai/gpt-5")).toMatchObject({ admitted: true });
+		expect("reason" in view.get("openai/gpt-5")!).toBe(false);
+		expect(view.get("anthropic/claude-opus-5:batch")).toMatchObject({ admitted: false, reason: "built-in deny: floating alias, batch endpoint, stealth, or meta-router" });
+		expect(view.get("liquid/lfm:free")).toMatchObject({ admitted: false, reason: "free models excluded (filters.includeFree)" });
+		expect(view.get("tencent/translator")).toMatchObject({ admitted: false, reason: "no tool support (filters.requireToolSupport)" });
+		expect(view.get("azure-eu/gpt-4o-deploy")).toMatchObject({ admitted: false, reason: "upstream azure-eu is disabled" });
+		// A $0 named-upstream model is self-hosted, never "free".
+		expect(view.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: true });
+		// Filters relaxed: the same models come in.
+		const open = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters: { ...DEFAULT_CONFIG.filters, includeFree: true, requireToolSupport: false } }, unserved: served }));
+		expect(open.get("liquid/lfm:free")!.admitted).toBe(true);
+		expect(open.get("tencent/translator")!.admitted).toBe(true);
+	});
+
+	test("allow list, deny glob and pin, in the order a turn applies them", () => {
+		const filters = { ...DEFAULT_CONFIG.filters, allow: ["anthropic/*", "vllm/*"], deny: ["*haiku*"] };
+		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters }, unserved: served }));
+		expect(view.get("openai/gpt-5")).toMatchObject({ admitted: false, reason: "not in the allow list" });
+		expect(view.get("anthropic/claude-haiku-5")).toMatchObject({ admitted: false, reason: "denied by *haiku*" });
+		expect(view.get("anthropic/claude-sonnet-5")).toMatchObject({ admitted: true });
+		expect(view.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: true });
+		// A pin keeps every other model out.
+		const pinned = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters, pin: "anthropic/claude-sonnet-5" }, unserved: served }));
+		expect(pinned.get("anthropic/claude-sonnet-5")).toMatchObject({ admitted: true });
+		expect(pinned.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: false, reason: "pinned to anthropic/claude-sonnet-5" });
+		expect(pinned.get("openai/gpt-5")).toMatchObject({ admitted: false, reason: "not in the allow list" }); // the earlier reason stands
+		// A pin the filters drop is ignored, as select ignores it: nothing else is pinned out.
+		const dropped = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters, pin: "anthropic/claude-haiku-5" }, unserved: served }));
+		expect(dropped.get("anthropic/claude-haiku-5")).toMatchObject({ admitted: false, reason: "denied by *haiku*" });
+		expect(dropped.get("anthropic/claude-sonnet-5")).toMatchObject({ admitted: true });
+		// So is a pin naming no model.
+		expect(bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters, pin: "nobody/here" }, unserved: served })).get("anthropic/claude-sonnet-5")!.admitted).toBe(true);
+	});
+});
+
+describe("GET /v1/router/catalog", () => {
+	let handle: StartedServer;
+	let empty: StartedServer;
+	const dir = mkdtempSync(join(tmpdir(), "amr-catalog-"));
+	const FETCHED = Date.now() - 60_000;
+	beforeAll(() => {
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		cfg.server.host = "127.0.0.1";
+		cfg.server.port = 0;
+		cfg.server.apiKey = "k";
+		cfg.logLevel = "silent";
+		// Nothing reaches the network: the catalog is served from its on-disk
+		// cache (within TTL), the periodic refresh is off, and the base URL is dead.
+		cfg.openrouter.apiKey = "sk-test";
+		cfg.openrouter.baseUrl = "http://127.0.0.1:9/api/v1";
+		cfg.openrouter.catalogRefreshMs = 0;
+		cfg.benchmarks.enabled = false;
+		cfg.upstreams = [vllm, azure];
+		cfg.ledger.path = join(dir, "router.db");
+		const db = openDb(cfg.ledger.path);
+		db.run("INSERT INTO catalog_cache (id, payload, fetched_at_ms, etag, key_scoped) VALUES (1, ?, ?, NULL, 0)", [JSON.stringify(FIXTURE.data), FETCHED]);
+		db.close();
+		handle = startServer(cfg);
+		const bare = structuredClone(cfg);
+		bare.upstreams = [];
+		bare.ledger.path = join(dir, "empty.db");
+		empty = startServer(bare);
+	});
+	afterAll(async () => {
+		await handle.stop();
+		await empty.stop();
+		try {
+			rmSync(dir, { recursive: true, force: true });
+		} catch {
+			/* Windows may hold the WAL briefly */
+		}
+	});
+	const get = (path: string, port = handle.server.port) => fetch(`http://127.0.0.1:${port}${path}`, { headers: { authorization: "Bearer k" } });
+	const view = async (path: string): Promise<Map<string, CatalogViewModel>> => bySlug((await (await get(path)).json()) as CatalogView);
+
+	test("the catalog as data: authenticated, sorted, every upstream's models, no verdict without a policy", async () => {
+		expect((await fetch(`http://127.0.0.1:${handle.server.port}/v1/router/catalog`)).status).toBe(401);
+		const res = await get("/v1/router/catalog");
+		expect(res.status).toBe(200);
+		const body = (await res.json()) as CatalogView;
+		expect(body.fetchedAtMs).toBe(FETCHED);
+		const slugs = body.models.map((m) => m.slug);
+		expect(slugs).toEqual([...slugs].sort());
+		// Every OpenRouter model the fixture normalises to, plus both named upstreams' — the disabled one too.
+		expect(slugs).toHaveLength(FIXTURE.data.filter((m) => normalizeCatalogModel(m) !== null).length + 2);
+		const models = bySlug(body);
+		const opus = models.get("anthropic/claude-opus-5")!;
+		const raw = normalizeCatalogModel(FIXTURE.data.find((m) => (m as { id: string }).id === "anthropic/claude-opus-5"))!;
+		expect(opus).toEqual({
+			slug: "anthropic/claude-opus-5",
+			canonicalSlug: raw.canonicalSlug,
+			name: raw.name,
+			provider: "openrouter",
+			vendor: "anthropic",
+			contextLength: raw.contextLength,
+			maxCompletionTokens: 128_000,
+			supportsTools: true,
+			supportsReasoning: raw.supportsReasoning,
+			reasoningMandatory: raw.reasoningMandatory,
+			inputModalities: raw.inputModalities,
+			price: { prompt: 5, completion: raw.price.completion * 1e6, cacheRead: 0.5, ...(raw.price.cacheWrite === undefined ? {} : { cacheWrite: raw.price.cacheWrite * 1e6 }) },
+			quality: raw.quality,
+			isFree: false,
+		});
+		expect(models.get("vllm/meta-llama/Llama-3")).toMatchObject({ provider: "vllm", vendor: "meta-llama", contextLength: 8_000 });
+		expect(models.get("azure-eu/gpt-4o-deploy")).toMatchObject({ provider: "azure-eu", vendor: "azure-eu", price: { prompt: 2.5, completion: 10, cacheRead: 1.25 } });
+		expect(body.models.some((m) => "admitted" in m || "reason" in m)).toBe(false);
+	});
+
+	test("judged under a policy: allow, deny, pin, the router's filters and the upstream's state", async () => {
+		const allowed = await view(`/v1/router/catalog?policy=${encodeURIComponent(JSON.stringify({ allow: ["anthropic/*", "azure-eu/*"], deny: ["anthropic/claude-opus-5"], maxTier: "simple" }))}`);
+		expect(allowed.get("anthropic/claude-sonnet-4.5")).toMatchObject({ admitted: true });
+		expect(allowed.get("anthropic/claude-opus-5")).toMatchObject({ admitted: false, reason: "denied by anthropic/claude-opus-5" });
+		expect(allowed.get("anthropic/claude-opus-5:batch")).toMatchObject({ admitted: false, reason: "built-in deny: floating alias, batch endpoint, stealth, or meta-router" });
+		expect(allowed.get("openai/gpt-5.6-luna")).toMatchObject({ admitted: false, reason: "not in the allow list" });
+		expect(allowed.get("azure-eu/gpt-4o-deploy")).toMatchObject({ admitted: false, reason: "upstream azure-eu is disabled" });
+		// The configured deny list stays in force under a policy's, as applyRequestPolicy adds rather than replaces.
+		const pinned = await view(`/v1/router/catalog?policy=${encodeURIComponent(JSON.stringify({ pin: "vllm/meta-llama/Llama-3" }))}`);
+		expect(pinned.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: true });
+		expect(pinned.get("anthropic/claude-sonnet-4.5")).toMatchObject({ admitted: false, reason: "pinned to vllm/meta-llama/Llama-3" });
+		expect(pinned.get("tencent/hy-mt2-1.8b")).toMatchObject({ admitted: false, reason: "no tool support (filters.requireToolSupport)" });
+		expect(pinned.get("liquid/lfm-2.5-2.6b:free")).toMatchObject({ admitted: false, reason: "free models excluded (filters.includeFree)" });
+		// `{}` is a policy too: every model carries a verdict.
+		const plain = await view("/v1/router/catalog?policy=%7B%7D");
+		expect(plain.get("anthropic/claude-sonnet-4.5")).toMatchObject({ admitted: true });
+		expect([...plain.values()].every((m) => typeof m.admitted === "boolean")).toBe(true);
+	});
+
+	test("a malformed policy is a 400 in the wire error shape", async () => {
+		for (const bad of ["%7B", "not-json", "%5B%5D", "null", "1"]) {
+			const res = await get(`/v1/router/catalog?policy=${bad}`);
+			expect(res.status).toBe(400);
+			const body = (await res.json()) as { error: { message: string; type: string; code: string } };
+			expect(body.error.code).toBe("invalid_request_error");
+			expect(body.error.message).toContain("policy");
+		}
+	});
+
+	test("before the first fetch: empty, never a wait", async () => {
+		expect((await (await get("/v1/router/catalog", empty.server.port)).json()) as CatalogView).toEqual({ fetchedAtMs: 0, models: [] });
+		expect((await (await get("/v1/router/catalog?policy=%7B%7D", empty.server.port)).json()) as CatalogView).toEqual({ fetchedAtMs: 0, models: [] });
+	});
+});

package/test/migrations.test.ts

@@ -8,6 +8,7 @@ import { createFeedbackStore } from "../src/cost/feedback.ts";
 import { createLedger } from "../src/cost/ledger.ts";
 import { buildUsageReport } from "../src/cost/report.ts";
 import { buildDailySummary, createKv } from "../src/cost/summary.ts";
+import { exportRows, spendUsdSince } from "../src/cost/views.ts";
 import { createConversationStore } from "../src/router/state.ts";
 import { openDb } from "../src/util/sqlite.ts";
 
@@ -23,7 +24,7 @@ import { openDb } from "../src/util/sqlite.ts";
 
 const FIXTURES = join(import.meta.dir, "fixtures", "migrations");
 const files = readdirSync(FIXTURES).filter((f) => /^router-v\d+\.db$/.test(f)).sort((a, b) => Number(/\d+/.exec(a)![0]) - Number(/\d+/.exec(b)![0]));
-const CURRENT_VERSION = 17;
+const CURRENT_VERSION = 18;
 
 describe("schema migrations from every shipped version", () => {
 	test("fixtures exist for the versions that shipped", () => {
@@ -43,7 +44,7 @@ describe("schema migrations from every shipped version", () => {
 				expect((db.query("PRAGMA user_version").get() as { user_version: number }).user_version).toBe(CURRENT_VERSION);
 				// Every column the current code writes exists after migration.
 				const ledgerCols = new Set((db.query("PRAGMA table_info(ledger)").all() as { name: string }[]).map((c) => c.name));
-				for (const c of ["harness_id", "error_kind", "omp_session_id", "features", "explored_from", "hold_arm", "prompt_tokens_saved"]) expect(ledgerCols.has(c)).toBe(true);
+				for (const c of ["harness_id", "error_kind", "omp_session_id", "features", "explored_from", "hold_arm", "prompt_tokens_saved", "scope"]) expect(ledgerCols.has(c)).toBe(true);
 				const convCols = new Set((db.query("PRAGMA table_info(conversations)").all() as { name: string }[]).map((c) => c.name));
 				for (const c of ["context_version", "compaction_plan", "compaction_plan_tokens", "upgrade_deferred_tier"]) expect(convCols.has(c)).toBe(true);
 				// The fixture's ledger row survived the ALTERs with its values.
@@ -61,6 +62,11 @@ describe("schema migrations from every shipped version", () => {
 				expect(conversations.load("fixture-key").key).toBe("fixture-key");
 				expect(buildUsageReport(db, { windowDays: 3650 }).totals.dispatches).toBe(1);
 				expect(buildDailySummary(db, {}).current.dispatches).toBe(0);
+				// v18: the fixture's row predates `scope`, so it exports under "" and no
+				// context scope claims its spend.
+				expect(exportRows(db, 0, null).map((r) => r.scope)).toEqual([""]);
+				expect(spendUsdSince(db, 0, null, "acme.api")).toBe(0);
+				expect(spendUsdSince(db, 0, null)).toBeGreaterThanOrEqual(0);
 				expect(ledger.prune?.(0)).toBe(0);
 			} finally {
 				db.close();
@@ -77,6 +83,8 @@ describe("schema migrations from every shipped version", () => {
 		const db = openDb(":memory:");
 		try {
 			expect((db.query("PRAGMA user_version").get() as { user_version: number }).user_version).toBe(CURRENT_VERSION);
+			// A fresh ledger has the scope column the bootstrap never spells out in CREATE TABLE.
+			expect((db.query("PRAGMA table_info(ledger)").all() as { name: string }[]).some((c) => c.name === "scope")).toBe(true);
 		} finally {
 			db.close();
 		}

package/test/trust-attribution.test.ts

@@ -259,11 +259,11 @@ describe("v4 migration", () => {
 		db.close();
 	});
 
-	test("schema is at user_version 17", () => {
+	test("schema is at user_version 18", () => {
 		const db = openDb(":memory:");
 		try {
 			const row = db.query("PRAGMA user_version").get() as { user_version: number };
-			expect(row.user_version).toBe(17);
+			expect(row.user_version).toBe(18);
 		} finally {
 			db.close();
 		}

package/test/turn.test.ts

@@ -545,6 +545,29 @@ describe("runTurn", () => {
 	});
 });
 
+describe("the context scope reaches the ledger", () => {
+	const run = async (req: NormRequest, config: RouterConfig) => {
+		const { router } = mkRouter([mkDecision("trivial", "cheap/model", { escalateTo: "simple" })]);
+		const { upstream } = mkUpstream([{ kind: "chunks", chunks: [startChunk("cheap/model"), textChunk("hi"), finishChunk("stop"), usageChunk({ promptTokens: 10, completionTokens: 2 }, 0.0001)] }]);
+		const { ledger, entries } = mkLedger();
+		const { store } = mkConversations();
+		const { sink } = mkSink();
+		await runTurn(req, sink, { config, router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+		return entries;
+	};
+
+	test("a turn's scope is recorded, header first and the configured default behind it", async () => {
+		// The header the team front door sets: the row can be charged to that project.
+		expect((await run({ ...mkReq(), agentdoxScope: "acme.api" }, mkConfig()))[0]!.scope).toBe("acme.api");
+		// No header: the resolved scope is the configured default, which is what the bridge would have used.
+		const base = mkConfig();
+		const withDefault: RouterConfig = { ...base, context: { ...base.context, defaultScope: "solo" } };
+		expect((await run(mkReq(), withDefault))[0]!.scope).toBe("solo");
+		// Neither: no scope at all, which the ledger stores as NULL.
+		expect((await run(mkReq(), mkConfig()))[0]!.scope).toBe("");
+	});
+});
+
 describe("exploration reaches the ledger", () => {
 	test("an explored turn records the tier it was dropped from", async () => {
 		const explored = { ...mkDecision("simple", "cheap/model"), explored: { from: "moderate" as Tier, to: "simple" as Tier } };

package/test/views.test.ts

@@ -64,9 +64,9 @@ function seeded() {
 	const db = openDb(":memory:");
 	const ledger = createLedger(db, cfg);
 	const feedback = createFeedbackStore(db);
-	ledger.record(entry({ id: "l1", harnessId: "u_ada", slug: "anthropic/claude-sonnet-5", servedSlug: "anthropic/claude-sonnet-5", predictedUsd: 0.01, reportedUsd: 0.012 }));
-	ledger.record(entry({ id: "l2", harnessId: "u_ada", slug: "anthropic/claude-sonnet-5", servedSlug: null, predictedUsd: 0.01, reportedUsd: null, escalationSignal: "circular" }));
-	ledger.record(entry({ id: "l3", harnessId: "u_bob", slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", predictedUsd: 0.001, reportedUsd: 0.001, error: "boom" }));
+	ledger.record(entry({ id: "l1", harnessId: "u_ada", scope: "acme.api", slug: "anthropic/claude-sonnet-5", servedSlug: "anthropic/claude-sonnet-5", predictedUsd: 0.01, reportedUsd: 0.012 }));
+	ledger.record(entry({ id: "l2", harnessId: "u_ada", scope: "acme.web", slug: "anthropic/claude-sonnet-5", servedSlug: null, predictedUsd: 0.01, reportedUsd: null, escalationSignal: "circular" }));
+	ledger.record(entry({ id: "l3", harnessId: "u_bob", scope: "acme.api", slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", predictedUsd: 0.001, reportedUsd: 0.001, error: "boom" }));
 	ledger.record(entry({ id: "l4", harnessId: "u_bob", requestedModel: "digest", slug: "ollama/glm-5.3-flash", servedSlug: "ollama/glm-5.3-flash", predictedUsd: 0.5, reportedUsd: 0.5 }));
 	ledger.record(entry({ id: "l5", harnessId: "u_bob", createdAtMs: NOW - 40 * DAY, slug: "ollama/glm-5.3-flash", predictedUsd: 5, reportedUsd: 5 }));
 	feedback.record({ ledgerId: "l1", ompSessionId: "s", slug: "anthropic/claude-sonnet-5", tier: "simple", verdict: "good", note: "" }, NOW - 1000);
@@ -87,6 +87,17 @@ describe("ledger views", () => {
 		expect(spendUsdSince(db, since, [])).toBe(0);
 	});
 
+	test("spend narrowed to one context scope, so a front door charges a project", () => {
+		// l1 (0.012, u_ada) and l3 (0.001, u_bob) carried acme.api; l2 (0.01 predicted) carried acme.web.
+		expect(spendUsdSince(db, since, null, "acme.api")).toBeCloseTo(0.013, 6);
+		expect(spendUsdSince(db, since, null, "acme.web")).toBeCloseTo(0.01, 6);
+		expect(spendUsdSince(db, since, ["u_ada"], "acme.api")).toBeCloseTo(0.012, 6); // harness and scope compose
+		expect(spendUsdSince(db, since, ["u_bob"], "acme.web")).toBe(0);
+		expect(spendUsdSince(db, since, null, "nope")).toBe(0);
+		expect(spendUsdSince(db, since, null, "")).toBeCloseTo(0.523, 6); // no scope given: every turn, scoped or not
+		expect(spendUsdSince(db, since, [], "acme.api")).toBe(0);
+	});
+
 	test("feedback by model with distinct judges, scoped by harness", () => {
 		const all = feedbackView(db, since, null);
 		expect(all.byModel).toEqual([
@@ -102,17 +113,22 @@ describe("ledger views", () => {
 		expect(feedbackView(db, since, []).recent).toEqual([]);
 	});
 
-	test("export rows by day, harness and served model; digest and old rows out; CSV quoting", () => {
+	test("export rows by day, harness, served model and scope; digest and old rows out; CSV quoting", () => {
 		const rows = exportRows(db, since, null);
-		expect(rows).toHaveLength(2);
-		expect(rows[0]).toMatchObject({ day: "2026-09-07", harnessId: "u_ada", slug: "anthropic/claude-sonnet-5", provider: "openrouter", dispatches: 2, promptTokens: 2000, cachedTokens: 800, completionTokens: 100, escalations: 1, errors: 0 });
-		expect(rows[0]!.spendUsd).toBeCloseTo(0.022, 6);
-		expect(rows[1]).toMatchObject({ harnessId: "u_bob", provider: "ollama", dispatches: 1, errors: 1 });
+		// u_ada's two turns are one model on one day but two projects, so they no longer share a row.
+		expect(rows).toHaveLength(3);
+		expect(rows[0]).toMatchObject({ day: "2026-09-07", harnessId: "u_ada", slug: "anthropic/claude-sonnet-5", scope: "acme.api", provider: "openrouter", dispatches: 1, promptTokens: 1000, cachedTokens: 400, completionTokens: 50, escalations: 0, errors: 0 });
+		expect(rows[0]!.spendUsd).toBeCloseTo(0.012, 6);
+		expect(rows[1]).toMatchObject({ harnessId: "u_ada", scope: "acme.web", dispatches: 1, escalations: 1 });
+		expect(rows[1]!.spendUsd).toBeCloseTo(0.01, 6);
+		expect(rows[2]).toMatchObject({ harnessId: "u_bob", scope: "acme.api", provider: "ollama", dispatches: 1, errors: 1 });
 		expect(exportRows(db, since, ["u_bob"])).toHaveLength(1);
 		expect(exportRows(db, since, [])).toEqual([]);
+		// A turn that carried no scope groups under "": what every row written before v18 does.
+		expect(exportRows(db, NOW - 60 * DAY, ["u_bob"]).map((r) => r.scope).sort()).toEqual(["", "acme.api"]);
 		const csv = exportCsv([{ ...rows[0]!, harnessId: 'ada, "L"' }]);
-		expect(csv.split("\n")[0]).toBe("day,harness,model,provider,dispatches,prompt_tokens,cached_tokens,completion_tokens,spend_usd,escalations,errors");
-		expect(csv.split("\n")[1]).toBe('2026-09-07,"ada, ""L""",anthropic/claude-sonnet-5,openrouter,2,2000,800,100,0.022000,1,0');
+		expect(csv.split("\n")[0]).toBe("day,harness,model,provider,dispatches,prompt_tokens,cached_tokens,completion_tokens,spend_usd,escalations,errors,scope");
+		expect(csv.split("\n")[1]).toBe('2026-09-07,"ada, ""L""",anthropic/claude-sonnet-5,openrouter,1,1000,400,50,0.012000,0,0,acme.api');
 		expect(harnessScopeParam(null)).toBeNull();
 		expect(harnessScopeParam(" , ")).toBeNull();
 		expect(harnessScopeParam("a, b")).toEqual(["a", "b"]);
@@ -130,7 +146,7 @@ describe("view routes", () => {
 		cfg.ledger.path = join(dir, "router.db");
 		// Seed through the ledger on the same file before the server opens it.
 		const db = openDb(cfg.ledger.path);
-		createLedger(db, cfg).record(entry({ id: "r1", createdAtMs: Date.now() - 1000, harnessId: "u_x", predictedUsd: 0.2, reportedUsd: 0.25 }));
+		createLedger(db, cfg).record(entry({ id: "r1", createdAtMs: Date.now() - 1000, harnessId: "u_x", scope: "acme.api", predictedUsd: 0.2, reportedUsd: 0.25 }));
 		db.close();
 		handle = startServer(cfg);
 	});
@@ -155,14 +171,21 @@ describe("view routes", () => {
 		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);
+		// ?scope= charges one project: the row carried acme.api, so acme.web sees nothing.
+		const scoped = (await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&scope=acme.api`)).json()) as { usd: number; scope: string };
+		expect(scoped.usd).toBeCloseTo(0.25, 6);
+		expect(scoped.scope).toBe("acme.api");
+		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&scope=acme.web`)).json()) as { usd: number }).usd).toBe(0);
+		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&harness=u_x&scope=acme.api`)).json()) as { usd: number }).usd).toBeCloseTo(0.25, 6);
 		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: [] });
 		const csv = await get("/v1/router/export?days=1");
 		expect(csv.headers.get("content-type")).toContain("text/csv");
-		expect((await csv.text()).split("\n")[1]).toContain("u_x,vendor/model,openrouter,1,1000,400,50,0.250000,0,0");
-		const js = (await (await get("/v1/router/export?days=1&format=json&harness=u_x")).json()) as { days: number; rows: { harnessId: string }[] };
+		expect((await csv.text()).split("\n")[1]).toContain("u_x,vendor/model,openrouter,1,1000,400,50,0.250000,0,0,acme.api");
+		const js = (await (await get("/v1/router/export?days=1&format=json&harness=u_x")).json()) as { days: number; rows: { harnessId: string; scope: string }[] };
 		expect(js.days).toBe(1);
 		expect(js.rows[0]?.harnessId).toBe("u_x");
+		expect(js.rows[0]?.scope).toBe("acme.api");
 	});
 });
 
@@ -176,6 +199,9 @@ describe("decision entries", () => {
 		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");
+		// The context scope is a ledger column now, so it rides along on every entry.
+		expect(ada.find((e) => e.id === "l1")?.scope).toBe("acme.api");
+		expect(ada.find((e) => e.id === "l2")?.scope).toBe("acme.web");
 		// 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);