@swestash/agent-lens 0.9.6 → 0.10.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;
 };
@@ -1377,6 +1377,12 @@ 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 readConfigFile() {
   const repoRoot = findRepoRoot();
   const dataDir = resolveDataDir(repoRoot);
@@ -1436,6 +1442,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 +1549,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 +1575,7 @@ function syncMeta(dst, src) {
   }
 }
 function copyWhole(src, dst, srcStat) {
-  ensureDir(dirname2(dst));
+  ensureDir(dirname3(dst));
   copyFileSync(src, dst);
   syncMeta(dst, srcStat);
 }
@@ -1570,27 +1629,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 +1690,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 +1703,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 +1728,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 +1747,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 +1769,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 +1783,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 +1800,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 +1811,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 +1956,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 +1975,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 +2004,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 +2024,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 +2038,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 +2139,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 +2197,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 +2280,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 +2311,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 +3370,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 +3378,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 +3407,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 +3920,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 +3996,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 +4005,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 +4036,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 +4220,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 };
@@ -4204,7 +4263,7 @@ function runIngest(argv = process.argv.slice(2)) {
     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 +4296,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 +4326,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 +4360,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";
@@ -5384,7 +5443,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 +5464,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 +5546,61 @@ 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 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 },
+    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 +5662,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,9 +5882,9 @@ 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 webDist = resolveWebDist(here, repoRoot);
   if (host !== "127.0.0.1" && host !== "localhost" && !process.env.AGENT_LENS_ALLOW_NONLOCAL) {
@@ -5772,7 +5898,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 }
+  });
   try {
     await app.listen({ host, port });
     console.log(`agent-lens-server: http://${host}:${port}  (db: ${dbPath})`);
@@ -5786,11 +5917,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 +5954,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 +5981,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 +6052,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 +6069,7 @@ 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();
   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)"}`);