@swestash/agent-lens 0.8.3 → 0.9.1

package/dist/agent-lens.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname6, join as join12 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname7, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../../node_modules/.pnpm/cac@6.7.14/node_modules/cac/dist/index.mjs
@@ -591,7 +591,7 @@ var CAC = class extends EventEmitter {
 var cac = (name = "") => new CAC(name);
 
 // ../core/dist/schema.js
-var SCHEMA_VERSION = 13;
+var SCHEMA_VERSION = 14;
 var SCHEMA_SQL = (
   /* sql */
   `
@@ -811,6 +811,29 @@ CREATE INDEX IF NOT EXISTS idx_findings_category ON findings(category);
 CREATE INDEX IF NOT EXISTS idx_findings_rule     ON findings(rule_id);
 CREATE INDEX IF NOT EXISTS idx_findings_tool_call ON findings(tool_call_id);
 
+-- File modifications derived from tool calls (ADR-022). One row per (tool_call, file): today
+-- Edit/Write/NotebookEdit are 1:1, but the hash id leaves room for multi-file sources (e.g. a
+-- future Bash-write heuristic) without a schema break. Failed calls (status='error') are excluded
+-- at derivation \u2014 they didn't change the file. Re-runnable like findings: incremental runs DELETE
+-- the dirty sessions' rows and re-INSERT (delete-then-insert). Populated by ingest's
+-- deriveFileChanges (filechanges.ts).
+CREATE TABLE IF NOT EXISTS file_changes (
+  id             TEXT PRIMARY KEY,                -- sha1(tool_call_id + NUL + file_path), 16 hex
+  tool_call_id   TEXT NOT NULL REFERENCES tool_calls(id),
+  session_id     TEXT NOT NULL REFERENCES sessions(id),
+  turn_id        TEXT,               -- no FK: rebuildDerived recreates turns (same stance as findings)
+  event_uuid     TEXT,                            -- jump-to-transcript anchor (#ev-<uuid>)
+  project_id     TEXT REFERENCES projects(id),    -- from the session, for per-project grouping
+  file_path      TEXT NOT NULL,                   -- normalized absolute path
+  tool_name      TEXT NOT NULL,                   -- Edit | Write | NotebookEdit
+  lines_added    INTEGER,                         -- newline-count delta (NULL when unknowable)
+  lines_removed  INTEGER,
+  timestamp      TEXT,                            -- ISO8601, from the tool call's event
+  derive_version INTEGER NOT NULL DEFAULT 1
+);
+CREATE INDEX IF NOT EXISTS idx_file_changes_session ON file_changes(session_id);
+CREATE INDEX IF NOT EXISTS idx_file_changes_file    ON file_changes(project_id, file_path, timestamp);
+
 -- Workflow-tool run results, ingested from the sidecar JSON the runner writes next to the launching
 -- session (\u2026/projects/<enc>/<sessionId>/workflows/wf_<id>.json). The transcript only carries the
 -- "launched in background" ack for an async run; this sidecar is the authoritative record of how the
@@ -2054,8 +2077,8 @@ function runService(action, params) {
 }
 
 // ../ingest/dist/run.js
-import { readFileSync as readFileSync7, statSync as statSync5, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
-import { dirname as dirname4, join as join9 } from "path";
+import { readFileSync as readFileSync7, statSync as statSync5, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
 
 // ../ingest/dist/db.js
 import Database from "better-sqlite3";
@@ -2088,6 +2111,7 @@ function resetSchema(db) {
     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;
@@ -2176,13 +2200,13 @@ function asString(v) {
 function asInt(v) {
   return typeof v === "number" && Number.isFinite(v) ? Math.trunc(v) : 0;
 }
-function parentSessionFromPath(path2) {
-  const parts = path2.split("/");
+function parentSessionFromPath(path3) {
+  const parts = path3.split("/");
   const i = parts.indexOf("subagents");
   return i > 0 ? parts[i - 1] : null;
 }
-function workflowRunFromPath(path2) {
-  const parts = path2.split("/");
+function workflowRunFromPath(path3) {
+  const parts = path3.split("/");
   const i = parts.indexOf("workflows");
   return i >= 0 && i + 1 < parts.length ? parts[i + 1] : null;
 }
@@ -2210,18 +2234,18 @@ var ClaudeCodeAdapter = class {
     const addFrom = (projectsDir, isVersion) => {
       const found = [];
       recurseJsonl(projectsDir, found);
-      for (const path2 of found) {
-        const parts = path2.split("/");
-        const sessionId = basename2(path2, ".jsonl");
+      for (const path3 of found) {
+        const parts = path3.split("/");
+        const sessionId = basename2(path3, ".jsonl");
         const encodedDir = parts[parts.length - 2] ?? "";
         files.push({
-          path: path2,
+          path: path3,
           sessionId,
           encodedDir,
           isVersion,
           sourceId,
-          parentSessionId: parentSessionFromPath(path2),
-          workflowRunId: workflowRunFromPath(path2)
+          parentSessionId: parentSessionFromPath(path3),
+          workflowRunId: workflowRunFromPath(path3)
         });
       }
     };
@@ -2659,8 +2683,8 @@ function execGeneratedScript(cmd) {
     const e = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const interp = new RegExp(`\\b(?:sh|bash|zsh|ksh|dash|source)\\s+["']?${e}\\b|(?:^|[\\n;|&(])\\s*\\.\\s+["']?${e}\\b`);
     const hasPath = /^(\.\/|\/|~\/)/.test(t);
-    const path2 = hasPath ? new RegExp(`(?:^|[\\n;|&(])\\s*${e}(?:\\s|$|[;&|<>])`) : new RegExp(`(?:^|[\\n;|&(])\\s*\\.\\/${e}\\b`);
-    if (interp.test(cmd) || path2.test(cmd))
+    const path3 = hasPath ? new RegExp(`(?:^|[\\n;|&(])\\s*${e}(?:\\s|$|[;&|<>])`) : new RegExp(`(?:^|[\\n;|&(])\\s*\\.\\/${e}\\b`);
+    if (interp.test(cmd) || path3.test(cmd))
       return t;
   }
   return null;
@@ -3200,8 +3224,195 @@ function classifyErrors(db, dirty) {
   return { count, version: ERROR_CLASSIFIER_VERSION };
 }
 
-// ../ingest/dist/pipeline.js
+// ../ingest/dist/filechanges.js
 import { createHash as createHash3 } from "crypto";
+import { posix as path2 } from "path";
+var FILECHANGES_VERSION = 1;
+var FILE_TOOLS = ["Edit", "Write", "NotebookEdit"];
+function fileChangeId(toolCallId, filePath) {
+  return createHash3("sha1").update(toolCallId).update("\0").update(filePath).digest("hex").slice(0, 16);
+}
+function normalizeFilePath(filePath, projectPath) {
+  if (typeof filePath !== "string" || !filePath)
+    return null;
+  if (filePath.startsWith("/"))
+    return path2.normalize(filePath);
+  if (!projectPath)
+    return null;
+  return path2.normalize(projectPath.replace(/\/$/, "") + "/" + filePath);
+}
+function lineCount(s) {
+  if (typeof s !== "string")
+    return null;
+  if (s === "")
+    return 0;
+  let n = 1;
+  for (let i = 0; i < s.length; i++)
+    if (s.charCodeAt(i) === 10)
+      n++;
+  return n;
+}
+function deriveFileChanges(db, dirty) {
+  const incremental = dirty != null;
+  if (incremental) {
+    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) => {
+      for (const id of ids)
+        ins.run(id);
+    })(dirty);
+  }
+  const scope = incremental ? " AND tc.session_id IN (SELECT id FROM _dirty_fc)" : "";
+  const proj = /* @__PURE__ */ new Map();
+  for (const r of db.prepare(`SELECT s.id id, p.id pid, p.path path FROM sessions s JOIN projects p ON p.id = s.project_id${incremental ? " WHERE s.id IN (SELECT id FROM _dirty_fc)" : ""}`).all()) {
+    proj.set(r.id, { id: r.pid, path: r.path });
+  }
+  const rows = db.prepare(`SELECT tc.id, tc.session_id, tc.turn_id, tc.event_uuid, tc.tool_name, tc.input_json, tc.status, e.timestamp
+       FROM tool_calls tc LEFT JOIN events e ON e.uuid = tc.event_uuid
+       WHERE tc.tool_name IN (${FILE_TOOLS.map(() => "?").join(",")})${scope}`).all(...FILE_TOOLS);
+  const insert = db.prepare(`INSERT INTO file_changes (id, tool_call_id, session_id, turn_id, event_uuid, project_id, file_path, tool_name, lines_added, lines_removed, timestamp, derive_version)
+     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(() => {
+    db.exec(delScope);
+    for (const row of rows) {
+      if (row.status === "error")
+        continue;
+      let input = null;
+      try {
+        input = row.input_json ? JSON.parse(row.input_json) : null;
+      } catch {
+        input = null;
+      }
+      if (!input)
+        continue;
+      const p = proj.get(row.session_id);
+      const filePath = normalizeFilePath(input.file_path ?? input.notebook_path, p?.path ?? null);
+      if (!filePath)
+        continue;
+      let added = null;
+      let removed = null;
+      if (row.tool_name === "Edit") {
+        added = lineCount(input.new_string);
+        removed = lineCount(input.old_string);
+      } else if (row.tool_name === "Write") {
+        added = lineCount(input.content);
+      }
+      insert.run({
+        id: fileChangeId(row.id, filePath),
+        tool_call_id: row.id,
+        session_id: row.session_id,
+        turn_id: row.turn_id,
+        event_uuid: row.event_uuid,
+        project_id: p?.id ?? null,
+        file_path: filePath,
+        tool_name: row.tool_name,
+        lines_added: added,
+        lines_removed: removed,
+        timestamp: row.timestamp,
+        derive_version: FILECHANGES_VERSION
+      });
+    }
+  });
+  tx();
+  if (incremental)
+    db.exec("DROP TABLE IF EXISTS _dirty_fc");
+  const count = db.prepare("SELECT COUNT(*) n FROM file_changes").get().n;
+  return { count, version: FILECHANGES_VERSION };
+}
+
+// ../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 dirname4, join as join6 } from "path";
+function projectId(agentId, path3) {
+  return createHash4("sha1").update(`${agentId}\0${path3}`).digest("hex").slice(0, 16);
+}
+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")))
+      return cur;
+    const next = dirname4(cur);
+    if (next === cur)
+      break;
+    cur = next;
+  }
+  return null;
+}
+function canonicalizeProjects(db, opts = {}) {
+  const home = strip(opts.homeDir ?? homedir3());
+  const rows = db.prepare("SELECT id, agent_id, path FROM projects").all();
+  const byPath = /* @__PURE__ */ new Map();
+  for (const r of rows)
+    byPath.set(strip(r.path), { id: r.id, agent_id: r.agent_id });
+  const withMains = new Set(db.prepare("SELECT DISTINCT project_id FROM sessions WHERE is_sidechain = 0 AND project_id IS NOT NULL").all().map((r) => r.project_id));
+  const memo = /* @__PURE__ */ new Map();
+  function canon(path3) {
+    const p = strip(path3);
+    const hit = memo.get(p);
+    if (hit)
+      return hit;
+    memo.set(p, p);
+    let out = p;
+    if (p !== home) {
+      const git = nearestGitRoot(p, home);
+      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)) {
+          if (byPath.has(cur)) {
+            out = canon(cur);
+            break;
+          }
+          if (dirname4(cur) === cur)
+            break;
+        }
+      }
+    }
+    memo.set(p, out);
+    return out;
+  }
+  let merged = 0;
+  const upsertProject = db.prepare(`INSERT INTO projects (id, agent_id, path, encoded_dir, first_seen, last_seen)
+     VALUES (?, ?, ?, NULL, NULL, NULL) ON CONFLICT(agent_id, path) DO NOTHING`);
+  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(() => {
+    for (const r of rows) {
+      const target = canon(r.path);
+      if (target === strip(r.path))
+        continue;
+      const targetId = byPath.get(target)?.id ?? projectId(r.agent_id, target);
+      if (targetId === r.id)
+        continue;
+      if (!byPath.has(target)) {
+        upsertProject.run(targetId, r.agent_id, target);
+        byPath.set(target, { id: targetId, agent_id: r.agent_id });
+      }
+      repointSessions.run(targetId, r.id);
+      repointFileChanges.run(targetId, r.id);
+      touched.add(targetId);
+      merged++;
+    }
+    const refresh = db.prepare(`UPDATE projects SET
+         first_seen = (SELECT MIN(started_at) FROM sessions WHERE project_id = projects.id),
+         last_seen  = (SELECT MAX(COALESCE(ended_at, started_at)) FROM sessions WHERE project_id = projects.id)
+       WHERE id = ?`);
+    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;
+  return { merged, removed };
+}
+
+// ../ingest/dist/pipeline.js
+import { createHash as createHash5 } from "crypto";
 function newStats() {
   return { files: 0, skipped: 0, malformed: 0, newEvents: 0 };
 }
@@ -3239,7 +3450,7 @@ function skillSummary(body) {
   return null;
 }
 function skillVersionId(name, body) {
-  return createHash3("sha1").update(name).update("\0").update(body).digest("hex").slice(0, 16);
+  return createHash5("sha1").update(name).update("\0").update(body).digest("hex").slice(0, 16);
 }
 function pruneExcluded(db, excludedPaths) {
   if (!excludedPaths.length)
@@ -3274,6 +3485,7 @@ function pruneExcluded(db, excludedPaths) {
   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)");
@@ -3507,6 +3719,7 @@ function rebuildDerived(db, dirty) {
   db.exec(`DELETE FROM sessions WHERE event_count = 0${andId}`);
   db.exec("DELETE FROM classifications WHERE scope = 'session' AND target_id NOT IN (SELECT id FROM sessions)");
   db.exec("DELETE FROM findings WHERE session_id NOT IN (SELECT id FROM sessions)");
+  db.exec("DELETE FROM file_changes WHERE session_id NOT IN (SELECT id FROM sessions)");
   if (!incremental) {
     db.exec("DELETE FROM skills WHERE id NOT IN (SELECT skill_id FROM tool_calls WHERE skill_id IS NOT NULL)");
   }
@@ -3619,11 +3832,11 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
             result_summary: tr.result_summary ?? null
           });
     }
-    let projectId = null;
+    let projectId2 = null;
     if (sessionMeta.cwd) {
-      projectId = createHash3("sha1").update(`${adapter.agentId}\0${sessionMeta.cwd}`).digest("hex").slice(0, 16);
+      projectId2 = createHash5("sha1").update(`${adapter.agentId}\0${sessionMeta.cwd}`).digest("hex").slice(0, 16);
       stmts.upsertProject.run({
-        id: projectId,
+        id: projectId2,
         agent_id: adapter.agentId,
         path: sessionMeta.cwd,
         encoded_dir: file.encodedDir || null,
@@ -3634,7 +3847,7 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
       id: file.sessionId,
       agent_id: adapter.agentId,
       source_id: file.sourceId,
-      project_id: projectId,
+      project_id: projectId2,
       slug: sessionMeta.slug ?? null,
       ai_title: sessionMeta.ai_title ?? null,
       cli_version: sessionMeta.cli_version ?? null,
@@ -3657,10 +3870,10 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
 
 // ../ingest/dist/workflows.js
 import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { basename as basename3, join as join6 } from "path";
+import { basename as basename3, join as join7 } from "path";
 
 // ../ingest/dist/redact.js
-import { createHash as createHash4, randomBytes } from "crypto";
+import { createHash as createHash6, randomBytes } from "crypto";
 function parseExcludes(csv) {
   return (csv ?? "").split(",").map((s) => s.trim()).filter(Boolean).map(encodeProjectPath);
 }
@@ -3669,17 +3882,17 @@ function isExcludedArchivePath(filePath, excluded) {
 }
 
 // ../ingest/dist/fileread.js
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "fs";
 import { StringDecoder } from "string_decoder";
 var STREAM_THRESHOLD = 8 * 1024 * 1024;
 var CHUNK2 = 64 * 1024;
 function sha256(buf) {
-  return createHash5("sha256").update(buf).digest("hex");
+  return createHash7("sha256").update(buf).digest("hex");
 }
-function sha256File(path2) {
-  const fd = openSync2(path2, "r");
-  const h = createHash5("sha256");
+function sha256File(path3) {
+  const fd = openSync2(path3, "r");
+  const h = createHash7("sha256");
   const buf = Buffer.allocUnsafe(CHUNK2);
   try {
     let n;
@@ -3690,8 +3903,8 @@ function sha256File(path2) {
   }
   return h.digest("hex");
 }
-function* streamLines(path2) {
-  const fd = openSync2(path2, "r");
+function* streamLines(path3) {
+  const fd = openSync2(path3, "r");
   const decoder = new StringDecoder("utf8");
   const buf = Buffer.allocUnsafe(CHUNK2);
   let leftover = "";
@@ -3725,7 +3938,7 @@ function walkSidecars(dir, inWorkflows, out) {
     return;
   }
   for (const e of entries) {
-    const p = join6(dir, e.name);
+    const p = join7(dir, e.name);
     if (e.isDirectory())
       walkSidecars(p, inWorkflows || e.name === "workflows", out);
     else if (e.isFile() && inWorkflows && /^wf_.+\.json$/.test(e.name))
@@ -3734,17 +3947,17 @@ function walkSidecars(dir, inWorkflows, out) {
 }
 function discoverSidecars(sourceArchiveDir) {
   const out = [];
-  walkSidecars(join6(sourceArchiveDir, "projects"), false, out);
+  walkSidecars(join7(sourceArchiveDir, "projects"), false, out);
   try {
-    for (const ts of readdirSync3(join6(sourceArchiveDir, ".versions"), { withFileTypes: true }))
+    for (const ts of readdirSync3(join7(sourceArchiveDir, ".versions"), { withFileTypes: true }))
       if (ts.isDirectory())
-        walkSidecars(join6(sourceArchiveDir, ts.name, "projects"), false, out);
+        walkSidecars(join7(sourceArchiveDir, ts.name, "projects"), false, out);
   } catch {
   }
   return out;
 }
-function sessionFromPath(path2) {
-  const parts = path2.split("/");
+function sessionFromPath(path3) {
+  const parts = path3.split("/");
   const i = parts.indexOf("workflows");
   return i > 0 ? parts[i - 1] : null;
 }
@@ -3791,25 +4004,25 @@ function ingestWorkflowResults(db, sourceArchiveDir, sourceId, excludedDirs, now
        total_tokens=excluded.total_tokens, total_tool_calls=excluded.total_tool_calls,
        duration_ms=excluded.duration_ms, started_at=excluded.started_at, ended_at=excluded.ended_at,
        ingested_at=excluded.ingested_at`);
-  for (const path2 of paths) {
+  for (const path3 of paths) {
     stats.files++;
-    const st = statSync2(path2);
+    const st = statSync2(path3);
     const mtimeMs = Math.trunc(st.mtimeMs);
-    const prev = full ? void 0 : getState.get(path2);
+    const prev = full ? void 0 : getState.get(path3);
     if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
       stats.skipped++;
       continue;
     }
     let buf;
     try {
-      buf = readFileSync4(path2);
+      buf = readFileSync4(path3);
     } catch {
       stats.malformed++;
       continue;
     }
     const hash2 = sha256(buf);
     if (prev && prev.sha256 === hash2) {
-      setState.run({ file_path: path2, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
+      setState.run({ file_path: path3, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
       stats.skipped++;
       continue;
     }
@@ -3824,14 +4037,14 @@ function ingestWorkflowResults(db, sourceArchiveDir, sourceId, excludedDirs, now
       stats.malformed++;
       continue;
     }
-    const runId = strOrNull(d.runId) ?? basename3(path2, ".json");
+    const runId = strOrNull(d.runId) ?? basename3(path3, ".json");
     const startedAt = toIso(d.startTime) ?? toIso(d.timestamp);
     const durationMs2 = intOrNull(d.durationMs);
     const endedAt = startedAt && durationMs2 != null ? new Date(Date.parse(startedAt) + durationMs2).toISOString() : null;
     upsert.run({
       run_id: runId,
       source_id: sourceId,
-      session_id: sessionFromPath(path2),
+      session_id: sessionFromPath(path3),
       task_id: strOrNull(d.taskId),
       workflow_name: strOrNull(d.workflowName),
       status: strOrNull(d.status),
@@ -3849,14 +4062,14 @@ function ingestWorkflowResults(db, sourceArchiveDir, sourceId, excludedDirs, now
       ended_at: endedAt,
       ingested_at: now2
     });
-    setState.run({ file_path: path2, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
+    setState.run({ file_path: path3, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
     stats.upserted++;
   }
 }
 
 // ../ingest/dist/meta.js
 import { readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { basename as basename4, join as join7 } from "path";
+import { basename as basename4, join as join8 } from "path";
 function newMetaStats() {
   return { files: 0, upserted: 0, skipped: 0, malformed: 0 };
 }
@@ -3868,7 +4081,7 @@ function walkMeta(dir, inSubagents, out) {
     return;
   }
   for (const e of entries) {
-    const p = join7(dir, e.name);
+    const p = join8(dir, e.name);
     if (e.isDirectory())
       walkMeta(p, inSubagents || e.name === "subagents", out);
     else if (e.isFile() && inSubagents && /^agent-.+\.meta\.json$/.test(e.name))
@@ -3877,11 +4090,11 @@ function walkMeta(dir, inSubagents, out) {
 }
 function discoverMeta(sourceArchiveDir) {
   const out = [];
-  walkMeta(join7(sourceArchiveDir, "projects"), false, out);
+  walkMeta(join8(sourceArchiveDir, "projects"), false, out);
   try {
-    for (const ts of readdirSync4(join7(sourceArchiveDir, ".versions"), { withFileTypes: true }))
+    for (const ts of readdirSync4(join8(sourceArchiveDir, ".versions"), { withFileTypes: true }))
       if (ts.isDirectory())
-        walkMeta(join7(sourceArchiveDir, ts.name, "projects"), false, out);
+        walkMeta(join8(sourceArchiveDir, ts.name, "projects"), false, out);
   } catch {
   }
   return out;
@@ -3905,25 +4118,25 @@ function ingestSubagentMeta(db, sourceArchiveDir, sourceId, excludedDirs, now2,
        source_id=excluded.source_id, agent_type=excluded.agent_type,
        agent_description=excluded.agent_description, spawn_depth=excluded.spawn_depth,
        tool_use_id=excluded.tool_use_id, ingested_at=excluded.ingested_at`);
-  for (const path2 of paths) {
+  for (const path3 of paths) {
     stats.files++;
-    const st = statSync3(path2);
+    const st = statSync3(path3);
     const mtimeMs = Math.trunc(st.mtimeMs);
-    const prev = full ? void 0 : getState.get(path2);
+    const prev = full ? void 0 : getState.get(path3);
     if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
       stats.skipped++;
       continue;
     }
     let buf;
     try {
-      buf = readFileSync5(path2);
+      buf = readFileSync5(path3);
     } catch {
       stats.malformed++;
       continue;
     }
     const hash2 = sha256(buf);
     if (prev && prev.sha256 === hash2) {
-      setState.run({ file_path: path2, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
+      setState.run({ file_path: path3, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
       stats.skipped++;
       continue;
     }
@@ -3938,7 +4151,7 @@ function ingestSubagentMeta(db, sourceArchiveDir, sourceId, excludedDirs, now2,
       stats.malformed++;
       continue;
     }
-    const sessionId = basename4(path2, ".meta.json");
+    const sessionId = basename4(path3, ".meta.json");
     upsert.run({
       session_id: sessionId,
       source_id: sourceId,
@@ -3948,14 +4161,14 @@ function ingestSubagentMeta(db, sourceArchiveDir, sourceId, excludedDirs, now2,
       tool_use_id: strOrNull2(d.toolUseId),
       ingested_at: now2
     });
-    setState.run({ file_path: path2, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
+    setState.run({ file_path: path3, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
     stats.upserted++;
   }
 }
 
 // ../ingest/dist/toolResults.js
 import { readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
-import { basename as basename5, join as join8 } from "path";
+import { basename as basename5, join as join9 } from "path";
 function newToolResultStats() {
   return { files: 0, upserted: 0, skipped: 0, malformed: 0 };
 }
@@ -3967,7 +4180,7 @@ function walkResults(dir, inResults, out) {
     return;
   }
   for (const e of entries) {
-    const p = join8(dir, e.name);
+    const p = join9(dir, e.name);
     if (e.isDirectory())
       walkResults(p, inResults || e.name === "tool-results", out);
     else if (e.isFile() && inResults && e.name.endsWith(".txt"))
@@ -3976,17 +4189,17 @@ function walkResults(dir, inResults, out) {
 }
 function discoverResults(sourceArchiveDir) {
   const out = [];
-  walkResults(join8(sourceArchiveDir, "projects"), false, out);
+  walkResults(join9(sourceArchiveDir, "projects"), false, out);
   try {
-    for (const ts of readdirSync5(join8(sourceArchiveDir, ".versions"), { withFileTypes: true }))
+    for (const ts of readdirSync5(join9(sourceArchiveDir, ".versions"), { withFileTypes: true }))
       if (ts.isDirectory())
-        walkResults(join8(sourceArchiveDir, ts.name, "projects"), false, out);
+        walkResults(join9(sourceArchiveDir, ts.name, "projects"), false, out);
   } catch {
   }
   return out;
 }
-function sessionFromPath2(path2) {
-  const parts = path2.split("/");
+function sessionFromPath2(path3) {
+  const parts = path3.split("/");
   const i = parts.indexOf("tool-results");
   return i > 0 ? parts[i - 1] : null;
 }
@@ -4003,40 +4216,40 @@ function ingestToolResults(db, sourceArchiveDir, excludedDirs, now2, stats, full
      VALUES (@session_id, @name, @path, @bytes, @text, @ingested_at)
      ON CONFLICT(session_id, name) DO UPDATE SET
        path=excluded.path, bytes=excluded.bytes, text=excluded.text, ingested_at=excluded.ingested_at`);
-  for (const path2 of paths) {
-    const sessionId = sessionFromPath2(path2);
+  for (const path3 of paths) {
+    const sessionId = sessionFromPath2(path3);
     if (!sessionId)
       continue;
     stats.files++;
-    const st = statSync4(path2);
+    const st = statSync4(path3);
     const mtimeMs = Math.trunc(st.mtimeMs);
-    const prev = full ? void 0 : getState.get(path2);
+    const prev = full ? void 0 : getState.get(path3);
     if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
       stats.skipped++;
       continue;
     }
     let buf;
     try {
-      buf = readFileSync6(path2);
+      buf = readFileSync6(path3);
     } catch {
       stats.malformed++;
       continue;
     }
     const hash2 = sha256(buf);
     if (prev && prev.sha256 === hash2) {
-      setState.run({ file_path: path2, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
+      setState.run({ file_path: path3, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
       stats.skipped++;
       continue;
     }
     upsert.run({
       session_id: sessionId,
-      name: basename5(path2, ".txt"),
-      path: path2,
+      name: basename5(path3, ".txt"),
+      path: path3,
       bytes: st.size,
       text: buf.toString("utf8"),
       ingested_at: now2
     });
-    setState.run({ file_path: path2, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
+    setState.run({ file_path: path3, size: st.size, mtime_ms: mtimeMs, sha256: hash2, ingested_at: now2 });
     stats.upserted++;
   }
 }
@@ -4058,11 +4271,11 @@ function runIngest(argv = process.argv.slice(2)) {
   const args = parseIngestArgs(argv);
   const archiveRoot = args.archive || resolveArchiveDir();
   const { path: dbPath } = resolveDbPath(args.db);
-  if (!existsSync4(archiveRoot)) {
+  if (!existsSync5(archiveRoot)) {
     console.error(`agent-lens-ingest: archive not found: ${archiveRoot} (run 'agent-lens collect' first)`);
     process.exit(1);
   }
-  mkdirSync4(dirname4(dbPath), { recursive: true });
+  mkdirSync4(dirname5(dbPath), { recursive: true });
   const db = args.full ? openRaw(dbPath) : openDb(dbPath);
   if (args.full) {
     resetSchema(db);
@@ -4095,7 +4308,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(join9(archiveRoot, source.label), source.label);
+    let files = adapter.discover(join10(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));
@@ -4127,14 +4340,16 @@ function runIngest(argv = process.argv.slice(2)) {
       ingestFile(db, stmts, adapter, file, lines, { size: st.size, mtimeMs, hash: hash2 }, now2, stats);
       dirty.add(file.sessionId);
     }
-    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);
+    ingestWorkflowResults(db, join10(archiveRoot, source.label), source.label, excludedDirs, now2, wfStats, args.full);
+    ingestSubagentMeta(db, join10(archiveRoot, source.label), source.label, excludedDirs, now2, metaStats, args.full);
+    ingestToolResults(db, join10(archiveRoot, source.label), excludedDirs, now2, trStats, args.full);
   }
   const expanded = rebuildDerived(db, args.full ? null : dirty);
+  canonicalizeProjects(db);
   const classified = classify(db, args.full ? null : expanded);
   const detected = detect(db, args.full ? null : expanded);
   classifyErrors(db, args.full ? null : expanded);
+  const fileChanges = deriveFileChanges(db, args.full ? null : expanded);
   const count = (sql) => db.prepare(sql).get().n;
   const sessions = count("SELECT COUNT(*) n FROM sessions");
   const turns = count("SELECT COUNT(*) n FROM turns");
@@ -4160,6 +4375,7 @@ function runIngest(argv = process.argv.slice(2)) {
   session_meta=${metaRows} (upserted=${metaStats.upserted} skipped=${metaStats.skipped} malformed=${metaStats.malformed})
   tool_results=${trRows} (upserted=${trStats.upserted} skipped=${trStats.skipped} malformed=${trStats.malformed})
   findings=${detected.count} (${sevLine})
+  file_changes=${fileChanges.count}
   tokens=${totalTokens.toLocaleString()} est_cost=$${cost.toFixed(2)} db=${dbPath}`);
 }
 function runMetrics(argv = process.argv.slice(2)) {
@@ -4168,21 +4384,23 @@ function runMetrics(argv = process.argv.slice(2)) {
     if (argv[i] === "--db")
       dbArg = argv[++i] ?? "";
   const { path: dbPath } = resolveDbPath(dbArg);
-  if (!existsSync4(dbPath)) {
+  if (!existsSync5(dbPath)) {
     console.error(`agent-lens-metrics: db not found: ${dbPath} (run ingest first)`);
     process.exit(1);
   }
   const db = openDb(dbPath);
+  canonicalizeProjects(db);
   const r = classify(db);
   const d = detect(db);
   const e = classifyErrors(db);
+  const fc = deriveFileChanges(db);
   db.close();
-  console.log(`agent-lens-metrics: classified=${r.count} classifier_version=${CLASSIFIER_VERSION} findings=${d.count} detector_version=${DETECTOR_VERSION} errors_classified=${e.count} error_classifier_version=${e.version} db=${dbPath}`);
+  console.log(`agent-lens-metrics: classified=${r.count} classifier_version=${CLASSIFIER_VERSION} findings=${d.count} detector_version=${DETECTOR_VERSION} errors_classified=${e.count} error_classifier_version=${e.version} file_changes=${fc.count} filechanges_version=${FILECHANGES_VERSION} db=${dbPath}`);
 }
 
 // ../server/dist/run.js
-import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname5 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../server/dist/db.js
@@ -4508,7 +4726,13 @@ function getSession(db, id) {
   session.tool_error_count = toolRows.filter((t) => t.status === "error").length;
   session.tool_rejection_count = toolRows.filter((t) => t.status === "error" && t.error_type && errorKind(t.error_type) === "rejection").length;
   session.tool_failure_count = session.tool_error_count - session.tool_rejection_count;
-  return { session, turns, events, classification, parent, children, workflow_runs, findings: sessionFindings };
+  let fileChanges = [];
+  if (tableExists(db, "file_changes")) {
+    fileChanges = db.prepare(`SELECT fc.id, fc.tool_call_id, fc.turn_id, fc.event_uuid, fc.file_path, fc.tool_name,
+                fc.lines_added, fc.lines_removed, fc.timestamp
+         FROM file_changes fc WHERE fc.session_id = ? ORDER BY fc.timestamp`).all(id);
+  }
+  return { session, turns, events, classification, parent, children, workflow_runs, findings: sessionFindings, file_changes: fileChanges };
 }
 function xmlTag(text, tag) {
   return text.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`))?.[1]?.trim() ?? null;
@@ -4644,6 +4868,107 @@ function listSkills(db, f = {}) {
     r.sources = r.sources ? String(r.sources).split(",").filter(Boolean) : [];
   return rows;
 }
+function listFiles(db, f = {}) {
+  if (!tableExists(db, "file_changes"))
+    return { total: 0, files: [] };
+  const where = [];
+  const params = [];
+  if (f.q && f.q.trim())
+    where.push("fc.file_path LIKE ?"), params.push(`%${f.q.trim()}%`);
+  if (f.project)
+    where.push("fc.project_id = ?"), params.push(f.project);
+  if (f.source)
+    where.push("EXISTS (SELECT 1 FROM sessions s WHERE s.id = fc.session_id AND s.source_id = ?)"), params.push(f.source);
+  const whereSql = where.length ? ` WHERE ${where.join(" AND ")}` : "";
+  const grouped = `SELECT fc.project_id, fc.file_path,
+       COUNT(DISTINCT fc.session_id) AS sessions,
+       COUNT(*) AS changes,
+       SUM(fc.lines_added) AS lines_added,
+       SUM(fc.lines_removed) AS lines_removed,
+       MIN(fc.timestamp) AS first_ts,
+       MAX(fc.timestamp) AS last_ts
+     FROM file_changes fc${whereSql}
+     GROUP BY fc.project_id, fc.file_path`;
+  const total = db.prepare(`SELECT COUNT(*) n FROM (${grouped})`).get(...params).n;
+  const ORDER = {
+    last_ts: "last_ts",
+    first_ts: "first_ts",
+    changes: "changes",
+    sessions: "sessions",
+    path: "file_path"
+  };
+  const col = ORDER[f.sort ?? "last_ts"] ?? "last_ts";
+  const dir = f.dir === "asc" ? "ASC" : "DESC";
+  const limit = Math.min(f.limit ?? 50, 200);
+  const offset = f.offset ?? 0;
+  const files = db.prepare(`SELECT g.*, p.path AS project_path FROM (${grouped}) g
+       LEFT JOIN projects p ON p.id = g.project_id
+       ORDER BY ${col} ${dir}, g.file_path ASC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  return { total, files };
+}
+function getFileTimeline(db, filePath, projectId2) {
+  if (!tableExists(db, "file_changes"))
+    return null;
+  const params = [filePath];
+  let scope = "fc.file_path = ?";
+  if (projectId2)
+    scope += " AND fc.project_id = ?", params.push(projectId2);
+  const rows = db.prepare(`SELECT fc.id, fc.session_id, fc.turn_id, fc.event_uuid, fc.tool_name, fc.lines_added,
+              fc.lines_removed, fc.timestamp, fc.project_id,
+              s.ai_title, s.slug, s.source_id, s.started_at, t.seq AS turn_seq, t.prompt_preview,
+              p.path AS project_path
+       FROM file_changes fc
+       JOIN sessions s ON s.id = fc.session_id
+       LEFT JOIN turns t ON t.id = fc.turn_id
+       LEFT JOIN projects p ON p.id = fc.project_id
+       WHERE ${scope} ORDER BY fc.timestamp`).all(...params);
+  if (!rows.length)
+    return null;
+  const cat = tableExists(db, "classifications") ? db.prepare("SELECT category FROM classifications WHERE scope = 'session' AND target_id = ?") : null;
+  const bySession = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let g = bySession.get(r.session_id);
+    if (!g) {
+      g = {
+        session_id: r.session_id,
+        title: r.ai_title || r.slug || null,
+        source_id: r.source_id,
+        started_at: r.started_at,
+        category: cat ? cat.get(r.session_id)?.category ?? null : null,
+        changes: []
+      };
+      bySession.set(r.session_id, g);
+    }
+    g.changes.push({
+      id: r.id,
+      turn_id: r.turn_id,
+      turn_seq: r.turn_seq,
+      prompt_preview: r.prompt_preview,
+      event_uuid: r.event_uuid,
+      tool_name: r.tool_name,
+      lines_added: r.lines_added,
+      lines_removed: r.lines_removed,
+      timestamp: r.timestamp
+    });
+  }
+  const sessions = [...bySession.values()].sort((a, b) => {
+    const la = a.changes[a.changes.length - 1].timestamp ?? "";
+    const lb = b.changes[b.changes.length - 1].timestamp ?? "";
+    return la < lb ? 1 : la > lb ? -1 : 0;
+  });
+  return {
+    file_path: filePath,
+    project_id: rows[0].project_id ?? null,
+    project_path: rows[0].project_path ?? null,
+    sessions_count: sessions.length,
+    changes_count: rows.length,
+    lines_added: rows.reduce((a, r) => a + (r.lines_added ?? 0), 0),
+    lines_removed: rows.reduce((a, r) => a + (r.lines_removed ?? 0), 0),
+    first_ts: rows[0].timestamp ?? null,
+    last_ts: rows[rows.length - 1].timestamp ?? null,
+    sessions
+  };
+}
 function getSkill(db, name) {
   const versions = db.prepare(`SELECT sk.id, sk.base_dir, sk.summary, sk.body, sk.body_bytes, sk.first_seen, sk.last_seen,
               (SELECT COUNT(*) FROM tool_calls tc WHERE tc.skill_id = sk.id) AS call_count
@@ -4761,7 +5086,7 @@ function securitySummary(db) {
 }
 
 // ../server/dist/app.js
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 
@@ -5037,8 +5362,8 @@ function dashboardBreakdowns(db, f) {
 }
 
 // ../server/dist/refresh.js
-import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "fs";
+import { join as join11 } from "path";
 function originAllowed(origin) {
   if (!origin)
     return true;
@@ -5059,13 +5384,13 @@ function writeBlocked(headers) {
 }
 function runRefresh() {
   const dataDir = resolveDataDir(findRepoRoot());
-  const lock = acquireLock(join10(dataDir, ".agent-lens.lock"));
+  const lock = acquireLock(join11(dataDir, ".agent-lens.lock"));
   if (!lock)
     return null;
   try {
     const collected = collectAll();
     const archiveRoot = resolveArchiveDir();
-    if (!existsSync5(archiveRoot))
+    if (!existsSync6(archiveRoot))
       mkdirSync5(archiveRoot, { recursive: true });
     runIngest([]);
     return { ok: true, collected };
@@ -5360,6 +5685,28 @@ async function createApp(db, opts = {}) {
       return reply.code(404).send({ error: "not found" });
     return result;
   });
+  app.get("/api/files", async (req) => {
+    const q = req.query;
+    const sort = ["last_ts", "first_ts", "changes", "sessions", "path"].find((s) => s === q.sort);
+    return listFiles(db, {
+      q: q.q,
+      source: q.source,
+      project: q.project,
+      sort,
+      dir: q.dir === "asc" ? "asc" : "desc",
+      limit: Math.min(Number(q.limit) || 50, 200),
+      offset: Number(q.offset) || 0
+    });
+  });
+  app.get("/api/file", async (req, reply) => {
+    const q = req.query;
+    if (!q.path)
+      return reply.code(400).send({ error: "missing path" });
+    const result = getFileTimeline(db, q.path, q.project || void 0);
+    if (!result)
+      return reply.code(404).send({ error: "not found" });
+    return result;
+  });
   app.get("/api/sessions/:id/export.md", async (req, reply) => {
     const { id } = req.params;
     const level = parseRedactionLevel(req.query.redact);
@@ -5368,7 +5715,7 @@ async function createApp(db, opts = {}) {
       return reply.code(404).send({ error: "not found" });
     reply.header("content-type", "text/markdown; charset=utf-8").header("content-disposition", `attachment; filename="${out.filename}"`).send(out.markdown);
   });
-  if (opts.webDist && existsSync6(opts.webDist)) {
+  if (opts.webDist && existsSync7(opts.webDist)) {
     await app.register(fastifyStatic, { root: opts.webDist });
     app.setNotFoundHandler((req, reply) => {
       if (req.url.startsWith("/api/"))
@@ -5381,7 +5728,7 @@ async function createApp(db, opts = {}) {
 
 // ../server/dist/run.js
 async function startServer(overrides = {}) {
-  const here = dirname5(fileURLToPath2(import.meta.url));
+  const here = dirname6(fileURLToPath2(import.meta.url));
   const repoRoot = findRepoRoot(here);
   const { path: dbPath } = resolveDbPath(overrides.db);
   const { host, port } = resolveServerConfig({ port: overrides.port, host: overrides.host });
@@ -5390,7 +5737,7 @@ async function startServer(overrides = {}) {
     console.error(`agent-lens-server: refusing to bind non-loopback host '${host}' (privacy). Set AGENT_LENS_ALLOW_NONLOCAL=1 to override.`);
     process.exit(1);
   }
-  if (!existsSync7(dbPath)) {
+  if (!existsSync8(dbPath)) {
     console.error(`agent-lens-server: db not found: ${dbPath} (run ingest first)`);
     process.exit(1);
   }
@@ -5401,7 +5748,7 @@ async function startServer(overrides = {}) {
   try {
     await app.listen({ host, port });
     console.log(`agent-lens-server: http://${host}:${port}  (db: ${dbPath})`);
-    if (!existsSync7(webDist))
+    if (!existsSync8(webDist))
       console.log("  note: web SPA not built \u2014 run `pnpm --filter @agent-lens/web build`");
   } catch (err) {
     console.error(err);
@@ -5410,12 +5757,12 @@ async function startServer(overrides = {}) {
 }
 
 // src/watch.ts
-import { existsSync as existsSync8 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join12 } from "path";
 import chokidar from "chokidar";
 async function runWatch(opts = {}) {
   const sources = loadSources();
-  const lockPath = join11(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  const lockPath = join12(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
   let running = false;
   let pending = false;
   const cycle = () => {
@@ -5448,7 +5795,7 @@ async function runWatch(opts = {}) {
     }
   };
   cycle();
-  const watchPaths = sources.map((s) => join11(s.configDir, "projects")).filter((p) => existsSync8(p));
+  const watchPaths = sources.map((s) => join12(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");
   }
@@ -5476,14 +5823,14 @@ async function runWatch(opts = {}) {
 // src/index.ts
 function version() {
   try {
-    const pkg = JSON.parse(readFileSync8(join12(dirname6(fileURLToPath3(import.meta.url)), "../package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync8(join13(dirname7(fileURLToPath3(import.meta.url)), "../package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function withLock(fn) {
-  const lockPath = join12(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  const lockPath = join13(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
   const lock = acquireLock(lockPath);
   if (!lock) {
     console.error("agent-lens: another collect/ingest run is in progress \u2014 skipping");
@@ -5528,7 +5875,7 @@ cli.command("metrics", "Re-run classification over an already-ingested DB").opti
 });
 cli.command("export <sessionId>", "Write a session to a shareable Markdown file (redacted by default)").option("--out <file>", "Write to this file (default: stdout)").option("--level <level>", "Redaction level: secrets (default) | structure").option("--no-redact", "Verbatim, UNREDACTED output (opt-out)").option("--db <path>", "SQLite DB path (overrides AGENT_LENS_DB / config db)").action((sessionId, opts) => {
   const { path: dbPath } = resolveDbPath(opts.db);
-  if (!existsSync9(dbPath)) {
+  if (!existsSync10(dbPath)) {
     console.error(`agent-lens: db not found: ${dbPath} (run ingest first)`);
     process.exit(1);
   }