auto-model-router 0.18.0 → 0.19.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.18.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.18.0",
+      "version": "0.19.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

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,10 +708,12 @@ 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
@@ -1555,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.18.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/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/server/http.ts

@@ -527,7 +527,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					// 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/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/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);