@swestash/agent-lens 0.10.0 → 0.11.1

package/dist/agent-lens.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync10, writeFileSync as writeFileSync3 } from "fs";
-import { join as join12 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { existsSync as existsSync10, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join12 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // ../../node_modules/.pnpm/cac@6.7.14/node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -921,6 +921,29 @@ END;
 `
 );
 
+// ../core/dist/sqlite.js
+function runNamed(stmt, row) {
+  return stmt.run(row);
+}
+var savepointSeq = 0;
+function transaction(db, fn) {
+  return (...args) => {
+    const savepoint = db.isTransaction ? `agent_lens_sp_${savepointSeq++}` : "";
+    db.exec(savepoint ? `SAVEPOINT ${savepoint}` : "BEGIN");
+    try {
+      const result = fn(...args);
+      db.exec(savepoint ? `RELEASE ${savepoint}` : "COMMIT");
+      return result;
+    } catch (err) {
+      try {
+        db.exec(savepoint ? `ROLLBACK TO ${savepoint}; RELEASE ${savepoint}` : "ROLLBACK");
+      } catch {
+      }
+      throw err;
+    }
+  };
+}
+
 // ../core/dist/security.js
 var SEVERITY_ORDER = ["info", "low", "medium", "high", "critical"];
 function severityRank(s) {
@@ -1076,7 +1099,7 @@ function scrubUsernames(text, users) {
 }
 
 // ../core/dist/redact-export.js
-import { createHash } from "crypto";
+import { createHash } from "node:crypto";
 
 // ../core/dist/markdown.js
 function truncate(s) {
@@ -1242,6 +1265,15 @@ function classifyToolError(resultSummary) {
 }
 
 // ../core/dist/pricing.js
+var SYNTHETIC_MODEL = "<synthetic>";
+function unpricedModels(models) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of models) {
+    if (m && m !== SYNTHETIC_MODEL && !rateForModel(m))
+      out.add(m);
+  }
+  return [...out].sort();
+}
 var PRICE_TABLE = {
   // Opus 4.0 / 4.1 launched at $15/$75; Opus 4.5 cut the Opus tier to $5/$25 and 4.6/4.7/4.8 kept it.
   // The bare 'claude-opus-4' fallback stays at the legacy rate for 4.0/4.1; 4.5+ override below.
@@ -1250,17 +1282,68 @@ var PRICE_TABLE = {
   "claude-opus-4-6": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
   "claude-opus-4-7": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
   "claude-opus-4-8": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+  "claude-opus-5": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
   "claude-fable-5": { input: 10, output: 50, cacheWrite: 12.5, cacheRead: 1 },
   "claude-sonnet-4": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  // Sonnet 5 list price. An introductory $2/$10 rate runs through 2026-08-31; we bill the list
+  // price so the estimate doesn't silently change under a date, matching the "list price" label.
+  "claude-sonnet-5": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
   "claude-haiku-4": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 },
   "claude-3-5-haiku": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 },
   "claude-3-5-sonnet": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 }
 };
+var CACHE_WRITE_MULTIPLIER = 1.25;
+var CACHE_READ_MULTIPLIER = 0.1;
+function toRate(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v))
+    return null;
+  const o = v;
+  const num = (x) => typeof x === "number" && Number.isFinite(x) && x >= 0 ? x : null;
+  const input = num(o.input);
+  const output = num(o.output);
+  if (input === null || output === null)
+    return null;
+  if (o.cacheWrite !== void 0 && num(o.cacheWrite) === null)
+    return null;
+  if (o.cacheRead !== void 0 && num(o.cacheRead) === null)
+    return null;
+  return {
+    input,
+    output,
+    cacheWrite: num(o.cacheWrite) ?? input * CACHE_WRITE_MULTIPLIER,
+    cacheRead: num(o.cacheRead) ?? input * CACHE_READ_MULTIPLIER
+  };
+}
+function mergePricing(base, overrides) {
+  const table = { ...base };
+  const invalid = [];
+  const applied = [];
+  if (overrides === null || typeof overrides !== "object" || Array.isArray(overrides)) {
+    return { table, invalid, applied };
+  }
+  for (const [prefix, value] of Object.entries(overrides)) {
+    const rate = toRate(value);
+    if (!prefix.trim() || !rate)
+      invalid.push(prefix);
+    else {
+      table[prefix] = rate;
+      applied.push(prefix);
+    }
+  }
+  return { table, invalid: invalid.sort(), applied: applied.sort() };
+}
+var activeTable = PRICE_TABLE;
+function usePricing(table) {
+  activeTable = table;
+}
+function activePricing() {
+  return activeTable;
+}
 function rateForModel(model) {
   if (!model)
     return null;
   let best = null;
-  for (const [prefix, rate] of Object.entries(PRICE_TABLE)) {
+  for (const [prefix, rate] of Object.entries(activeTable)) {
     if (model.startsWith(prefix) && (!best || prefix.length > best.len)) {
       best = { len: prefix.length, rate };
     }
@@ -1276,25 +1359,24 @@ function costForUsage(model, u) {
 }
 
 // ../core/dist/rawjson.js
-import { gzipSync, gunzipSync } from "zlib";
+import { gzipSync, gunzipSync } from "node:zlib";
 function packRaw(json) {
   return gzipSync(Buffer.from(json, "utf8"));
 }
 function unpackRaw(value) {
-  if (Buffer.isBuffer(value)) {
-    if (value.length >= 2 && value[0] === 31 && value[1] === 139) {
-      return gunzipSync(value).toString("utf8");
-    }
-    return value.toString("utf8");
+  if (typeof value === "string")
+    return value;
+  if (value.length >= 2 && value[0] === 31 && value[1] === 139) {
+    return gunzipSync(value).toString("utf8");
   }
-  return value;
+  return Buffer.from(value).toString("utf8");
 }
 
 // ../core/dist/paths.js
-import { existsSync, readFileSync } from "fs";
-import { dirname, join, resolve } from "path";
-import { fileURLToPath } from "url";
-import { homedir, platform } from "os";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir, platform } from "node:os";
 function expandPath(p) {
   if (!p)
     return p;
@@ -1372,8 +1454,8 @@ function resolveWebDist(fromDir, repoRoot = findRepoRoot(fromDir)) {
 }
 
 // ../core/dist/config.js
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 var DEFAULT_PORT = 4477;
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_DB_NAME = "agent-lens.db";
@@ -1383,6 +1465,18 @@ function resolveRetention() {
   const parsed = raw ? Number(raw) : NaN;
   return Number.isFinite(parsed) && parsed >= 0 ? { keepDays: parsed, origin: "env" } : { keepDays: DEFAULT_VERSIONS_KEEP_DAYS, origin: "default" };
 }
+function resolvePricing(cfg = readConfigFile()) {
+  const { table, invalid, applied } = mergePricing(PRICE_TABLE, cfg?.pricing);
+  return { table, origin: applied.length ? "file" : "default", applied, invalid };
+}
+function installPricing(cfg) {
+  const resolved = cfg === void 0 ? resolvePricing() : resolvePricing(cfg);
+  usePricing(resolved.table);
+  if (resolved.invalid.length) {
+    console.error(`agent-lens: ignoring ${resolved.invalid.length} malformed pricing override(s): ${resolved.invalid.join(", ")} (each entry needs numeric input + output; built-in rates kept)`);
+  }
+  return resolved;
+}
 function readConfigFile() {
   const repoRoot = findRepoRoot();
   const dataDir = resolveDataDir(repoRoot);
@@ -1443,10 +1537,10 @@ function resolveServerConfig(overrides = {}, cfg = readConfigFile()) {
 }
 
 // ../core/dist/version.js
-import { spawnSync } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join3, parse } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { spawnSync } from "node:child_process";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join3, parse } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var moduleDir2 = dirname2(fileURLToPath2(import.meta.url));
 function isPlaceholder(v) {
   return v.startsWith("0.0.0");
@@ -1548,9 +1642,9 @@ function encodeProjectPath(p) {
 }
 
 // ../core/dist/collect.js
-import { appendFileSync, closeSync, copyFileSync, existsSync as existsSync2, mkdirSync, openSync, readSync, readdirSync, statSync, unlinkSync, utimesSync, writeSync, chmodSync } from "fs";
-import { basename, dirname as dirname3, join as join4, relative, sep } from "path";
-import { platform as platform2 } from "os";
+import { appendFileSync, closeSync, copyFileSync, existsSync as existsSync2, mkdirSync, openSync, readSync, readdirSync, statSync, unlinkSync, utimesSync, writeSync, chmodSync } from "node:fs";
+import { basename, dirname as dirname3, join as join4, relative, sep } from "node:path";
+import { platform as platform2 } from "node:os";
 var POSIX = platform2() !== "win32";
 var DIR_MODE = 448;
 var FILE_MODE = 384;
@@ -1769,9 +1863,9 @@ function collectAll(opts = {}) {
 }
 
 // ../core/dist/lock.js
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { dirname as dirname4 } from "path";
-import { hostname } from "os";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+import { hostname } from "node:os";
 function isAlive(pid) {
   if (!pid)
     return false;
@@ -1811,10 +1905,10 @@ function acquireLock(lockPath, staleMs = 6 * 60 * 60 * 1e3) {
 }
 
 // ../core/dist/service.js
-import { spawnSync as spawnSync2 } from "child_process";
-import { mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2, platform as platform3, userInfo } from "os";
-import { join as join5 } from "path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2, platform as platform3, userInfo } from "node:os";
+import { join as join5 } from "node:path";
 var DEFAULT_HOURS = [9, 13, 17, 21];
 function currentUser() {
   try {
@@ -2139,15 +2233,15 @@ function runService(action, params) {
 }
 
 // ../ingest/dist/run.js
-import { readFileSync as readFileSync6, statSync as statSync3, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
-import { dirname as dirname6, join as join9 } from "path";
+import { readFileSync as readFileSync6, statSync as statSync3, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname6, join as join9 } from "node:path";
 
 // ../ingest/dist/db.js
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 function openRaw(file) {
-  const db = new Database(file);
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
+  const db = new DatabaseSync(file);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
   return db;
 }
 function readSchemaVersion(db) {
@@ -2167,37 +2261,40 @@ function openDb(file) {
   return db;
 }
 function resetSchema(db) {
-  db.pragma("foreign_keys = OFF");
-  db.exec(`
-    DROP TRIGGER IF EXISTS events_au;
-    DROP TRIGGER IF EXISTS events_ad;
-    DROP TRIGGER IF EXISTS events_ai;
-    DROP TABLE IF EXISTS events_fts;
-    DROP TABLE IF EXISTS file_changes;
-    DROP TABLE IF EXISTS findings;
-    DROP TABLE IF EXISTS classifications;
-    DROP TABLE IF EXISTS token_usage;
-    DROP TABLE IF EXISTS tool_calls;
-    DROP TABLE IF EXISTS skills;
-    DROP TABLE IF EXISTS events;
-    DROP TABLE IF EXISTS turns;
-    DROP TABLE IF EXISTS sessions;
-    DROP TABLE IF EXISTS projects;
-    DROP TABLE IF EXISTS sources;
-    DROP TABLE IF EXISTS agents;
-    DROP TABLE IF EXISTS workflow_results;
-    DROP TABLE IF EXISTS session_meta;
-    DROP TABLE IF EXISTS tool_results;
-    DROP TABLE IF EXISTS ingest_state;
-    DROP TABLE IF EXISTS meta;
-  `);
-  applySchema(db);
-  db.pragma("foreign_keys = ON");
+  db.exec("PRAGMA foreign_keys = OFF");
+  try {
+    db.exec(`
+      DROP TRIGGER IF EXISTS events_au;
+      DROP TRIGGER IF EXISTS events_ad;
+      DROP TRIGGER IF EXISTS events_ai;
+      DROP TABLE IF EXISTS events_fts;
+      DROP TABLE IF EXISTS file_changes;
+      DROP TABLE IF EXISTS findings;
+      DROP TABLE IF EXISTS classifications;
+      DROP TABLE IF EXISTS token_usage;
+      DROP TABLE IF EXISTS tool_calls;
+      DROP TABLE IF EXISTS skills;
+      DROP TABLE IF EXISTS events;
+      DROP TABLE IF EXISTS turns;
+      DROP TABLE IF EXISTS sessions;
+      DROP TABLE IF EXISTS projects;
+      DROP TABLE IF EXISTS sources;
+      DROP TABLE IF EXISTS agents;
+      DROP TABLE IF EXISTS workflow_results;
+      DROP TABLE IF EXISTS session_meta;
+      DROP TABLE IF EXISTS tool_results;
+      DROP TABLE IF EXISTS ingest_state;
+      DROP TABLE IF EXISTS meta;
+    `);
+    applySchema(db);
+  } finally {
+    db.exec("PRAGMA foreign_keys = ON");
+  }
 }
 
 // ../ingest/dist/adapters/claude-code.js
-import { readdirSync as readdirSync2 } from "fs";
-import { basename as basename2, join as join6 } from "path";
+import { readdirSync as readdirSync2 } from "node:fs";
+import { basename as basename2, join as join6 } from "node:path";
 function flattenText(content) {
   if (content == null)
     return null;
@@ -2458,7 +2555,7 @@ function createDirtySet(db, name, ids) {
   db.exec(`DROP TABLE IF EXISTS ${name}`);
   db.exec(`CREATE TEMP TABLE ${name} (id TEXT PRIMARY KEY)`);
   const ins = db.prepare(`INSERT OR IGNORE INTO ${name} (id) VALUES (?)`);
-  db.transaction((xs) => {
+  transaction(db, (xs) => {
     for (const id of xs)
       ins.run(id);
   })(ids);
@@ -2658,7 +2755,7 @@ function classify(db, dirty) {
        category=excluded.category, complexity_score=excluded.complexity_score,
        complexity_band=excluded.complexity_band, signals_json=excluded.signals_json,
        classifier_version=excluded.classifier_version`);
-  const tx = db.transaction(() => {
+  const tx = transaction(db, () => {
     for (const sess of sessions) {
       const toolCounts = toolMix.get(sess.id) ?? {};
       const skills = skillMix.get(sess.id) ?? {};
@@ -2729,8 +2826,8 @@ function classify(db, dirty) {
 }
 
 // ../ingest/dist/detect.js
-import { createHash as createHash2 } from "crypto";
-import { posix as path } from "path";
+import { createHash as createHash2 } from "node:crypto";
+import { posix as path } from "node:path";
 var DETECTOR_VERSION = 8;
 function evidence(s, max = 200) {
   const one = s.replace(/\s+/g, " ").trim();
@@ -3195,7 +3292,7 @@ function detect(db, dirty) {
      VALUES (@id, @session_id, @tool_call_id, @event_uuid, @turn_id, @rule_id, @category, @framework_ref, @severity, @title, @evidence, @signals_json, @detector_version)
      ON CONFLICT(id) DO NOTHING`);
   const delScope = incremental ? "DELETE FROM findings WHERE session_id IN (SELECT id FROM _dirty_sec)" : "DELETE FROM findings";
-  const tx = db.transaction(() => {
+  const tx = transaction(db, () => {
     db.exec(delScope);
     for (const row of rows) {
       const ctx = buildContext(row, projPath.get(row.session_id) ?? null, ownedConfigDirs);
@@ -3255,7 +3352,7 @@ function classifyErrors(db, dirty) {
     createDirtySet(db, "_dirty_err", dirty);
   const rows = db.prepare(`SELECT id, result_summary FROM tool_calls WHERE status = 'error'${scope}`).all();
   const update = db.prepare("UPDATE tool_calls SET error_type = ? WHERE id = ?");
-  const tx = db.transaction(() => {
+  const tx = transaction(db, () => {
     db.exec(`UPDATE tool_calls SET error_type = NULL WHERE error_type IS NOT NULL${scope}`);
     for (const r of rows)
       update.run(classifyToolError(r.result_summary).type, r.id);
@@ -3268,8 +3365,8 @@ function classifyErrors(db, dirty) {
 }
 
 // ../ingest/dist/filechanges.js
-import { createHash as createHash3 } from "crypto";
-import { posix as path2 } from "path";
+import { createHash as createHash3 } from "node:crypto";
+import { posix as path2 } from "node:path";
 var FILECHANGES_VERSION = 1;
 var FILE_TOOLS = ["Edit", "Write", "NotebookEdit"];
 function fileChangeId(toolCallId, filePath) {
@@ -3301,7 +3398,7 @@ function deriveFileChanges(db, dirty) {
     db.exec("DROP TABLE IF EXISTS _dirty_fc");
     db.exec("CREATE TEMP TABLE _dirty_fc (id TEXT PRIMARY KEY)");
     const ins = db.prepare("INSERT OR IGNORE INTO _dirty_fc (id) VALUES (?)");
-    db.transaction((ids) => {
+    transaction(db, (ids) => {
       for (const id of ids)
         ins.run(id);
     })(dirty);
@@ -3318,7 +3415,7 @@ function deriveFileChanges(db, dirty) {
      VALUES (@id, @tool_call_id, @session_id, @turn_id, @event_uuid, @project_id, @file_path, @tool_name, @lines_added, @lines_removed, @timestamp, @derive_version)
      ON CONFLICT(id) DO NOTHING`);
   const delScope = incremental ? "DELETE FROM file_changes WHERE session_id IN (SELECT id FROM _dirty_fc)" : "DELETE FROM file_changes";
-  const tx = db.transaction(() => {
+  const tx = transaction(db, () => {
     db.exec(delScope);
     for (const row of rows) {
       if (row.status === "error")
@@ -3367,10 +3464,10 @@ function deriveFileChanges(db, dirty) {
 }
 
 // ../ingest/dist/canonicalize.js
-import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-import { createHash as createHash4 } from "crypto";
-import { dirname as dirname5, join as join7 } from "path";
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { createHash as createHash4 } from "node:crypto";
+import { dirname as dirname5, join as join7 } from "node:path";
 function projectId(agentId, path3) {
   return createHash4("sha1").update(`${agentId}\0${path3}`).digest("hex").slice(0, 16);
 }
@@ -3426,7 +3523,7 @@ function canonicalizeProjects(db, opts = {}) {
   const repointSessions = db.prepare("UPDATE sessions SET project_id = ? WHERE project_id = ?");
   const repointFileChanges = db.prepare("UPDATE file_changes SET project_id = ? WHERE project_id = ?");
   const touched = /* @__PURE__ */ new Set();
-  db.transaction(() => {
+  transaction(db, () => {
     for (const r of rows) {
       const target = canon(r.path);
       if (target === strip(r.path))
@@ -3450,12 +3547,12 @@ function canonicalizeProjects(db, opts = {}) {
     for (const id of touched)
       refresh.run(id);
   })();
-  const removed = db.prepare("DELETE FROM projects WHERE id NOT IN (SELECT DISTINCT project_id FROM sessions WHERE project_id IS NOT NULL)").run().changes;
+  const removed = Number(db.prepare("DELETE FROM projects WHERE id NOT IN (SELECT DISTINCT project_id FROM sessions WHERE project_id IS NOT NULL)").run().changes);
   return { merged, removed };
 }
 
 // ../ingest/dist/pipeline.js
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash5 } from "node:crypto";
 function newStats() {
   return { files: 0, skipped: 0, malformed: 0, newEvents: 0 };
 }
@@ -3519,20 +3616,23 @@ function pruneExcluded(db, excludedPaths) {
     return 0;
   }
   const files = db.prepare("SELECT DISTINCT source_file f FROM events WHERE session_id IN (SELECT id FROM _prune) AND source_file IS NOT NULL").all().map((r) => r.f);
-  db.pragma("foreign_keys = OFF");
-  db.transaction(() => {
-    db.exec("DELETE FROM findings WHERE session_id IN (SELECT id FROM _prune)");
-    db.exec("DELETE FROM file_changes WHERE session_id IN (SELECT id FROM _prune)");
-    for (const t of ["token_usage", "tool_calls", "turns", "events"])
-      db.exec(`DELETE FROM ${t} WHERE session_id IN (SELECT id FROM _prune)`);
-    db.exec("DELETE FROM classifications WHERE scope = 'session' AND target_id IN (SELECT id FROM _prune)");
-    db.exec("DELETE FROM sessions WHERE id IN (SELECT id FROM _prune)");
-    const delState = db.prepare("DELETE FROM ingest_state WHERE file_path = ?");
-    for (const f of files)
-      delState.run(f);
-    db.exec("DELETE FROM projects WHERE id NOT IN (SELECT DISTINCT project_id FROM sessions WHERE project_id IS NOT NULL)");
-  })();
-  db.pragma("foreign_keys = ON");
+  db.exec("PRAGMA foreign_keys = OFF");
+  try {
+    transaction(db, () => {
+      db.exec("DELETE FROM findings WHERE session_id IN (SELECT id FROM _prune)");
+      db.exec("DELETE FROM file_changes WHERE session_id IN (SELECT id FROM _prune)");
+      for (const t of ["token_usage", "tool_calls", "turns", "events"])
+        db.exec(`DELETE FROM ${t} WHERE session_id IN (SELECT id FROM _prune)`);
+      db.exec("DELETE FROM classifications WHERE scope = 'session' AND target_id IN (SELECT id FROM _prune)");
+      db.exec("DELETE FROM sessions WHERE id IN (SELECT id FROM _prune)");
+      const delState = db.prepare("DELETE FROM ingest_state WHERE file_path = ?");
+      for (const f of files)
+        delState.run(f);
+      db.exec("DELETE FROM projects WHERE id NOT IN (SELECT DISTINCT project_id FROM sessions WHERE project_id IS NOT NULL)");
+    })();
+  } finally {
+    db.exec("PRAGMA foreign_keys = ON");
+  }
   db.exec("DROP TABLE IF EXISTS _prune");
   return total;
 }
@@ -3614,12 +3714,12 @@ function rebuildTurns(db, scope, sessionIds) {
   const insTurn = db.prepare(`INSERT INTO turns (id, session_id, seq, user_event_uuid, prompt_preview, model, started_at, ended_at, duration_ms)
      VALUES (@id, @session_id, @seq, @user_event_uuid, @prompt_preview, @model, @started_at, @ended_at, @duration_ms)`);
   const updEventTurn = db.prepare("UPDATE events SET turn_id = ? WHERE uuid = ?");
-  const tx = db.transaction(() => {
+  const tx = transaction(db, () => {
     for (const { id } of sessionIds) {
       const rows = selEvents.all(id);
       const { turns, eventTurn } = buildTurns(id, rows);
       for (const t of turns)
-        insTurn.run(t);
+        runNamed(insTurn, t);
       for (const [uuid, turnId] of eventTurn)
         updEventTurn.run(turnId, uuid);
     }
@@ -3638,7 +3738,7 @@ function linkSkillVersions(db, sessionIds) {
        first_seen = MIN(first_seen, excluded.first_seen),
        base_dir   = excluded.base_dir`);
   const linkCall = db.prepare("UPDATE tool_calls SET skill_id = ? WHERE id = ?");
-  const linkTx = db.transaction(() => {
+  const linkTx = transaction(db, () => {
     for (const { id: sid } of sessionIds) {
       const calls = selSkillCalls.all(sid);
       if (!calls.length)
@@ -3836,7 +3936,7 @@ function prepareStatements(db) {
 function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
   const sessionMeta = {};
   let eventsInFile = 0;
-  const tx = db.transaction(() => {
+  const tx = transaction(db, () => {
     stmts.insSessionStub.run(file.sessionId, adapter.agentId, file.sourceId);
     let seq = 0;
     for (const line of lines) {
@@ -3860,10 +3960,10 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
         }
       }
       if (parsed.tokenUsage)
-        stmts.insTokens.run(parsed.tokenUsage);
+        runNamed(stmts.insTokens, parsed.tokenUsage);
       if (parsed.toolCalls)
         for (const tc of parsed.toolCalls)
-          stmts.insTool.run(tc);
+          runNamed(stmts.insTool, tc);
       if (parsed.toolResults)
         for (const tr of parsed.toolResults)
           stmts.patchTool.run({
@@ -3917,14 +4017,13 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
 }
 
 // ../ingest/dist/workflows.js
-import { basename as basename3 } from "path";
+import { basename as basename3 } from "node:path";
 
 // ../ingest/dist/sidecar.js
-import { readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { join as join8 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // ../ingest/dist/redact.js
-import { createHash as createHash6, randomBytes } from "crypto";
 function parseExcludes(csv) {
   return (csv ?? "").split(",").map((s) => s.trim()).filter(Boolean).map(encodeProjectPath);
 }
@@ -3933,17 +4032,17 @@ function isExcludedArchivePath(filePath, excluded) {
 }
 
 // ../ingest/dist/fileread.js
-import { createHash as createHash7 } from "crypto";
-import { openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "fs";
-import { StringDecoder } from "string_decoder";
+import { createHash as createHash6 } from "node:crypto";
+import { openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 var STREAM_THRESHOLD = 8 * 1024 * 1024;
 var CHUNK2 = 64 * 1024;
 function sha256(buf) {
-  return createHash7("sha256").update(buf).digest("hex");
+  return createHash6("sha256").update(buf).digest("hex");
 }
 function sha256File(path3) {
   const fd = openSync2(path3, "r");
-  const h = createHash7("sha256");
+  const h = createHash6("sha256");
   const buf = Buffer.allocUnsafe(CHUNK2);
   try {
     let n;
@@ -4136,7 +4235,7 @@ function ingestWorkflowResults(db, sourceArchiveDir, sourceId, excludedDirs, now
 }
 
 // ../ingest/dist/meta.js
-import { basename as basename4 } from "path";
+import { basename as basename4 } from "node:path";
 var newMetaStats = newSidecarStats;
 function ingestSubagentMeta(db, sourceArchiveDir, sourceId, excludedDirs, now2, stats, full) {
   const upsert = db.prepare(`INSERT INTO session_meta
@@ -4175,7 +4274,7 @@ function ingestSubagentMeta(db, sourceArchiveDir, sourceId, excludedDirs, now2,
 }
 
 // ../ingest/dist/toolResults.js
-import { basename as basename5 } from "path";
+import { basename as basename5 } from "node:path";
 var newToolResultStats = newSidecarStats;
 function ingestToolResults(db, sourceArchiveDir, excludedDirs, now2, stats, full) {
   const upsert = db.prepare(`INSERT INTO tool_results (session_id, name, path, bytes, text, ingested_at)
@@ -4235,10 +4334,16 @@ function printIngestReport(db, dbPath, r) {
   const usageRows = db.prepare("SELECT model, input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens FROM token_usage").all();
   let cost = 0;
   let totalTokens = 0;
+  const unpriced2 = /* @__PURE__ */ new Map();
   for (const u of usageRows) {
     cost += costForUsage(u.model, u);
     totalTokens += u.input_tokens + u.output_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens;
+    if (u.model && u.model !== SYNTHETIC_MODEL && !rateForModel(u.model)) {
+      unpriced2.set(u.model, (unpriced2.get(u.model) ?? 0) + 1);
+    }
   }
+  const unpricedLine = unpriced2.size ? `
+  unpriced=${unpriced2.size} model(s): ` + [...unpriced2].map(([m, n]) => `${m} (${n} records)`).join(", ") + ` \u2014 cost above excludes them; add rates under "pricing" in agent-lens.config.json` : "";
   const wfRuns = count("SELECT COUNT(*) n FROM workflow_results");
   const metaRows = count("SELECT COUNT(*) n FROM session_meta");
   const trRows = count("SELECT COUNT(*) n FROM tool_results");
@@ -4253,12 +4358,13 @@ function printIngestReport(db, dbPath, r) {
   tool_results=${trRows} (upserted=${r.trStats.upserted} skipped=${r.trStats.skipped} malformed=${r.trStats.malformed})
   findings=${r.detected.count} (${sevLine})
   file_changes=${r.fileChanges.count}
-  tokens=${totalTokens.toLocaleString()} est_cost=$${cost.toFixed(2)} db=${dbPath}`);
+  tokens=${totalTokens.toLocaleString()} est_cost=$${cost.toFixed(2)} db=${dbPath}` + unpricedLine);
 }
 function runIngest(argv = process.argv.slice(2)) {
   const args = parseIngestArgs(argv);
   const archiveRoot = args.archive || resolveArchiveDir();
   const { path: dbPath } = resolveDbPath(args.db);
+  installPricing();
   if (!existsSync5(archiveRoot)) {
     console.error(`agent-lens-ingest: archive not found: ${archiveRoot} (run 'agent-lens collect' first)`);
     process.exit(1);
@@ -4359,22 +4465,23 @@ function runMetrics(argv = process.argv.slice(2)) {
 }
 
 // ../server/dist/run.js
-import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname7 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync8 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../server/dist/db.js
-import Database2 from "better-sqlite3";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
 // ../server/dist/sql-util.js
+var bind = (params) => params;
 function tableExists(db, name) {
   return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?").get(name);
 }
 function queryAll(db, sql, ...params) {
-  return db.prepare(sql).all(...params);
+  return db.prepare(sql).all(...bind(params));
 }
 function queryGet(db, sql, ...params) {
-  return db.prepare(sql).get(...params);
+  return db.prepare(sql).get(...bind(params));
 }
 function pushDateRange(clauses, params, col, from, to) {
   if (from) {
@@ -4432,6 +4539,9 @@ function splitOf(rows) {
 function tokensOf(split) {
   return split.input + split.output + split.cache_creation + split.cache_read;
 }
+function unpricedOf(rows) {
+  return unpricedModels(rows.filter((u) => u.i || u.o || u.cw || u.cr).map((u) => u.model));
+}
 function costOf(rows) {
   let cost = 0;
   for (const u of rows) {
@@ -4447,8 +4557,8 @@ function costOf(rows) {
 
 // ../server/dist/db.js
 function openReadonly(file) {
-  const db = new Database2(file, { readonly: true, fileMustExist: true });
-  db.pragma("query_only = ON");
+  const db = new DatabaseSync2(file, { readOnly: true });
+  db.exec("PRAGMA query_only = ON");
   return db;
 }
 function schemaStatus(db) {
@@ -4496,6 +4606,32 @@ function listModels(db) {
 function toFtsQuery(raw) {
   return raw.trim().split(/\s+/).filter(Boolean).map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
 }
+var TOKENS_SORT_SQL = `(SELECT COALESCE(SUM(t.input_tokens + t.output_tokens
+      + t.cache_creation_input_tokens + t.cache_read_input_tokens), 0)
+    FROM token_usage t WHERE t.session_id = s.id)`;
+var SECURITY_SORT_SQL = `(CASE worst_severity
+      WHEN 'critical' THEN 5 WHEN 'high' THEN 4 WHEN 'medium' THEN 3 WHEN 'low' THEN 2 WHEN 'info' THEN 1
+      ELSE 0 END) * 1000000 + finding_count`;
+var COST_SORT_SQL = `(SELECT COALESCE(SUM((tu.input_tokens * mr.i_rate + tu.output_tokens * mr.o_rate
+      + tu.cache_creation_input_tokens * mr.cw_rate + tu.cache_read_input_tokens * mr.cr_rate) / 1000000.0), 0)
+    FROM token_usage tu LEFT JOIN model_rate mr ON mr.model IS tu.model
+    WHERE tu.session_id = s.id)`;
+function ratesCte() {
+  const entries = Object.entries(activePricing());
+  return {
+    // `model_rate` resolves the prefix match ONCE per distinct model id, not once per token_usage row.
+    // Inlining the lookup into the cost expression instead re-ran it for every usage row of every
+    // candidate session — ~35× slower on a real corpus, which would have made this "fix" a regression.
+    sql: `WITH rates(prefix, i_rate, o_rate, cw_rate, cr_rate) AS (VALUES ${entries.map(() => "(?,?,?,?,?)").join(",")}),
+      model_rate AS (
+        SELECT m.model, r.i_rate, r.o_rate, r.cw_rate, r.cr_rate
+        FROM (SELECT DISTINCT model FROM token_usage) m
+        LEFT JOIN rates r ON r.prefix = (
+          SELECT p.prefix FROM rates p WHERE substr(m.model, 1, length(p.prefix)) = p.prefix
+          ORDER BY length(p.prefix) DESC LIMIT 1)) `,
+    params: entries.flatMap(([prefix, r]) => [prefix, r.input, r.output, r.cacheWrite, r.cacheRead])
+  };
+}
 function listSessions(db, f) {
   const where = [];
   const params = [];
@@ -4540,41 +4676,19 @@ function listSessions(db, f) {
                  LIMIT 1) AS worst_severity
        FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
        ${whereSql}`;
-  const NATIVE_ORDER = {
+  const ORDER = {
     started: "s.started_at",
     title: "COALESCE(s.ai_title, s.slug)",
     turns: "s.turn_count",
-    duration: "s.duration_ms"
+    duration: "s.duration_ms",
+    errors: "tool_error_count",
+    tokens: TOKENS_SORT_SQL,
+    cost: COST_SORT_SQL,
+    security: SECURITY_SORT_SQL
   };
   const sortKey = f.sort ?? "started";
-  const JS_SORT = /* @__PURE__ */ new Set(["tokens", "cost", "errors", "security"]);
-  let sessions;
-  if (JS_SORT.has(sortKey)) {
-    const all = attachSessionCost(db, queryAll(db, baseSelect, ...params));
-    const sign = f.dir === "asc" ? 1 : -1;
-    const metric = (r) => {
-      switch (sortKey) {
-        case "tokens":
-          return r.tokens;
-        case "cost":
-          return r.cost;
-        case "errors":
-          return r.tool_error_count ?? 0;
-        // Security: rank by worst severity (info=0 … critical=4; none = -1), finding count as tiebreak.
-        case "security":
-          return (severityRank(r.worst_severity ?? "") + 1) * 1e6 + (r.finding_count ?? 0);
-        default:
-          return 0;
-      }
-    };
-    all.sort((a, b) => {
-      const c = (metric(a) - metric(b)) * sign;
-      return c !== 0 ? c : String(a.id).localeCompare(String(b.id));
-    });
-    sessions = all.slice(f.offset, f.offset + f.limit);
-  } else {
-    sessions = attachSessionCost(db, queryAll(db, `${baseSelect} ORDER BY ${orderBy(NATIVE_ORDER, sortKey, "started", f.dir)}, s.id ASC LIMIT ? OFFSET ?`, ...params, f.limit, f.offset));
-  }
+  const rates = sortKey === "cost" ? ratesCte() : null;
+  const sessions = attachSessionCost(db, queryAll(db, `${rates?.sql ?? ""}${baseSelect} ORDER BY ${orderBy(ORDER, sortKey, "started", f.dir)}, s.id ASC LIMIT ? OFFSET ?`, ...rates?.params ?? [], ...params, f.limit, f.offset));
   return { total, sessions };
 }
 function attachSessionCost(db, rows) {
@@ -4594,7 +4708,14 @@ function attachSessionCost(db, rows) {
   return rows.map(({ ai_title, slug, ...r }) => {
     const u = usageBySession.get(r.id) ?? [];
     const split = splitOf(u);
-    return { ...r, tokens: tokensOf(split), token_split: split, cost: costOf(u), title: ai_title || slug || null };
+    return {
+      ...r,
+      tokens: tokensOf(split),
+      token_split: split,
+      cost: costOf(u),
+      unpriced_models: unpricedOf(u),
+      title: ai_title || slug || null
+    };
   });
 }
 function loadToolCalls(db, id) {
@@ -4739,6 +4860,7 @@ function withSessionTotals(db, session, id, toolRows) {
     tokens: tokensOf(split),
     token_split: split,
     cost: costOf(usage),
+    unpriced_models: unpricedOf(usage),
     title: session.ai_title || session.slug || null,
     tool_call_count: toolRows.length,
     tool_error_count,
@@ -5129,7 +5251,7 @@ function securitySummary(db) {
 }
 
 // ../server/dist/app.js
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync7 } from "node:fs";
 import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 
@@ -5187,11 +5309,18 @@ var usageForCost = (u) => ({
   cache_creation_input_tokens: u.cw ?? 0,
   cache_read_input_tokens: u.cr ?? 0
 });
-function pct(sorted, p) {
-  if (sorted.length === 0)
-    return 0;
-  const rank = Math.ceil(p / 100 * sorted.length) - 1;
-  return sorted[Math.min(Math.max(rank, 0), sorted.length - 1)];
+function percentiles(db, values, params) {
+  const at = (p) => `(SELECT COALESCE((SELECT v FROM vals ORDER BY v
+        LIMIT 1 OFFSET MAX(0, CAST(ceil(${p} / 100.0 * (SELECT c FROM n)) AS INTEGER) - 1)), 0))`;
+  const row = queryGet(
+    db,
+    // MATERIALIZED matters: the three selects below each reference `vals`, and without the hint
+    // SQLite inlines the CTE and re-runs the underlying scan once per percentile.
+    `WITH vals AS MATERIALIZED (${values}), n AS (SELECT COUNT(*) c FROM vals)
+     SELECT ${at(50)} AS p50, ${at(95)} AS p95, (SELECT c FROM n) AS count`,
+    ...params
+  );
+  return row ?? { p50: 0, p95: 0, count: 0 };
 }
 function workflowWhere(f) {
   const where = [];
@@ -5250,18 +5379,18 @@ function dashboardOverview(db, f) {
      GROUP BY t.model`, ...w.params);
   const tokens = zeroSplit();
   let cost = 0;
-  const unpriced = [];
+  const unpriced2 = [];
   for (const u of usage) {
     addUsage(tokens, u);
     cost += costForUsage(u.model, usageForCost(u));
     if (u.model && !rateForModel(u.model) && (u.i || u.o || u.cw || u.cr))
-      unpriced.push(u.model);
+      unpriced2.push(u.model);
   }
   const totalTokens = tokens.input + tokens.output + tokens.cache_creation + tokens.cache_read;
-  const durs = queryAll(db, `SELECT tn.duration_ms d FROM turns tn JOIN sessions s ON s.id = tn.session_id
-     ${w.sql ? w.sql + " AND" : "WHERE"} tn.duration_ms IS NOT NULL ORDER BY tn.duration_ms`, ...w.params).map((r) => r.d);
-  const sessDurs = queryAll(db, `SELECT s.duration_ms d FROM sessions s
-     ${w.sql ? w.sql + " AND" : "WHERE"} s.is_sidechain = 0 AND s.duration_ms IS NOT NULL ORDER BY s.duration_ms`, ...w.params).map((r) => r.d);
+  const turnDur = percentiles(db, `SELECT tn.duration_ms v FROM turns tn JOIN sessions s ON s.id = tn.session_id
+     ${w.sql ? w.sql + " AND" : "WHERE"} tn.duration_ms IS NOT NULL`, w.params);
+  const sessDur = percentiles(db, `SELECT s.duration_ms v FROM sessions s
+     ${w.sql ? w.sql + " AND" : "WHERE"} s.is_sidechain = 0 AND s.duration_ms IS NOT NULL`, w.params);
   return {
     range: { from: f.from ?? null, to: f.to ?? null, source: f.source ?? null },
     sessions: counts.sessions ?? 0,
@@ -5275,9 +5404,9 @@ function dashboardOverview(db, f) {
     total_tokens: totalTokens,
     cache_read_ratio: totalTokens ? tokens.cache_read / totalTokens : 0,
     cost: Number(cost.toFixed(4)),
-    unpriced_models: [...new Set(unpriced)].sort(),
-    turn_duration_ms: { p50: pct(durs, 50), p95: pct(durs, 95), count: durs.length },
-    session_duration_ms: { p50: pct(sessDurs, 50), p95: pct(sessDurs, 95), count: sessDurs.length },
+    unpriced_models: [...new Set(unpriced2)].sort(),
+    turn_duration_ms: turnDur,
+    session_duration_ms: sessDur,
     workflows: workflowAgg(db, f)
   };
 }
@@ -5442,8 +5571,8 @@ function dashboardBreakdowns(db, f) {
 }
 
 // ../server/dist/refresh.js
-import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "node:fs";
+import { join as join10 } from "node:path";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 function originAllowed(origin) {
   if (!origin)
@@ -5480,7 +5609,7 @@ function runRefresh() {
 }
 
 // ../server/dist/triage.js
-import Database3 from "better-sqlite3";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 var TRIAGE_SCHEMA_SQL = (
   /* sql */
   `
@@ -5508,8 +5637,8 @@ CREATE TABLE IF NOT EXISTS muted_rules (
 `
 );
 function openTriage(file) {
-  const db = new Database3(file);
-  db.pragma("journal_mode = WAL");
+  const db = new DatabaseSync3(file);
+  db.exec("PRAGMA journal_mode = WAL");
   db.exec(TRIAGE_SCHEMA_SQL);
   return db;
 }
@@ -5518,7 +5647,7 @@ function dismiss(db, ids, note) {
   const stmt = db.prepare(`INSERT INTO dismissed_findings (finding_id, note, dismissed_at) VALUES (?, ?, ?)
      ON CONFLICT(finding_id) DO UPDATE SET note = excluded.note, dismissed_at = excluded.dismissed_at`);
   const ts = now();
-  const tx = db.transaction((list) => {
+  const tx = transaction(db, (list) => {
     for (const id of list)
       stmt.run(id, note ?? null, ts);
   });
@@ -5528,9 +5657,9 @@ function dismiss(db, ids, note) {
 function reopen(db, ids) {
   const stmt = db.prepare("DELETE FROM dismissed_findings WHERE finding_id = ?");
   let n = 0;
-  const tx = db.transaction((list) => {
+  const tx = transaction(db, (list) => {
     for (const id of list)
-      n += stmt.run(id).changes;
+      n += Number(stmt.run(id).changes);
   });
   tx(ids);
   return n;
@@ -5540,14 +5669,14 @@ function muteRule(db, ruleId, scope = "global", scopeId = "", note) {
      ON CONFLICT(rule_id, scope, scope_id) DO UPDATE SET note = excluded.note, muted_at = excluded.muted_at`).run(ruleId, scope, scope === "global" ? "" : scopeId, note ?? null, now());
 }
 function unmute(db, ruleId, scope = "global", scopeId = "") {
-  return db.prepare("DELETE FROM muted_rules WHERE rule_id = ? AND scope = ? AND scope_id = ?").run(ruleId, scope, scope === "global" ? "" : scopeId).changes;
+  return Number(db.prepare("DELETE FROM muted_rules WHERE rule_id = ? AND scope = ? AND scope_id = ?").run(ruleId, scope, scope === "global" ? "" : scopeId).changes);
 }
 function listMutes(db) {
   return db.prepare("SELECT rule_id, scope, scope_id, note, muted_at FROM muted_rules ORDER BY muted_at DESC").all();
 }
 
 // ../server/dist/about.js
-import { statSync as statSync4 } from "fs";
+import { statSync as statSync4 } from "node:fs";
 function storage(db, dbPath) {
   const row = tableExists(db, "ingest_state") ? queryGet(db, "SELECT COUNT(*) files, SUM(size) bytes, MAX(ingested_at) last FROM ingest_state") : void 0;
   let db_bytes = null;
@@ -5564,6 +5693,13 @@ function storage(db, dbPath) {
     last_ingested: row?.last ?? null
   };
 }
+function unpriced(db) {
+  if (!tableExists(db, "token_usage"))
+    return [];
+  const rows = queryAll(db, `SELECT DISTINCT model FROM token_usage
+      WHERE input_tokens + output_tokens + cache_creation_input_tokens + cache_read_input_tokens > 0`);
+  return unpricedModels(rows.map((r) => r.model));
+}
 function engineVersion(db, table, sql, expected) {
   const in_data = tableExists(db, table) ? queryAll(db, sql).map((r) => r.v).filter((v) => Number.isFinite(v)) : [];
   return { expected, in_data, stale: in_data.some((v) => v < expected) };
@@ -5594,6 +5730,13 @@ function about(db, ctx) {
     },
     server: { host: ctx.host, port: ctx.port, loopback_only: ctx.loopbackOnly },
     retention: { versions_keep_days: retention.keepDays, origin: retention.origin },
+    pricing: {
+      origin: ctx.pricing.origin,
+      models: Object.keys(ctx.pricing.table).length,
+      applied: ctx.pricing.applied,
+      invalid: ctx.pricing.invalid,
+      unpriced: unpriced(db)
+    },
     sources: loadSources().map((s) => ({ label: s.label, agent: s.agent, config_dir: s.configDir })),
     // storage() already carries last_ingested from the same MAX(ingested_at) it aggregates over —
     // reusing it avoids a second query AND keeps the tableExists guard that lastIngested() lacks.
@@ -5886,6 +6029,7 @@ async function startServer(overrides = {}) {
   const repoRoot = findRepoRoot(here);
   const { path: dbPath, origin: dbOrigin } = resolveDbPath(overrides.db);
   const { host, port } = resolveServerConfig({ port: overrides.port, host: overrides.host });
+  const pricing = installPricing();
   const webDist = resolveWebDist(here, repoRoot);
   if (host !== "127.0.0.1" && host !== "localhost" && !process.env.AGENT_LENS_ALLOW_NONLOCAL) {
     console.error(`agent-lens-server: refusing to bind non-loopback host '${host}' (privacy). Set AGENT_LENS_ALLOW_NONLOCAL=1 to override.`);
@@ -5902,7 +6046,7 @@ async function startServer(overrides = {}) {
     webDist,
     triageDbPath,
     enforceLoopbackHost,
-    about: { db: { path: dbPath, origin: dbOrigin }, host, port, loopbackOnly: enforceLoopbackHost, repoRoot }
+    about: { db: { path: dbPath, origin: dbOrigin }, host, port, loopbackOnly: enforceLoopbackHost, repoRoot, pricing }
   });
   try {
     await app.listen({ host, port });
@@ -5916,8 +6060,8 @@ async function startServer(overrides = {}) {
 }
 
 // src/watch.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join11 } from "node:path";
 import chokidar from "chokidar";
 async function runWatch(opts = {}) {
   const sources = loadSources();
@@ -6070,6 +6214,7 @@ cli.command("config", "Show the effective configuration (sources, paths, server)
   const archive = resolveArchiveDir(repoRoot);
   const triageDb = triageDbFor(dbPath);
   const { keepDays, origin: keepOrigin } = resolveRetention();
+  const pricing = resolvePricing();
   console.log("agent-lens config (precedence: flag > env > config file > default)\n");
   console.log("Paths");
   console.log(`  config file      ${configFile ?? "(none \u2014 using built-in default source)"}`);
@@ -6083,6 +6228,10 @@ cli.command("config", "Show the effective configuration (sources, paths, server)
   console.log(`  non-local bind   ${process.env.AGENT_LENS_ALLOW_NONLOCAL ? "allowed (AGENT_LENS_ALLOW_NONLOCAL)" : "blocked (loopback only)"}`);
   console.log("\nRetention");
   console.log(`  .versions keep   ${keepDays} day(s)  [${keepOrigin}]`);
+  console.log("\nPricing");
+  console.log(`  models priced    ${Object.keys(pricing.table).length}  [${pricing.origin}]`);
+  if (pricing.applied.length) console.log(`  overrides        ${pricing.applied.join(", ")}`);
+  if (pricing.invalid.length) console.log(`  ignored (bad)    ${pricing.invalid.join(", ")}`);
   console.log("\nSources");
   for (const s of loadSources()) console.log(`  ${s.label.padEnd(14)} ${s.configDir}  (${s.agent})`);
 });