@swestash/agent-lens 0.9.6 → 0.11.0

package/dist/agent-lens.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname7, join as join11 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync10, writeFileSync as writeFileSync3 } from "fs";
+import { join as join12 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // ../../node_modules/.pnpm/cac@6.7.14/node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -107,7 +107,7 @@ var findAllBrackets = (v) => {
   const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
   const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
   const res = [];
-  const parse = (match) => {
+  const parse2 = (match) => {
     let variadic = false;
     let value = match[1];
     if (value.startsWith("...")) {
@@ -122,11 +122,11 @@ var findAllBrackets = (v) => {
   };
   let angledMatch;
   while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
-    res.push(parse(angledMatch));
+    res.push(parse2(angledMatch));
   }
   let squareMatch;
   while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
-    res.push(parse(squareMatch));
+    res.push(parse2(squareMatch));
   }
   return res;
 };
@@ -1242,6 +1242,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 +1259,65 @@ 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 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 };
     }
@@ -1377,6 +1434,24 @@ import { join as join2 } from "path";
 var DEFAULT_PORT = 4477;
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_DB_NAME = "agent-lens.db";
+var DEFAULT_VERSIONS_KEEP_DAYS = 90;
+function resolveRetention() {
+  const raw = process.env.AGENT_LENS_VERSIONS_KEEP_DAYS;
+  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);
@@ -1436,6 +1511,59 @@ function resolveServerConfig(overrides = {}, cfg = readConfigFile()) {
   return { port, host, portOrigin, hostOrigin };
 }
 
+// ../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";
+var moduleDir2 = dirname2(fileURLToPath2(import.meta.url));
+function isPlaceholder(v) {
+  return v.startsWith("0.0.0");
+}
+function nearestPackageVersion(dir) {
+  const { root } = parse(dir);
+  for (let d = dir; ; d = dirname2(d)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(join3(d, "package.json"), "utf8"));
+      if (typeof pkg.version === "string" && pkg.version)
+        return pkg.version;
+    } catch {
+    }
+    if (d === root)
+      return null;
+  }
+}
+function gitDescribe(cwd) {
+  try {
+    const r = spawnSync("git", ["describe", "--tags", "--always", "--dirty"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (r.status !== 0)
+      return null;
+    const out = r.stdout?.trim();
+    return out ? out : null;
+  } catch {
+    return null;
+  }
+}
+function computeVersion(fromDir = moduleDir2) {
+  const pkg = nearestPackageVersion(fromDir);
+  if (pkg && !isPlaceholder(pkg))
+    return { version: pkg, source: "npm" };
+  const described = gitDescribe(fromDir);
+  if (described)
+    return { version: described, source: "git" };
+  return { version: "unknown", source: "unknown" };
+}
+var cached = null;
+function resolveVersion() {
+  if (!cached)
+    cached = computeVersion();
+  return cached;
+}
+
 // ../core/dist/sources.js
 function loadSources() {
   if (process.env.CLAUDE_DIR) {
@@ -1490,7 +1618,7 @@ 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 dirname2, join as join3, relative, sep } from "path";
+import { basename, dirname as dirname3, join as join4, relative, sep } from "path";
 import { platform as platform2 } from "os";
 var POSIX = platform2() !== "win32";
 var DIR_MODE = 448;
@@ -1516,7 +1644,7 @@ function syncMeta(dst, src) {
   }
 }
 function copyWhole(src, dst, srcStat) {
-  ensureDir(dirname2(dst));
+  ensureDir(dirname3(dst));
   copyFileSync(src, dst);
   syncMeta(dst, srcStat);
 }
@@ -1570,27 +1698,27 @@ function filesEqual(a, b) {
   return prefixEquals(a, b, sa.size);
 }
 function latestSnapshot(archive, relParts) {
-  const versRoot = join3(archive, ".versions");
+  const versRoot = join4(archive, ".versions");
   if (!existsSync2(versRoot))
     return null;
   const stamps = readdirSync(versRoot).sort();
   for (let i = stamps.length - 1; i >= 0; i--) {
-    const p = join3(versRoot, stamps[i], ...relParts);
+    const p = join4(versRoot, stamps[i], ...relParts);
     if (existsSync2(p))
       return p;
   }
   return null;
 }
 function snapshot(absPath, relParts, versionsDir, stats) {
-  const dst = join3(versionsDir, ...relParts);
-  ensureDir(dirname2(dst));
+  const dst = join4(versionsDir, ...relParts);
+  ensureDir(dirname3(dst));
   copyFileSync(absPath, dst);
   syncMeta(dst, statSync(absPath));
   stats.snapshots++;
 }
 function walkCollectable(dir, out, inWorkflows = false, inToolResults = false) {
   for (const e of readdirSync(dir, { withFileTypes: true })) {
-    const p = join3(dir, e.name);
+    const p = join4(dir, e.name);
     if (e.isDirectory()) {
       walkCollectable(p, out, inWorkflows || e.name === "workflows", inToolResults || e.name === "tool-results");
     } else if (e.isFile() && (e.name.endsWith(".jsonl") || inWorkflows || inToolResults || e.name.endsWith(".meta.json"))) {
@@ -1631,7 +1759,7 @@ function removeCredentials(dir) {
   if (!existsSync2(dir))
     return;
   for (const e of readdirSync(dir, { withFileTypes: true })) {
-    const p = join3(dir, e.name);
+    const p = join4(dir, e.name);
     if (e.isDirectory())
       removeCredentials(p);
     else if (e.name === ".credentials.json") {
@@ -1644,19 +1772,19 @@ function removeCredentials(dir) {
 }
 function collectSource(source, archiveBase, excludedDirs, runTs, stats, log) {
   const { label, configDir } = source;
-  const archive = join3(archiveBase, label);
-  const versionsDir = join3(archive, ".versions", runTs);
+  const archive = join4(archiveBase, label);
+  const versionsDir = join4(archive, ".versions", runTs);
   if (!existsSync2(configDir)) {
     log(`agent-lens: [${label}] source not found: ${configDir} (skipping)`);
     return;
   }
-  ensureDir(join3(archive, "projects"));
-  ensureDir(join3(archive, "settings"));
+  ensureDir(join4(archive, "projects"));
+  ensureDir(join4(archive, "settings"));
   const files = [];
-  const projectsDir = join3(configDir, "projects");
+  const projectsDir = join4(configDir, "projects");
   if (existsSync2(projectsDir))
     walkCollectable(projectsDir, files);
-  const historySrc = join3(configDir, "history.jsonl");
+  const historySrc = join4(configDir, "history.jsonl");
   if (existsSync2(historySrc))
     files.push(historySrc);
   const before = { scanned: stats.scanned, snapshots: stats.snapshots };
@@ -1669,16 +1797,16 @@ function collectSource(source, archiveBase, excludedDirs, runTs, stats, log) {
     if (excludedDirs.some((enc) => relPosix.startsWith(`projects/${enc}/`)))
       continue;
     stats.scanned++;
-    syncFile(src, join3(archive, ...relParts), relParts, archive, versionsDir, stats, base.endsWith(".jsonl"));
+    syncFile(src, join4(archive, ...relParts), relParts, archive, versionsDir, stats, base.endsWith(".jsonl"));
   }
   for (const f of ["settings.json", "settings.local.json"]) {
-    const s = join3(configDir, f);
+    const s = join4(configDir, f);
     if (!existsSync2(s))
       continue;
-    const a = join3(archive, "settings", f);
+    const a = join4(archive, "settings", f);
     if (existsSync2(a) && !filesEqual(s, a))
       snapshot(a, ["settings", f], versionsDir, stats);
-    ensureDir(dirname2(a));
+    ensureDir(dirname3(a));
     copyFileSync(s, a);
     syncMeta(a, statSync(s));
   }
@@ -1688,7 +1816,7 @@ function collectSource(source, archiveBase, excludedDirs, runTs, stats, log) {
   const line = `${(/* @__PURE__ */ new Date()).toISOString()} run=${runTs} source=${label} scanned=${scanned} snapshots=${snapshots} archive=${archive}`;
   log(`agent-lens: ${line}`);
   try {
-    appendFileSync(join3(archiveBase, ".collect.log"), line + "\n");
+    appendFileSync(join4(archiveBase, ".collect.log"), line + "\n");
   } catch {
   }
 }
@@ -1710,8 +1838,8 @@ function collectAll(opts = {}) {
 }
 
 // ../core/dist/lock.js
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { dirname as dirname3 } from "path";
+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";
 function isAlive(pid) {
   if (!pid)
@@ -1724,10 +1852,10 @@ function isAlive(pid) {
   }
 }
 function acquireLock(lockPath, staleMs = 6 * 60 * 60 * 1e3) {
-  mkdirSync2(dirname3(lockPath), { recursive: true });
+  mkdirSync2(dirname4(lockPath), { recursive: true });
   if (existsSync3(lockPath)) {
     try {
-      const held = JSON.parse(readFileSync3(lockPath, "utf8"));
+      const held = JSON.parse(readFileSync4(lockPath, "utf8"));
       const fresh = typeof held.ts === "number" && Date.now() - held.ts < staleMs;
       if (fresh && isAlive(held.pid ?? 0))
         return null;
@@ -1741,7 +1869,7 @@ function acquireLock(lockPath, staleMs = 6 * 60 * 60 * 1e3) {
       return;
     released = true;
     try {
-      const cur = JSON.parse(readFileSync3(lockPath, "utf8"));
+      const cur = JSON.parse(readFileSync4(lockPath, "utf8"));
       if (cur.pid === process.pid)
         unlinkSync2(lockPath);
     } catch {
@@ -1752,10 +1880,10 @@ function acquireLock(lockPath, staleMs = 6 * 60 * 60 * 1e3) {
 }
 
 // ../core/dist/service.js
-import { spawnSync } from "child_process";
+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 join4 } from "path";
+import { join as join5 } from "path";
 var DEFAULT_HOURS = [9, 13, 17, 21];
 function currentUser() {
   try {
@@ -1897,15 +2025,15 @@ ${envDict}  <key>RunAtLoad</key><true/>
 `;
 }
 function sh(cmd, args, quiet = false) {
-  const r = spawnSync(cmd, args, { stdio: quiet ? "ignore" : "inherit", encoding: "utf8" });
+  const r = spawnSync2(cmd, args, { stdio: quiet ? "ignore" : "inherit", encoding: "utf8" });
   return r.status === 0;
 }
 function have(cmd) {
-  const r = spawnSync(cmd, ["--version"], { stdio: "ignore" });
+  const r = spawnSync2(cmd, ["--version"], { stdio: "ignore" });
   return r.status === 0 || r.error === void 0;
 }
 function systemdUnitDir() {
-  return join4(process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config"), "systemd", "user");
+  return join5(process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config"), "systemd", "user");
 }
 function linuxInstall(targets, node, cli2, hours) {
   if (!have("systemctl")) {
@@ -1916,11 +2044,11 @@ function linuxInstall(targets, node, cli2, hours) {
   const dir = systemdUnitDir();
   mkdirSync3(dir, { recursive: true });
   if (targets.includes("collector")) {
-    writeFileSync2(join4(dir, SYSTEMD_COLLECTOR_SERVICE), systemdCollectorService(node, cli2));
-    writeFileSync2(join4(dir, SYSTEMD_COLLECTOR_TIMER), systemdCollectorTimer(hours));
+    writeFileSync2(join5(dir, SYSTEMD_COLLECTOR_SERVICE), systemdCollectorService(node, cli2));
+    writeFileSync2(join5(dir, SYSTEMD_COLLECTOR_TIMER), systemdCollectorTimer(hours));
   }
   if (targets.includes("server")) {
-    writeFileSync2(join4(dir, SYSTEMD_SERVER_SERVICE), systemdServerService(node, cli2, serverEnv()));
+    writeFileSync2(join5(dir, SYSTEMD_SERVER_SERVICE), systemdServerService(node, cli2, serverEnv()));
   }
   sh("systemctl", ["--user", "daemon-reload"]);
   if (targets.includes("collector")) {
@@ -1945,12 +2073,12 @@ function linuxUninstall(targets) {
   if (targets.includes("collector")) {
     sh("systemctl", ["--user", "disable", "--now", SYSTEMD_COLLECTOR_TIMER], true);
     for (const u of [SYSTEMD_COLLECTOR_TIMER, SYSTEMD_COLLECTOR_SERVICE])
-      rmSync(join4(dir, u), { force: true });
+      rmSync(join5(dir, u), { force: true });
     sh("systemctl", ["--user", "reset-failed", SYSTEMD_COLLECTOR_SERVICE], true);
   }
   if (targets.includes("server")) {
     sh("systemctl", ["--user", "disable", "--now", SYSTEMD_SERVER_SERVICE], true);
-    rmSync(join4(dir, SYSTEMD_SERVER_SERVICE), { force: true });
+    rmSync(join5(dir, SYSTEMD_SERVER_SERVICE), { force: true });
     sh("systemctl", ["--user", "reset-failed", SYSTEMD_SERVER_SERVICE], true);
   }
   sh("systemctl", ["--user", "daemon-reload"]);
@@ -1965,7 +2093,7 @@ function linuxStatus(targets) {
     sh("systemctl", ["--user", "status", SYSTEMD_SERVER_SERVICE, "--no-pager"]);
 }
 function launchdPlistPath(label) {
-  return join4(homedir2(), "Library", "LaunchAgents", `${label}.plist`);
+  return join5(homedir2(), "Library", "LaunchAgents", `${label}.plist`);
 }
 function macBootstrap(plist) {
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
@@ -1979,18 +2107,18 @@ function macBootout(label, plist) {
   rmSync(plist, { force: true });
 }
 function macInstall(targets, node, cli2, hours) {
-  const agents = join4(homedir2(), "Library", "LaunchAgents");
+  const agents = join5(homedir2(), "Library", "LaunchAgents");
   mkdirSync3(agents, { recursive: true });
   const dataDir = resolveDataDir(findRepoRoot());
   if (targets.includes("collector")) {
     const plist = launchdPlistPath(LAUNCHD_COLLECTOR_LABEL);
-    writeFileSync2(plist, launchdCollectorPlist(node, cli2, hours, join4(dataDir, "schedule.log")));
+    writeFileSync2(plist, launchdCollectorPlist(node, cli2, hours, join5(dataDir, "schedule.log")));
     macBootstrap(plist);
     console.log(`agent-lens service: installed collector agent ${LAUNCHD_COLLECTOR_LABEL} (hours ${hours.join(",")})`);
   }
   if (targets.includes("server")) {
     const plist = launchdPlistPath(LAUNCHD_SERVER_LABEL);
-    writeFileSync2(plist, launchdServerPlist(node, cli2, join4(dataDir, "server.log"), serverEnv()));
+    writeFileSync2(plist, launchdServerPlist(node, cli2, join5(dataDir, "server.log"), serverEnv()));
     macBootstrap(plist);
     console.log(`agent-lens service: installed server agent ${LAUNCHD_SERVER_LABEL}`);
   }
@@ -2080,8 +2208,8 @@ function runService(action, params) {
 }
 
 // ../ingest/dist/run.js
-import { readFileSync as readFileSync5, statSync as statSync3, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
+import { readFileSync as readFileSync6, statSync as statSync3, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { dirname as dirname6, join as join9 } from "path";
 
 // ../ingest/dist/db.js
 import Database from "better-sqlite3";
@@ -2138,7 +2266,7 @@ function resetSchema(db) {
 
 // ../ingest/dist/adapters/claude-code.js
 import { readdirSync as readdirSync2 } from "fs";
-import { basename as basename2, join as join5 } from "path";
+import { basename as basename2, join as join6 } from "path";
 function flattenText(content) {
   if (content == null)
     return null;
@@ -2221,7 +2349,7 @@ function recurseJsonl(dir, out) {
     return;
   }
   for (const e of entries) {
-    const p = join5(dir, e.name);
+    const p = join6(dir, e.name);
     if (e.isDirectory())
       recurseJsonl(p, out);
     else if (e.isFile() && e.name.endsWith(".jsonl"))
@@ -2252,12 +2380,12 @@ var ClaudeCodeAdapter = class {
         });
       }
     };
-    addFrom(join5(archiveRoot, "projects"), false);
-    const versionsRoot = join5(archiveRoot, ".versions");
+    addFrom(join6(archiveRoot, "projects"), false);
+    const versionsRoot = join6(archiveRoot, ".versions");
     try {
       for (const ts of readdirSync2(versionsRoot, { withFileTypes: true })) {
         if (ts.isDirectory())
-          addFrom(join5(versionsRoot, ts.name, "projects"), true);
+          addFrom(join6(versionsRoot, ts.name, "projects"), true);
       }
     } catch {
     }
@@ -3311,7 +3439,7 @@ function deriveFileChanges(db, dirty) {
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { createHash as createHash4 } from "crypto";
-import { dirname as dirname4, join as join6 } from "path";
+import { dirname as dirname5, join as join7 } from "path";
 function projectId(agentId, path3) {
   return createHash4("sha1").update(`${agentId}\0${path3}`).digest("hex").slice(0, 16);
 }
@@ -3319,9 +3447,9 @@ var strip = (p) => p.length > 1 ? p.replace(/\/$/, "") : p;
 function nearestGitRoot(path3, home) {
   let cur = strip(path3);
   while (cur !== home && cur !== "/" && cur.length > 0) {
-    if (existsSync4(join6(cur, ".git")))
+    if (existsSync4(join7(cur, ".git")))
       return cur;
-    const next = dirname4(cur);
+    const next = dirname5(cur);
     if (next === cur)
       break;
     cur = next;
@@ -3348,12 +3476,12 @@ function canonicalizeProjects(db, opts = {}) {
       if (git) {
         out = git;
       } else if (existsSync4(p) || !withMains.has(byPath.get(p)?.id ?? "")) {
-        for (let cur = dirname4(p); cur !== "/" && cur !== home && cur.length > 0; cur = dirname4(cur)) {
+        for (let cur = dirname5(p); cur !== "/" && cur !== home && cur.length > 0; cur = dirname5(cur)) {
           if (byPath.has(cur)) {
             out = canon(cur);
             break;
           }
-          if (dirname4(cur) === cur)
+          if (dirname5(cur) === cur)
             break;
         }
       }
@@ -3861,8 +3989,8 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
 import { basename as basename3 } from "path";
 
 // ../ingest/dist/sidecar.js
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join7 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
 
 // ../ingest/dist/redact.js
 import { createHash as createHash6, randomBytes } from "crypto";
@@ -3937,7 +4065,7 @@ function walk(dir, subdir, inSubdir, matchName, out) {
     return;
   }
   for (const e of entries) {
-    const p = join7(dir, e.name);
+    const p = join8(dir, e.name);
     if (e.isDirectory())
       walk(p, subdir, inSubdir || e.name === subdir, matchName, out);
     else if (e.isFile() && inSubdir && matchName(e.name))
@@ -3946,11 +4074,11 @@ function walk(dir, subdir, inSubdir, matchName, out) {
 }
 function discover(sourceArchiveDir, subdir, matchName) {
   const out = [];
-  walk(join7(sourceArchiveDir, "projects"), subdir, false, matchName, out);
+  walk(join8(sourceArchiveDir, "projects"), subdir, false, matchName, out);
   try {
-    for (const ts of readdirSync3(join7(sourceArchiveDir, ".versions"), { withFileTypes: true }))
+    for (const ts of readdirSync3(join8(sourceArchiveDir, ".versions"), { withFileTypes: true }))
       if (ts.isDirectory())
-        walk(join7(sourceArchiveDir, ts.name, "projects"), subdir, false, matchName, out);
+        walk(join8(sourceArchiveDir, ts.name, "projects"), subdir, false, matchName, out);
   } catch {
   }
   return out;
@@ -3977,7 +4105,7 @@ function ingestSidecars(db, sourceArchiveDir, excludedDirs, now2, stats, full, c
     }
     let buf;
     try {
-      buf = readFileSync4(path3);
+      buf = readFileSync5(path3);
     } catch {
       stats.malformed++;
       continue;
@@ -4161,7 +4289,7 @@ function shouldReingest(path3, size, mtimeMs, prev) {
   if (prev && prev.size === size && prev.mtime_ms === mtimeMs)
     return { action: "skip-stat" };
   const small = size <= STREAM_THRESHOLD;
-  const buf = small ? readFileSync5(path3) : null;
+  const buf = small ? readFileSync6(path3) : null;
   const hash2 = small ? sha256(buf) : sha256File(path3);
   if (prev && prev.sha256 === hash2)
     return { action: "skip-hash", hash: hash2 };
@@ -4176,10 +4304,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");
@@ -4194,17 +4328,18 @@ 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);
   }
-  mkdirSync4(dirname5(dbPath), { recursive: true });
+  mkdirSync4(dirname6(dbPath), { recursive: true });
   const db = args.full ? openRaw(dbPath) : openDb(dbPath);
   if (args.full) {
     resetSchema(db);
@@ -4237,7 +4372,7 @@ function runIngest(argv = process.argv.slice(2)) {
     }
     stmts.insAgent.run(adapter.agentId, adapter.agentName);
     stmts.insSource.run({ id: source.label, label: source.label, agent_id: adapter.agentId, config_dir: source.configDir });
-    let files = adapter.discover(join8(archiveRoot, source.label), source.label);
+    let files = adapter.discover(join9(archiveRoot, source.label), source.label);
     if (excludedDirs.length)
       files = files.filter((f) => !isExcludedArchivePath(f.path, excludedDirs));
     files.sort((a, b) => Number(a.isVersion) - Number(b.isVersion));
@@ -4267,9 +4402,9 @@ function runIngest(argv = process.argv.slice(2)) {
       ingestFile(db, stmts, adapter, file, lines, { size: st.size, mtimeMs, hash: decision.hash }, now2, stats);
       dirty.add(file.sessionId);
     }
-    ingestWorkflowResults(db, join8(archiveRoot, source.label), source.label, excludedDirs, now2, wfStats, args.full);
-    ingestSubagentMeta(db, join8(archiveRoot, source.label), source.label, excludedDirs, now2, metaStats, args.full);
-    ingestToolResults(db, join8(archiveRoot, source.label), excludedDirs, now2, trStats, args.full);
+    ingestWorkflowResults(db, join9(archiveRoot, source.label), source.label, excludedDirs, now2, wfStats, args.full);
+    ingestSubagentMeta(db, join9(archiveRoot, source.label), source.label, excludedDirs, now2, metaStats, args.full);
+    ingestToolResults(db, join9(archiveRoot, source.label), excludedDirs, now2, trStats, args.full);
   }
   const expanded = rebuildDerived(db, args.full ? null : dirty);
   canonicalizeProjects(db);
@@ -4301,8 +4436,8 @@ function runMetrics(argv = process.argv.slice(2)) {
 
 // ../server/dist/run.js
 import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname6 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../server/dist/db.js
 import Database2 from "better-sqlite3";
@@ -4373,6 +4508,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) {
@@ -4535,7 +4673,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) {
@@ -4680,6 +4825,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,
@@ -5191,12 +5337,12 @@ 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
@@ -5216,7 +5362,7 @@ 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(),
+    unpriced_models: [...new Set(unpriced2)].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 },
     workflows: workflowAgg(db, f)
@@ -5384,7 +5530,7 @@ function dashboardBreakdowns(db, f) {
 
 // ../server/dist/refresh.js
 import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 function originAllowed(origin) {
   if (!origin)
@@ -5405,7 +5551,7 @@ function writeBlocked(headers) {
 }
 function runRefresh() {
   const dataDir = resolveDataDir(findRepoRoot());
-  const lock = acquireLock(join9(dataDir, ".agent-lens.lock"));
+  const lock = acquireLock(join10(dataDir, ".agent-lens.lock"));
   if (!lock)
     return null;
   try {
@@ -5487,6 +5633,75 @@ 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";
+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;
+  try {
+    db_bytes = statSync4(dbPath).size;
+  } catch {
+    db_bytes = null;
+  }
+  return {
+    db_bytes,
+    archive_bytes: row?.bytes ?? 0,
+    // SUM over zero rows is NULL, not 0
+    archive_files: row?.files ?? 0,
+    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) };
+}
+function about(db, ctx) {
+  const version2 = resolveVersion();
+  const schema = schemaStatus(db);
+  const dataDir = resolveDataDir(ctx.repoRoot);
+  const retention = resolveRetention();
+  return {
+    versions: {
+      app: version2.version,
+      app_source: version2.source,
+      schema: schema.db_version,
+      schema_expected: schema.expected,
+      schema_stale: schema.stale,
+      detector: engineVersion(db, "findings", "SELECT DISTINCT detector_version v FROM findings ORDER BY v", DETECTOR_VERSION),
+      classifier: engineVersion(db, "classifications", "SELECT DISTINCT classifier_version v FROM classifications ORDER BY v", CLASSIFIER_VERSION)
+    },
+    paths: {
+      config_file: resolveConfigFile(ctx.repoRoot, dataDir),
+      data_dir: { path: dataDir, origin: process.env.AGENT_LENS_DATA ? "env" : "default" },
+      // archive and triage_db are "fixed": ADR-021 makes them non-relocatable on their own, so they
+      // are derived here with the same core helpers the CLI uses rather than read from config.
+      archive: { path: resolveArchiveDir(ctx.repoRoot), origin: "fixed" },
+      db: { path: ctx.db.path, origin: ctx.db.origin },
+      triage_db: { path: triageDbFor(ctx.db.path), origin: "fixed" }
+    },
+    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.
+    storage: storage(db, ctx.db.path)
+  };
+}
+
 // ../server/dist/prefs.js
 var PREFS_SCHEMA_SQL = (
   /* sql */
@@ -5548,8 +5763,20 @@ async function createApp(db, opts = {}) {
   };
   app.get("/api/health", async () => {
     const s = schemaStatus(db);
-    return { ok: true, last_ingested: lastIngested(db), schema_version: s.db_version, schema_stale: s.stale };
+    const v = resolveVersion();
+    return {
+      ok: true,
+      last_ingested: lastIngested(db),
+      schema_version: s.db_version,
+      schema_stale: s.stale,
+      version: v.version,
+      version_source: v.source
+    };
   });
+  if (opts.about) {
+    const ctx = opts.about;
+    app.get("/api/about", async () => about(db, ctx));
+  }
   app.post("/api/refresh", async (req, reply) => {
     if (writeBlocked(req.headers)) {
       return reply.code(403).send({ error: { code: "FORBIDDEN_ORIGIN", message: "cross-origin refresh blocked" } });
@@ -5756,10 +5983,11 @@ async function createApp(db, opts = {}) {
 
 // ../server/dist/run.js
 async function startServer(overrides = {}) {
-  const here = dirname6(fileURLToPath2(import.meta.url));
+  const here = dirname7(fileURLToPath3(import.meta.url));
   const repoRoot = findRepoRoot(here);
-  const { path: dbPath } = resolveDbPath(overrides.db);
+  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.`);
@@ -5772,7 +6000,12 @@ async function startServer(overrides = {}) {
   const triageDbPath = triageDbFor(dbPath);
   const db = openReadonly(dbPath);
   const enforceLoopbackHost = host === "127.0.0.1" || host === "localhost";
-  const app = await createApp(db, { webDist, triageDbPath, enforceLoopbackHost });
+  const app = await createApp(db, {
+    webDist,
+    triageDbPath,
+    enforceLoopbackHost,
+    about: { db: { path: dbPath, origin: dbOrigin }, host, port, loopbackOnly: enforceLoopbackHost, repoRoot, pricing }
+  });
   try {
     await app.listen({ host, port });
     console.log(`agent-lens-server: http://${host}:${port}  (db: ${dbPath})`);
@@ -5786,11 +6019,11 @@ async function startServer(overrides = {}) {
 
 // src/watch.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import chokidar from "chokidar";
 async function runWatch(opts = {}) {
   const sources = loadSources();
-  const lockPath = join10(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  const lockPath = join11(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
   let running = false;
   let pending = false;
   const cycle = () => {
@@ -5823,7 +6056,7 @@ async function runWatch(opts = {}) {
     }
   };
   cycle();
-  const watchPaths = sources.map((s) => join10(s.configDir, "projects")).filter((p) => existsSync9(p));
+  const watchPaths = sources.map((s) => join11(s.configDir, "projects")).filter((p) => existsSync9(p));
   if (watchPaths.length === 0) {
     console.error("agent-lens watch: no source 'projects' directories found \u2014 nothing to watch");
   }
@@ -5850,15 +6083,10 @@ async function runWatch(opts = {}) {
 
 // src/index.ts
 function version() {
-  try {
-    const pkg = JSON.parse(readFileSync6(join11(dirname7(fileURLToPath3(import.meta.url)), "../package.json"), "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
+  return resolveVersion().version;
 }
 function withLock(fn) {
-  const lockPath = join11(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  const lockPath = join12(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
   const lock = acquireLock(lockPath);
   if (!lock) {
     console.error("agent-lens: another collect/ingest run is in progress \u2014 skipping");
@@ -5926,7 +6154,7 @@ cli.command(
 ).option("--times <hours>", "Collector cadence: comma-separated hours 0-23 (default: 9,13,17,21)").action((action, target, opts) => {
   const targets = parseTargets(target);
   const hours = action === "install" ? parseHours(opts.times) : void 0;
-  runService(action, { cliEntry: fileURLToPath3(import.meta.url), hours, targets });
+  runService(action, { cliEntry: fileURLToPath4(import.meta.url), hours, targets });
 });
 cli.command("config", "Show the effective configuration (sources, paths, server) and where each value came from").action(() => {
   const repoRoot = findRepoRoot();
@@ -5943,8 +6171,8 @@ cli.command("config", "Show the effective configuration (sources, paths, server)
   const { path: dbPath, origin: dbOrigin } = resolveDbPath();
   const archive = resolveArchiveDir(repoRoot);
   const triageDb = triageDbFor(dbPath);
-  const keepDays = process.env.AGENT_LENS_VERSIONS_KEEP_DAYS || "90";
-  const keepOrigin = process.env.AGENT_LENS_VERSIONS_KEEP_DAYS ? "env" : "default";
+  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)"}`);
@@ -5958,6 +6186,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})`);
 });