@swestash/agent-lens 0.8.2 → 0.9.0

package/dist/agent-lens.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname6, join as join13 } from "path";
+import { dirname as dirname6, join as join12 } 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
@@ -1315,6 +1338,12 @@ function resolveDataDir(repoRoot = findRepoRoot()) {
     return join(repoRoot, "data");
   return userDataDir();
 }
+function resolveArchiveDir(repoRoot = findRepoRoot()) {
+  return join(resolveDataDir(repoRoot), "archive");
+}
+function triageDbFor(dbPath) {
+  return join(dirname(dbPath), "triage.db");
+}
 function resolveConfigFile(repoRoot, dataDir) {
   const candidates = [
     process.env.AGENT_LENS_CONFIG,
@@ -1662,7 +1691,7 @@ function collectSource(source, archiveBase, excludedDirs, runTs, stats, log) {
 }
 function collectAll(opts = {}) {
   const log = opts.log ?? ((m) => console.log(m));
-  const archiveBase = opts.archiveBase ?? join3(resolveDataDir(findRepoRoot()), "archive");
+  const archiveBase = opts.archiveBase ?? resolveArchiveDir();
   const sources = opts.sources ?? loadSources();
   const excludedDirs = (opts.excludes ?? loadExcludes()).map(encodeProjectPath);
   const runTs = opts.runTimestamp ?? collectTimestamp();
@@ -2082,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;
@@ -2170,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;
 }
@@ -2204,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)
         });
       }
     };
@@ -2653,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;
@@ -3194,8 +3224,107 @@ 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/pipeline.js
+import { createHash as createHash4 } from "crypto";
 function newStats() {
   return { files: 0, skipped: 0, malformed: 0, newEvents: 0 };
 }
@@ -3233,7 +3362,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 createHash4("sha1").update(name).update("\0").update(body).digest("hex").slice(0, 16);
 }
 function pruneExcluded(db, excludedPaths) {
   if (!excludedPaths.length)
@@ -3268,6 +3397,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)");
@@ -3501,6 +3631,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)");
   }
@@ -3615,7 +3746,7 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
     }
     let projectId = null;
     if (sessionMeta.cwd) {
-      projectId = createHash3("sha1").update(`${adapter.agentId}\0${sessionMeta.cwd}`).digest("hex").slice(0, 16);
+      projectId = createHash4("sha1").update(`${adapter.agentId}\0${sessionMeta.cwd}`).digest("hex").slice(0, 16);
       stmts.upsertProject.run({
         id: projectId,
         agent_id: adapter.agentId,
@@ -3654,7 +3785,7 @@ import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as
 import { basename as basename3, join as join6 } from "path";
 
 // ../ingest/dist/redact.js
-import { createHash as createHash4, randomBytes } from "crypto";
+import { createHash as createHash5, randomBytes } from "crypto";
 function parseExcludes(csv) {
   return (csv ?? "").split(",").map((s) => s.trim()).filter(Boolean).map(encodeProjectPath);
 }
@@ -3663,17 +3794,17 @@ function isExcludedArchivePath(filePath, excluded) {
 }
 
 // ../ingest/dist/fileread.js
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } 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 createHash6("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 = createHash6("sha256");
   const buf = Buffer.allocUnsafe(CHUNK2);
   try {
     let n;
@@ -3684,8 +3815,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 = "";
@@ -3737,8 +3868,8 @@ function discoverSidecars(sourceArchiveDir) {
   }
   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;
 }
@@ -3785,25 +3916,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;
     }
@@ -3818,14 +3949,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),
@@ -3843,7 +3974,7 @@ 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++;
   }
 }
@@ -3899,25 +4030,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;
     }
@@ -3932,7 +4063,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,
@@ -3942,7 +4073,7 @@ 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++;
   }
 }
@@ -3979,8 +4110,8 @@ function discoverResults(sourceArchiveDir) {
   }
   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;
 }
@@ -3997,40 +4128,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++;
   }
 }
@@ -4050,8 +4181,7 @@ function parseIngestArgs(argv) {
 }
 function runIngest(argv = process.argv.slice(2)) {
   const args = parseIngestArgs(argv);
-  const dataDir = resolveDataDir(findRepoRoot());
-  const archiveRoot = args.archive || process.env.AGENT_LENS_ARCHIVE || join9(dataDir, "archive");
+  const archiveRoot = args.archive || resolveArchiveDir();
   const { path: dbPath } = resolveDbPath(args.db);
   if (!existsSync4(archiveRoot)) {
     console.error(`agent-lens-ingest: archive not found: ${archiveRoot} (run 'agent-lens collect' first)`);
@@ -4130,6 +4260,7 @@ function runIngest(argv = process.argv.slice(2)) {
   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");
@@ -4155,6 +4286,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)) {
@@ -4171,13 +4303,14 @@ function runMetrics(argv = process.argv.slice(2)) {
   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, join as join11 } from "path";
+import { dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../server/dist/db.js
@@ -4503,7 +4636,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;
@@ -4639,6 +4778,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, projectId) {
+  if (!tableExists(db, "file_changes"))
+    return null;
+  const params = [filePath];
+  let scope = "fc.file_path = ?";
+  if (projectId)
+    scope += " AND fc.project_id = ?", params.push(projectId);
+  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
@@ -5059,7 +5299,7 @@ function runRefresh() {
     return null;
   try {
     const collected = collectAll();
-    const archiveRoot = process.env.AGENT_LENS_ARCHIVE || join10(dataDir, "archive");
+    const archiveRoot = resolveArchiveDir();
     if (!existsSync5(archiveRoot))
       mkdirSync5(archiveRoot, { recursive: true });
     runIngest([]);
@@ -5355,6 +5595,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);
@@ -5389,7 +5651,7 @@ async function startServer(overrides = {}) {
     console.error(`agent-lens-server: db not found: ${dbPath} (run ingest first)`);
     process.exit(1);
   }
-  const triageDbPath = process.env.AGENT_LENS_TRIAGE_DB || join11(dirname5(dbPath), "triage.db");
+  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 });
@@ -5406,11 +5668,11 @@ async function startServer(overrides = {}) {
 
 // src/watch.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 import chokidar from "chokidar";
 async function runWatch(opts = {}) {
   const sources = loadSources();
-  const lockPath = join12(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  const lockPath = join11(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
   let running = false;
   let pending = false;
   const cycle = () => {
@@ -5443,7 +5705,7 @@ async function runWatch(opts = {}) {
     }
   };
   cycle();
-  const watchPaths = sources.map((s) => join12(s.configDir, "projects")).filter((p) => existsSync8(p));
+  const watchPaths = sources.map((s) => join11(s.configDir, "projects")).filter((p) => existsSync8(p));
   if (watchPaths.length === 0) {
     console.error("agent-lens watch: no source 'projects' directories found \u2014 nothing to watch");
   }
@@ -5471,14 +5733,14 @@ async function runWatch(opts = {}) {
 // src/index.ts
 function version() {
   try {
-    const pkg = JSON.parse(readFileSync8(join13(dirname6(fileURLToPath3(import.meta.url)), "../package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync8(join12(dirname6(fileURLToPath3(import.meta.url)), "../package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function withLock(fn) {
-  const lockPath = join13(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");
@@ -5561,17 +5823,17 @@ cli.command("config", "Show the effective configuration (sources, paths, server)
   }
   const { port, host, portOrigin, hostOrigin } = server;
   const { path: dbPath, origin: dbOrigin } = resolveDbPath();
-  const archive = process.env.AGENT_LENS_ARCHIVE || join13(dataDir, "archive");
-  const triageDb = process.env.AGENT_LENS_TRIAGE_DB || join13(dirname6(dbPath), "triage.db");
+  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";
   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)"}`);
   console.log(`  data dir         ${dataDir}${process.env.AGENT_LENS_DATA ? "  [env]" : ""}`);
-  console.log(`  archive          ${archive}${process.env.AGENT_LENS_ARCHIVE ? "  [env]" : ""}`);
+  console.log(`  archive          ${archive}  [fixed: <data dir>/archive]`);
   console.log(`  db               ${dbPath}  [${dbOrigin}]`);
-  console.log(`  triage db        ${triageDb}${process.env.AGENT_LENS_TRIAGE_DB ? "  [env]" : ""}`);
+  console.log(`  triage db        ${triageDb}  [fixed: beside the db]`);
   console.log("\nServer");
   console.log(`  host             ${host}  [${hostOrigin}]`);
   console.log(`  port             ${port}  [${portOrigin}]`);