@swestash/agent-lens 0.1.0 → 0.3.0

package/dist/agent-lens.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname6, join as join9 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+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 = 8;
+var SCHEMA_VERSION = 11;
 var SCHEMA_SQL = (
   /* sql */
   `
@@ -781,6 +781,61 @@ CREATE TABLE IF NOT EXISTS classifications (
   PRIMARY KEY (scope, target_id)
 );
 
+-- 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
+-- run finished \u2014 status (completed/failed), summary, the returned result payload, and roll-up
+-- tokens/tool-calls/duration/agent-count. One row per run id; UPSERT on re-ingest. Stored verbatim
+-- (like tool_calls.input_json) \u2014 the DB is local; redaction is an export-time concern. --------------
+CREATE TABLE IF NOT EXISTS workflow_results (
+  run_id           TEXT PRIMARY KEY,   -- wf_<id> (matches tool_calls.workflow_run_id / sessions.workflow_run_id)
+  source_id        TEXT,               -- which configured source (account) it came from
+  session_id       TEXT,               -- launching session (path segment before /workflows/)
+  task_id          TEXT,               -- async task id (the "Task ID: \u2026" in the launch ack)
+  workflow_name    TEXT,
+  status           TEXT,               -- completed | failed | running | ...
+  summary          TEXT,
+  default_model    TEXT,               -- model the run executed on (e.g. claude-fable-5)
+  result_json      TEXT,               -- the returned result object, verbatim JSON (null when none)
+  phases_json      TEXT,               -- [{title}] the run's phase structure (e.g. Generate \u2192 Judge)
+  logs_json        TEXT,               -- concise per-item outcome lines the runner emitted
+  progress_json    TEXT,               -- workflowProgress: the phase/agent event timeline
+  agent_count      INTEGER,            -- agents the run reports having fanned out to
+  total_tokens     INTEGER,
+  total_tool_calls INTEGER,
+  duration_ms      INTEGER,
+  started_at       TEXT,               -- ISO, from the sidecar startTime/timestamp
+  ended_at         TEXT,               -- ISO, started_at + duration
+  ingested_at      TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_results_session ON workflow_results(session_id);
+
+-- Per-subagent metadata sidecar (subagents/agent-<id>.meta.json). One row per subagent session,
+-- joined at read time onto sessions (LEFT JOIN, may precede the session row's arrival). Supplies the
+-- authoritative agentType/description/spawnDepth \u2014 Workflow fan-out subagents carry none in-transcript.
+CREATE TABLE IF NOT EXISTS session_meta (
+  session_id        TEXT PRIMARY KEY,   -- 'agent-<id>' = the subagent session id (meta filename stem)
+  source_id         TEXT,
+  agent_type        TEXT,               -- meta.agentType (e.g. 'Explore', 'claude-code-guide')
+  agent_description TEXT,               -- meta.description (a real human title)
+  spawn_depth       INTEGER,            -- meta.spawnDepth (optional; absent \u21D2 top-level)
+  tool_use_id       TEXT,               -- meta.toolUseId (the spawning tool_call)
+  ingested_at       TEXT
+);
+
+-- Full un-truncated tool outputs spilled to disk (tool-results/<name>.txt) when a result was too large
+-- for the transcript, which keeps only a 280-char summary naming the file. Joined at read time by
+-- parsing that summary's '\u2026/tool-results/<name>.txt' marker back to (session_id, name).
+CREATE TABLE IF NOT EXISTS tool_results (
+  session_id  TEXT,     -- session the tool ran in (from the archive path)
+  name        TEXT,     -- file basename without .txt (matches the marker in tool_calls.result_summary)
+  path        TEXT,     -- archive path (provenance)
+  bytes       INTEGER,  -- original size, for the UI
+  text        TEXT,     -- full un-truncated output, stored inline (self-contained DB)
+  ingested_at TEXT,
+  PRIMARY KEY (session_id, name)
+);
+
 -- Idempotent ingest bookkeeping per archive file. --------------------------
 CREATE TABLE IF NOT EXISTS ingest_state (
   file_path       TEXT PRIMARY KEY,
@@ -1148,16 +1203,17 @@ function snapshot(absPath, relParts, versionsDir, stats) {
   syncMeta(dst, statSync(absPath));
   stats.snapshots++;
 }
-function walkJsonl(dir, out) {
+function walkCollectable(dir, out, inWorkflows = false, inToolResults = false) {
   for (const e of readdirSync(dir, { withFileTypes: true })) {
     const p = join2(dir, e.name);
-    if (e.isDirectory())
-      walkJsonl(p, out);
-    else if (e.isFile() && e.name.endsWith(".jsonl"))
+    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"))) {
       out.push(p);
+    }
   }
 }
-function syncFile(src, dst, relParts, archive, versionsDir, stats) {
+function syncFile(src, dst, relParts, archive, versionsDir, stats, appendable) {
   const srcStat = statSync(src);
   if (!existsSync2(dst)) {
     copyWhole(src, dst, srcStat);
@@ -1169,11 +1225,11 @@ function syncFile(src, dst, relParts, archive, versionsDir, stats) {
     return;
   const ssize = srcStat.size;
   const asize = arcStat.size;
-  if (ssize >= asize && prefixEquals(src, dst, asize)) {
-    if (ssize > asize) {
-      appendRange(src, dst, asize, ssize);
-      stats.appended++;
-    }
+  if (ssize === asize && prefixEquals(src, dst, asize)) {
+    syncMeta(dst, srcStat);
+  } else if (appendable && ssize > asize && prefixEquals(src, dst, asize)) {
+    appendRange(src, dst, asize, ssize);
+    stats.appended++;
     syncMeta(dst, srcStat);
   } else if (ssize < asize) {
     const last = latestSnapshot(archive, relParts);
@@ -1214,7 +1270,7 @@ function collectSource(source, archiveBase, excludedDirs, runTs, stats, log) {
   const files = [];
   const projectsDir = join2(configDir, "projects");
   if (existsSync2(projectsDir))
-    walkJsonl(projectsDir, files);
+    walkCollectable(projectsDir, files);
   const historySrc = join2(configDir, "history.jsonl");
   if (existsSync2(historySrc))
     files.push(historySrc);
@@ -1228,7 +1284,7 @@ function collectSource(source, archiveBase, excludedDirs, runTs, stats, log) {
     if (excludedDirs.some((enc) => relPosix.startsWith(`projects/${enc}/`)))
       continue;
     stats.scanned++;
-    syncFile(src, join2(archive, ...relParts), relParts, archive, versionsDir, stats);
+    syncFile(src, join2(archive, ...relParts), relParts, archive, versionsDir, stats, base.endsWith(".jsonl"));
   }
   for (const f of ["settings.json", "settings.local.json"]) {
     const s = join2(configDir, f);
@@ -1627,8 +1683,8 @@ function runService(action, params) {
 }
 
 // ../ingest/dist/run.js
-import { readFileSync as readFileSync4, statSync as statSync2, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
-import { dirname as dirname4, join as join5 } from "path";
+import { readFileSync as readFileSync7, statSync as statSync5, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
 
 // ../ingest/dist/db.js
 import Database from "better-sqlite3";
@@ -1638,9 +1694,16 @@ function openRaw(file) {
   db.pragma("foreign_keys = ON");
   return db;
 }
+function readSchemaVersion(db) {
+  const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+  if (!row)
+    return null;
+  const n = Number(row.value);
+  return Number.isFinite(n) ? n : null;
+}
 function applySchema(db) {
   db.exec(SCHEMA_SQL);
-  db.prepare("INSERT INTO meta(key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(String(SCHEMA_VERSION));
+  db.prepare("INSERT INTO meta(key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO NOTHING").run(String(SCHEMA_VERSION));
 }
 function openDb(file) {
   const db = openRaw(file);
@@ -1664,6 +1727,9 @@ function resetSchema(db) {
     DROP TABLE IF EXISTS projects;
     DROP TABLE IF EXISTS sources;
     DROP TABLE IF EXISTS agents;
+    DROP TABLE IF EXISTS workflow_results;
+    DROP TABLE IF EXISTS session_meta;
+    DROP TABLE IF EXISTS tool_results;
     DROP TABLE IF EXISTS ingest_state;
     DROP TABLE IF EXISTS meta;
   `);
@@ -1875,9 +1941,10 @@ var ClaudeCodeAdapter = class {
             result_summary: null
           });
         } else if (b.type === "tool_result" && asString(b.tool_use_id)) {
+          const isAskUser = tur && tur.questions && tur.answers && typeof tur.answers === "object";
           toolResults.push({
             tool_use_id: b.tool_use_id,
-            result_summary: summarizeResult(b.content),
+            result_summary: isAskUser ? JSON.stringify({ answers: tur.answers, annotations: tur.annotations ?? {} }) : summarizeResult(b.content),
             ...tur ? {
               status: asString(tur.status),
               agent_type: asString(tur.agentType),
@@ -2607,6 +2674,10 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now, stats) {
   tx();
 }
 
+// ../ingest/dist/workflows.js
+import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { basename as basename3, join as join5 } from "path";
+
 // ../ingest/dist/redact.js
 import { createHash as createHash2, randomBytes } from "crypto";
 function parseExcludes(csv) {
@@ -2661,6 +2732,334 @@ function* streamLines(path) {
   }
 }
 
+// ../ingest/dist/workflows.js
+function newWorkflowStats() {
+  return { files: 0, upserted: 0, skipped: 0, malformed: 0 };
+}
+function walkSidecars(dir, inWorkflows, out) {
+  let entries;
+  try {
+    entries = readdirSync3(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = join5(dir, e.name);
+    if (e.isDirectory())
+      walkSidecars(p, inWorkflows || e.name === "workflows", out);
+    else if (e.isFile() && inWorkflows && /^wf_.+\.json$/.test(e.name))
+      out.push(p);
+  }
+}
+function discoverSidecars(sourceArchiveDir) {
+  const out = [];
+  walkSidecars(join5(sourceArchiveDir, "projects"), false, out);
+  try {
+    for (const ts of readdirSync3(join5(sourceArchiveDir, ".versions"), { withFileTypes: true }))
+      if (ts.isDirectory())
+        walkSidecars(join5(sourceArchiveDir, ts.name, "projects"), false, out);
+  } catch {
+  }
+  return out;
+}
+function sessionFromPath(path) {
+  const parts = path.split("/");
+  const i = parts.indexOf("workflows");
+  return i > 0 ? parts[i - 1] : null;
+}
+function toIso(x) {
+  if (typeof x === "number" && Number.isFinite(x))
+    return new Date(x).toISOString();
+  if (typeof x === "string" && x) {
+    const t = Date.parse(x);
+    return Number.isNaN(t) ? null : new Date(t).toISOString();
+  }
+  return null;
+}
+var jsonOrNull = (v) => v == null ? null : JSON.stringify(v);
+var intOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? Math.trunc(v) : null;
+var strOrNull = (v) => typeof v === "string" && v ? v : null;
+function cleanStr(v) {
+  const s = strOrNull(v);
+  if (!s)
+    return null;
+  return s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/\[[0-9;]+m\]?/g, "").trim() || null;
+}
+function ingestWorkflowResults(db, sourceArchiveDir, sourceId, excludedDirs, now, stats, full) {
+  let paths = discoverSidecars(sourceArchiveDir);
+  if (excludedDirs.length)
+    paths = paths.filter((p) => !isExcludedArchivePath(p, excludedDirs));
+  paths.sort((a, b) => Number(a.includes("/.versions/")) - Number(b.includes("/.versions/")) || (a < b ? -1 : 1));
+  const getState = db.prepare("SELECT size, mtime_ms, sha256 FROM ingest_state WHERE file_path = ?");
+  const setState = db.prepare(`INSERT INTO ingest_state (file_path, size, mtime_ms, sha256, events_ingested, ingested_at)
+     VALUES (@file_path, @size, @mtime_ms, @sha256, 0, @ingested_at)
+     ON CONFLICT(file_path) DO UPDATE SET size=excluded.size, mtime_ms=excluded.mtime_ms, sha256=excluded.sha256, ingested_at=excluded.ingested_at`);
+  const upsert = db.prepare(`INSERT INTO workflow_results
+       (run_id, source_id, session_id, task_id, workflow_name, status, summary, default_model,
+        result_json, phases_json, logs_json, progress_json,
+        agent_count, total_tokens, total_tool_calls, duration_ms, started_at, ended_at, ingested_at)
+     VALUES
+       (@run_id, @source_id, @session_id, @task_id, @workflow_name, @status, @summary, @default_model,
+        @result_json, @phases_json, @logs_json, @progress_json,
+        @agent_count, @total_tokens, @total_tool_calls, @duration_ms, @started_at, @ended_at, @ingested_at)
+     ON CONFLICT(run_id) DO UPDATE SET
+       source_id=excluded.source_id, session_id=excluded.session_id, task_id=excluded.task_id,
+       workflow_name=excluded.workflow_name, status=excluded.status, summary=excluded.summary,
+       default_model=excluded.default_model, result_json=excluded.result_json, phases_json=excluded.phases_json,
+       logs_json=excluded.logs_json, progress_json=excluded.progress_json, agent_count=excluded.agent_count,
+       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 path of paths) {
+    stats.files++;
+    const st = statSync2(path);
+    const mtimeMs = Math.trunc(st.mtimeMs);
+    const prev = full ? void 0 : getState.get(path);
+    if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
+      stats.skipped++;
+      continue;
+    }
+    let buf;
+    try {
+      buf = readFileSync4(path);
+    } catch {
+      stats.malformed++;
+      continue;
+    }
+    const hash = sha256(buf);
+    if (prev && prev.sha256 === hash) {
+      setState.run({ file_path: path, size: st.size, mtime_ms: mtimeMs, sha256: hash, ingested_at: now });
+      stats.skipped++;
+      continue;
+    }
+    let d;
+    try {
+      d = JSON.parse(buf.toString("utf8"));
+    } catch {
+      stats.malformed++;
+      continue;
+    }
+    if (!d || typeof d !== "object") {
+      stats.malformed++;
+      continue;
+    }
+    const runId = strOrNull(d.runId) ?? basename3(path, ".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(path),
+      task_id: strOrNull(d.taskId),
+      workflow_name: strOrNull(d.workflowName),
+      status: strOrNull(d.status),
+      summary: strOrNull(d.summary),
+      default_model: cleanStr(d.defaultModel),
+      result_json: jsonOrNull(d.result),
+      phases_json: Array.isArray(d.phases) ? JSON.stringify(d.phases) : null,
+      logs_json: Array.isArray(d.logs) ? JSON.stringify(d.logs) : null,
+      progress_json: Array.isArray(d.workflowProgress) ? JSON.stringify(d.workflowProgress) : null,
+      agent_count: intOrNull(d.agentCount),
+      total_tokens: intOrNull(d.totalTokens),
+      total_tool_calls: intOrNull(d.totalToolCalls),
+      duration_ms: durationMs2,
+      started_at: startedAt,
+      ended_at: endedAt,
+      ingested_at: now
+    });
+    setState.run({ file_path: path, size: st.size, mtime_ms: mtimeMs, sha256: hash, ingested_at: now });
+    stats.upserted++;
+  }
+}
+
+// ../ingest/dist/meta.js
+import { readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { basename as basename4, join as join6 } from "path";
+function newMetaStats() {
+  return { files: 0, upserted: 0, skipped: 0, malformed: 0 };
+}
+function walkMeta(dir, inSubagents, out) {
+  let entries;
+  try {
+    entries = readdirSync4(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = join6(dir, e.name);
+    if (e.isDirectory())
+      walkMeta(p, inSubagents || e.name === "subagents", out);
+    else if (e.isFile() && inSubagents && /^agent-.+\.meta\.json$/.test(e.name))
+      out.push(p);
+  }
+}
+function discoverMeta(sourceArchiveDir) {
+  const out = [];
+  walkMeta(join6(sourceArchiveDir, "projects"), false, out);
+  try {
+    for (const ts of readdirSync4(join6(sourceArchiveDir, ".versions"), { withFileTypes: true }))
+      if (ts.isDirectory())
+        walkMeta(join6(sourceArchiveDir, ts.name, "projects"), false, out);
+  } catch {
+  }
+  return out;
+}
+var intOrNull2 = (v) => typeof v === "number" && Number.isFinite(v) ? Math.trunc(v) : null;
+var strOrNull2 = (v) => typeof v === "string" && v ? v : null;
+function ingestSubagentMeta(db, sourceArchiveDir, sourceId, excludedDirs, now, stats, full) {
+  let paths = discoverMeta(sourceArchiveDir);
+  if (excludedDirs.length)
+    paths = paths.filter((p) => !isExcludedArchivePath(p, excludedDirs));
+  paths.sort((a, b) => Number(a.includes("/.versions/")) - Number(b.includes("/.versions/")) || (a < b ? -1 : 1));
+  const getState = db.prepare("SELECT size, mtime_ms, sha256 FROM ingest_state WHERE file_path = ?");
+  const setState = db.prepare(`INSERT INTO ingest_state (file_path, size, mtime_ms, sha256, events_ingested, ingested_at)
+     VALUES (@file_path, @size, @mtime_ms, @sha256, 0, @ingested_at)
+     ON CONFLICT(file_path) DO UPDATE SET size=excluded.size, mtime_ms=excluded.mtime_ms, sha256=excluded.sha256, ingested_at=excluded.ingested_at`);
+  const upsert = db.prepare(`INSERT INTO session_meta
+       (session_id, source_id, agent_type, agent_description, spawn_depth, tool_use_id, ingested_at)
+     VALUES
+       (@session_id, @source_id, @agent_type, @agent_description, @spawn_depth, @tool_use_id, @ingested_at)
+     ON CONFLICT(session_id) DO UPDATE SET
+       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 path of paths) {
+    stats.files++;
+    const st = statSync3(path);
+    const mtimeMs = Math.trunc(st.mtimeMs);
+    const prev = full ? void 0 : getState.get(path);
+    if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
+      stats.skipped++;
+      continue;
+    }
+    let buf;
+    try {
+      buf = readFileSync5(path);
+    } catch {
+      stats.malformed++;
+      continue;
+    }
+    const hash = sha256(buf);
+    if (prev && prev.sha256 === hash) {
+      setState.run({ file_path: path, size: st.size, mtime_ms: mtimeMs, sha256: hash, ingested_at: now });
+      stats.skipped++;
+      continue;
+    }
+    let d;
+    try {
+      d = JSON.parse(buf.toString("utf8"));
+    } catch {
+      stats.malformed++;
+      continue;
+    }
+    if (!d || typeof d !== "object") {
+      stats.malformed++;
+      continue;
+    }
+    const sessionId = basename4(path, ".meta.json");
+    upsert.run({
+      session_id: sessionId,
+      source_id: sourceId,
+      agent_type: strOrNull2(d.agentType),
+      agent_description: strOrNull2(d.description),
+      spawn_depth: intOrNull2(d.spawnDepth),
+      tool_use_id: strOrNull2(d.toolUseId),
+      ingested_at: now
+    });
+    setState.run({ file_path: path, size: st.size, mtime_ms: mtimeMs, sha256: hash, ingested_at: now });
+    stats.upserted++;
+  }
+}
+
+// ../ingest/dist/toolResults.js
+import { readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
+import { basename as basename5, join as join7 } from "path";
+function newToolResultStats() {
+  return { files: 0, upserted: 0, skipped: 0, malformed: 0 };
+}
+function walkResults(dir, inResults, out) {
+  let entries;
+  try {
+    entries = readdirSync5(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = join7(dir, e.name);
+    if (e.isDirectory())
+      walkResults(p, inResults || e.name === "tool-results", out);
+    else if (e.isFile() && inResults && e.name.endsWith(".txt"))
+      out.push(p);
+  }
+}
+function discoverResults(sourceArchiveDir) {
+  const out = [];
+  walkResults(join7(sourceArchiveDir, "projects"), false, out);
+  try {
+    for (const ts of readdirSync5(join7(sourceArchiveDir, ".versions"), { withFileTypes: true }))
+      if (ts.isDirectory())
+        walkResults(join7(sourceArchiveDir, ts.name, "projects"), false, out);
+  } catch {
+  }
+  return out;
+}
+function sessionFromPath2(path) {
+  const parts = path.split("/");
+  const i = parts.indexOf("tool-results");
+  return i > 0 ? parts[i - 1] : null;
+}
+function ingestToolResults(db, sourceArchiveDir, excludedDirs, now, stats, full) {
+  let paths = discoverResults(sourceArchiveDir);
+  if (excludedDirs.length)
+    paths = paths.filter((p) => !isExcludedArchivePath(p, excludedDirs));
+  paths.sort((a, b) => Number(a.includes("/.versions/")) - Number(b.includes("/.versions/")) || (a < b ? -1 : 1));
+  const getState = db.prepare("SELECT size, mtime_ms, sha256 FROM ingest_state WHERE file_path = ?");
+  const setState = db.prepare(`INSERT INTO ingest_state (file_path, size, mtime_ms, sha256, events_ingested, ingested_at)
+     VALUES (@file_path, @size, @mtime_ms, @sha256, 0, @ingested_at)
+     ON CONFLICT(file_path) DO UPDATE SET size=excluded.size, mtime_ms=excluded.mtime_ms, sha256=excluded.sha256, ingested_at=excluded.ingested_at`);
+  const upsert = db.prepare(`INSERT INTO tool_results (session_id, name, path, bytes, text, ingested_at)
+     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 path of paths) {
+    const sessionId = sessionFromPath2(path);
+    if (!sessionId)
+      continue;
+    stats.files++;
+    const st = statSync4(path);
+    const mtimeMs = Math.trunc(st.mtimeMs);
+    const prev = full ? void 0 : getState.get(path);
+    if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
+      stats.skipped++;
+      continue;
+    }
+    let buf;
+    try {
+      buf = readFileSync6(path);
+    } catch {
+      stats.malformed++;
+      continue;
+    }
+    const hash = sha256(buf);
+    if (prev && prev.sha256 === hash) {
+      setState.run({ file_path: path, size: st.size, mtime_ms: mtimeMs, sha256: hash, ingested_at: now });
+      stats.skipped++;
+      continue;
+    }
+    upsert.run({
+      session_id: sessionId,
+      name: basename5(path, ".txt"),
+      path,
+      bytes: st.size,
+      text: buf.toString("utf8"),
+      ingested_at: now
+    });
+    setState.run({ file_path: path, size: st.size, mtime_ms: mtimeMs, sha256: hash, ingested_at: now });
+    stats.upserted++;
+  }
+}
+
 // ../ingest/dist/run.js
 function parseIngestArgs(argv) {
   const a = { full: false, db: "", archive: "" };
@@ -2677,16 +3076,24 @@ 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 || join5(dataDir, "archive");
-  const dbPath = args.db || process.env.AGENT_LENS_DB || join5(dataDir, "agent-lens.db");
+  const archiveRoot = args.archive || process.env.AGENT_LENS_ARCHIVE || join8(dataDir, "archive");
+  const dbPath = args.db || process.env.AGENT_LENS_DB || join8(dataDir, "agent-lens.db");
   if (!existsSync4(archiveRoot)) {
     console.error(`agent-lens-ingest: archive not found: ${archiveRoot} (run 'agent-lens collect' first)`);
     process.exit(1);
   }
   mkdirSync4(dirname4(dbPath), { recursive: true });
   const db = args.full ? openRaw(dbPath) : openDb(dbPath);
-  if (args.full)
+  if (args.full) {
     resetSchema(db);
+  } else {
+    const dbVer = readSchemaVersion(db);
+    if (dbVer != null && dbVer !== SCHEMA_VERSION) {
+      console.error(`agent-lens-ingest: schema mismatch \u2014 DB is v${dbVer}, this build expects v${SCHEMA_VERSION}. Run 'agent-lens ingest --full' to rebuild.`);
+      db.close();
+      process.exit(1);
+    }
+  }
   const adapterList = [new ClaudeCodeAdapter()];
   const adapterById = new Map(adapterList.map((a) => [a.agentId, a]));
   const sources = loadSources();
@@ -2696,6 +3103,9 @@ function runIngest(argv = process.argv.slice(2)) {
   const pruned = pruneExcluded(db, excludePaths);
   const stmts = prepareStatements(db);
   const stats = newStats();
+  const wfStats = newWorkflowStats();
+  const metaStats = newMetaStats();
+  const trStats = newToolResultStats();
   const dirty = /* @__PURE__ */ new Set();
   for (const source of sources) {
     const adapter = adapterById.get(source.agent);
@@ -2705,13 +3115,13 @@ 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(join5(archiveRoot, source.label), source.label);
+    let files = adapter.discover(join8(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));
     for (const file of files) {
       stats.files++;
-      const st = statSync2(file.path);
+      const st = statSync5(file.path);
       const mtimeMs = Math.trunc(st.mtimeMs);
       const prev = args.full ? void 0 : stmts.getState.get(file.path);
       if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
@@ -2719,7 +3129,7 @@ function runIngest(argv = process.argv.slice(2)) {
         continue;
       }
       const small = st.size <= STREAM_THRESHOLD;
-      const buf = small ? readFileSync4(file.path) : null;
+      const buf = small ? readFileSync7(file.path) : null;
       const hash = small ? sha256(buf) : sha256File(file.path);
       if (prev && prev.sha256 === hash) {
         stmts.setState.run({
@@ -2737,6 +3147,9 @@ function runIngest(argv = process.argv.slice(2)) {
       ingestFile(db, stmts, adapter, file, lines, { size: st.size, mtimeMs, hash }, now, stats);
       dirty.add(file.sessionId);
     }
+    ingestWorkflowResults(db, join8(archiveRoot, source.label), source.label, excludedDirs, now, wfStats, args.full);
+    ingestSubagentMeta(db, join8(archiveRoot, source.label), source.label, excludedDirs, now, metaStats, args.full);
+    ingestToolResults(db, join8(archiveRoot, source.label), excludedDirs, now, trStats, args.full);
   }
   const expanded = rebuildDerived(db, args.full ? null : dirty);
   const classified = classify(db, args.full ? null : expanded);
@@ -2752,9 +3165,15 @@ function runIngest(argv = process.argv.slice(2)) {
     cost += costForUsage(u.model, u);
     totalTokens += u.input_tokens + u.output_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens;
   }
+  const wfRuns = count("SELECT COUNT(*) n FROM workflow_results");
+  const metaRows = count("SELECT COUNT(*) n FROM session_meta");
+  const trRows = count("SELECT COUNT(*) n FROM tool_results");
   db.close();
   console.log(`agent-lens-ingest: files=${stats.files} skipped=${stats.skipped} new_events=${stats.newEvents} malformed=${stats.malformed}${pruned ? ` excluded_pruned=${pruned}` : ""}
   sessions=${sessions} turns=${turns} events=${events} tool_calls=${tools} classified=${classified.count}
+  workflow_results=${wfRuns} (sidecar upserted=${wfStats.upserted} skipped=${wfStats.skipped} malformed=${wfStats.malformed})
+  session_meta=${metaRows} (upserted=${metaStats.upserted} skipped=${metaStats.skipped} malformed=${metaStats.malformed})
+  tool_results=${trRows} (upserted=${trStats.upserted} skipped=${trStats.skipped} malformed=${trStats.malformed})
   tokens=${totalTokens.toLocaleString()} est_cost=$${cost.toFixed(2)} db=${dbPath}`);
 }
 function runMetrics(argv = process.argv.slice(2)) {
@@ -2763,7 +3182,7 @@ function runMetrics(argv = process.argv.slice(2)) {
     if (argv[i] === "--db")
       dbArg = argv[++i] ?? "";
   const dataDir = resolveDataDir(findRepoRoot());
-  const dbPath = dbArg || process.env.AGENT_LENS_DB || join5(dataDir, "agent-lens.db");
+  const dbPath = dbArg || process.env.AGENT_LENS_DB || join8(dataDir, "agent-lens.db");
   if (!existsSync4(dbPath)) {
     console.error(`agent-lens-metrics: db not found: ${dbPath} (run ingest first)`);
     process.exit(1);
@@ -2776,7 +3195,7 @@ function runMetrics(argv = process.argv.slice(2)) {
 
 // ../server/dist/run.js
 import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname5, join as join7 } from "path";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../server/dist/db.js
@@ -2786,6 +3205,12 @@ function openReadonly(file) {
   db.pragma("query_only = ON");
   return db;
 }
+function schemaStatus(db) {
+  const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+  const dbVersion = row ? Number(row.value) : null;
+  const db_version = dbVersion != null && Number.isFinite(dbVersion) ? dbVersion : null;
+  return { db_version, expected: SCHEMA_VERSION, stale: db_version != null && db_version !== SCHEMA_VERSION };
+}
 function lastIngested(db) {
   const row = db.prepare("SELECT MAX(ingested_at) AS last FROM ingest_state").get();
   return row?.last ?? null;
@@ -2858,21 +3283,47 @@ function listSessions(db, f) {
   }
   const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : "";
   const total = db.prepare(`SELECT COUNT(*) n FROM sessions s ${whereSql}`).get(...params).n;
-  const rows = db.prepare(`SELECT s.id, s.ai_title, s.slug, s.source_id, s.is_sidechain, s.started_at, s.ended_at,
+  const baseSelect = `SELECT s.id, s.ai_title, s.slug, s.source_id, s.is_sidechain, s.started_at, s.ended_at,
               s.duration_ms, s.event_count, s.turn_count, p.path AS project_path,
               (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models
        FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
-       ${whereSql}
-       ORDER BY s.started_at DESC
-       LIMIT ? OFFSET ?`).all(...params, f.limit, f.offset);
-  const ids = rows.map((r) => r.id);
+       ${whereSql}`;
+  const NATIVE_ORDER = {
+    started: "s.started_at",
+    title: "COALESCE(s.ai_title, s.slug)",
+    turns: "s.turn_count",
+    duration: "s.duration_ms"
+  };
+  const sortKey = f.sort ?? "started";
+  const sqlDir = f.dir === "asc" ? "ASC" : "DESC";
+  let rows;
+  if (sortKey === "tokens" || sortKey === "cost") {
+    const all = db.prepare(baseSelect).all(...params);
+    attachSessionCost(db, all);
+    const sign = f.dir === "asc" ? 1 : -1;
+    all.sort((a, b) => {
+      const c = (sortKey === "tokens" ? a.tokens - b.tokens : a.cost - b.cost) * sign;
+      return c !== 0 ? c : String(a.id).localeCompare(String(b.id));
+    });
+    rows = all.slice(f.offset, f.offset + f.limit);
+  } else {
+    const orderCol = NATIVE_ORDER[sortKey] ?? NATIVE_ORDER.started;
+    rows = db.prepare(`${baseSelect} ORDER BY ${orderCol} ${sqlDir}, s.id ASC LIMIT ? OFFSET ?`).all(...params, f.limit, f.offset);
+    attachSessionCost(db, rows);
+  }
+  return { total, sessions: rows };
+}
+function attachSessionCost(db, rows) {
   const costBySession = /* @__PURE__ */ new Map();
-  if (ids.length) {
-    const ph = ids.map(() => "?").join(",");
+  const ids = rows.map((r) => r.id);
+  const CHUNK3 = 800;
+  for (let i = 0; i < ids.length; i += CHUNK3) {
+    const batch = ids.slice(i, i + CHUNK3);
+    const ph = batch.map(() => "?").join(",");
     const usage = db.prepare(`SELECT session_id, model,
                 SUM(input_tokens) i, SUM(output_tokens) o,
                 SUM(cache_creation_input_tokens) cw, SUM(cache_read_input_tokens) cr
-         FROM token_usage WHERE session_id IN (${ph}) GROUP BY session_id, model`).all(...ids);
+         FROM token_usage WHERE session_id IN (${ph}) GROUP BY session_id, model`).all(...batch);
     for (const u of usage) {
       const acc = costBySession.get(u.session_id) ?? { tokens: 0, cost: 0, split: { input: 0, output: 0, cache_creation: 0, cache_read: 0 } };
       acc.tokens += u.i + u.o + u.cw + u.cr;
@@ -2896,7 +3347,6 @@ function listSessions(db, f) {
     r.cost = c ? Number(c.cost.toFixed(4)) : 0;
     r.title = r.ai_title || r.slug || null;
   }
-  return { total, sessions: rows };
 }
 function getSession(db, id) {
   const session = db.prepare(`SELECT s.*, p.path AS project_path FROM sessions s
@@ -2911,6 +3361,17 @@ function getSession(db, id) {
               total_duration_ms, total_tokens, input_json, result_summary,
               (SELECT COUNT(*) FROM sessions s WHERE s.workflow_run_id = tool_calls.workflow_run_id) AS workflow_agent_count
        FROM tool_calls WHERE session_id = ?`).all(id);
+  if (tableExists(db, "tool_results")) {
+    const getFull = db.prepare("SELECT text, bytes FROM tool_results WHERE session_id = ? AND name = ?");
+    for (const t of toolRows) {
+      const m = typeof t.result_summary === "string" ? t.result_summary.match(/tool-results\/([A-Za-z0-9_-]+)\.txt/) : null;
+      if (!m)
+        continue;
+      const full = getFull.get(id, m[1]);
+      if (full)
+        t.full_result = { text: full.text, bytes: full.bytes };
+    }
+  }
   const toolsByEvent = /* @__PURE__ */ new Map();
   for (const t of toolRows) {
     if (!t.event_uuid)
@@ -2978,9 +3439,12 @@ function getSession(db, id) {
     if (p)
       parent = { id: p.id, title: p.ai_title || p.slug || null, turn_seq: p.turn_seq ?? null };
   }
+  const hasMeta = tableExists(db, "session_meta");
   const children = db.prepare(`SELECT s.id, s.ai_title, s.slug, s.turn_count, s.started_at, s.workflow_run_id,
               (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models
-       FROM sessions s WHERE s.parent_session_id = ? ORDER BY s.started_at`).all(id);
+              ${hasMeta ? ", sm.agent_type, sm.agent_description, sm.spawn_depth" : ", NULL AS agent_type, NULL AS agent_description, NULL AS spawn_depth"}
+       FROM sessions s ${hasMeta ? "LEFT JOIN session_meta sm ON sm.session_id = s.id" : ""}
+       WHERE s.parent_session_id = ? ORDER BY s.started_at`).all(id);
   for (const ch of children) {
     ch.title = ch.ai_title || ch.slug || null;
     const u = db.prepare(`SELECT model, SUM(input_tokens) i, SUM(output_tokens) o,
@@ -2989,8 +3453,10 @@ function getSession(db, id) {
     ch.tokens = u.reduce((a, r) => a + r.i + r.o + r.cw + r.cr, 0);
     ch.cost = Number(u.reduce((a, r) => a + costForUsage(r.model, { input_tokens: r.i, output_tokens: r.o, cache_creation_input_tokens: r.cw, cache_read_input_tokens: r.cr }), 0).toFixed(4));
   }
+  const hasWR = tableExists(db, "workflow_results");
   const workflow_runs = db.prepare(`SELECT tc.workflow_run_id AS run_id, tc.workflow_name AS name, t.seq AS turn_seq,
               (SELECT COUNT(*) FROM sessions s WHERE s.workflow_run_id = tc.workflow_run_id) AS agent_count
+              ${hasWR ? ", (SELECT status FROM workflow_results wr WHERE wr.run_id = tc.workflow_run_id) AS status" : ", NULL AS status"}
        FROM tool_calls tc LEFT JOIN turns t ON t.id = tc.turn_id
        WHERE tc.session_id = ? AND tc.workflow_run_id IS NOT NULL
        ORDER BY t.seq`).all(id);
@@ -2999,8 +3465,21 @@ function getSession(db, id) {
 function xmlTag(text, tag) {
   return text.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`))?.[1]?.trim() ?? null;
 }
+function tableExists(db, name) {
+  return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?").get(name);
+}
+function safeJson(s) {
+  if (!s)
+    return null;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
 function getWorkflow(db, runId) {
   const wf = db.prepare(`SELECT tc.id AS tool_use_id, tc.workflow_run_id AS run_id, tc.workflow_name AS name, tc.status, tc.result_summary,
+              tc.input_json AS input_json,
               tc.session_id AS parent_session_id, t.seq AS turn_seq,
               ps.ai_title AS parent_ai_title, ps.slug AS parent_slug
        FROM tool_calls tc
@@ -3011,9 +3490,12 @@ function getWorkflow(db, runId) {
        LIMIT 1`).get(runId);
   if (!wf)
     return null;
+  const hasMeta = tableExists(db, "session_meta");
   const agents = db.prepare(`SELECT s.id, s.ai_title, s.slug, s.turn_count, s.started_at, s.ended_at, s.duration_ms,
               (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models
-       FROM sessions s WHERE s.workflow_run_id = ? ORDER BY s.started_at`).all(runId);
+              ${hasMeta ? ", sm.agent_type, sm.agent_description, sm.spawn_depth" : ", NULL AS agent_type, NULL AS agent_description, NULL AS spawn_depth"}
+       FROM sessions s ${hasMeta ? "LEFT JOIN session_meta sm ON sm.session_id = s.id" : ""}
+       WHERE s.workflow_run_id = ? ORDER BY s.started_at`).all(runId);
   let total_tokens = 0;
   let total_cost = 0;
   let started_at = null;
@@ -3044,12 +3526,44 @@ function getWorkflow(db, runId) {
       completion = { status: xmlTag(t, "status"), summary: xmlTag(t, "summary"), result: xmlTag(t, "result"), failures: xmlTag(t, "failures") };
     }
   }
+  const wr = tableExists(db, "workflow_results") ? db.prepare(`SELECT status, summary, default_model, result_json, phases_json, logs_json, progress_json,
+                  agent_count, total_tokens, total_tool_calls, duration_ms, started_at, ended_at
+           FROM workflow_results WHERE run_id = ?`).get(wf.run_id) : null;
+  let run = null;
+  if (wr) {
+    run = {
+      status: wr.status ?? null,
+      summary: wr.summary ?? null,
+      default_model: wr.default_model ?? null,
+      agent_count: wr.agent_count ?? null,
+      total_tokens: wr.total_tokens ?? null,
+      total_tool_calls: wr.total_tool_calls ?? null,
+      duration_ms: wr.duration_ms ?? null,
+      started_at: wr.started_at ?? null,
+      ended_at: wr.ended_at ?? null,
+      phases: safeJson(wr.phases_json),
+      logs: safeJson(wr.logs_json),
+      // The per-phase/per-agent event timeline (workflowProgress) — lets the page render a phase graph
+      // with a per-phase descriptor (agent count, models). Absent on older/failed runs → UI falls back.
+      progress: safeJson(wr.progress_json)
+    };
+    if (wr.result_json != null || wr.status) {
+      completion = {
+        status: wr.status ?? completion?.status ?? null,
+        summary: wr.summary ?? completion?.summary ?? null,
+        result: wr.result_json ?? completion?.result ?? null,
+        failures: completion?.failures ?? null
+      };
+    }
+  }
   return {
     run_id: wf.run_id,
     name: wf.name ?? null,
-    status: wf.status ?? null,
+    status: wr?.status ?? wf.status ?? null,
     result_summary: wf.result_summary ?? null,
+    input_json: wf.input_json ?? null,
     completion,
+    run,
     parent: { id: wf.parent_session_id, title: wf.parent_ai_title || wf.parent_slug || null, turn_seq: wf.turn_seq ?? null },
     agents,
     stats: { agent_count: agents.length, total_tokens, total_cost: Number(total_cost.toFixed(4)), started_at, ended_at, duration_ms }
@@ -3058,8 +3572,11 @@ function getWorkflow(db, runId) {
 function listSkills(db, f = {}) {
   const where = ["tc.tool_name = 'Skill'", "tc.skill_name IS NOT NULL"];
   const params = [];
-  if (f.q && f.q.trim())
-    where.push("tc.skill_name LIKE ?"), params.push(`%${f.q.trim()}%`);
+  if (f.q && f.q.trim()) {
+    const like = `%${f.q.trim()}%`;
+    where.push("(tc.skill_name LIKE ? OR EXISTS (SELECT 1 FROM skills sk WHERE sk.name = tc.skill_name AND sk.body LIKE ?))");
+    params.push(like, like);
+  }
   if (f.source)
     where.push("s.source_id = ?"), params.push(f.source);
   if (f.project)
@@ -3276,7 +3793,7 @@ function dashboardBreakdowns(db, f) {
 
 // ../server/dist/refresh.js
 import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
-import { join as join6 } from "path";
+import { join as join9 } from "path";
 function originAllowed(origin) {
   if (!origin)
     return true;
@@ -3289,12 +3806,12 @@ function originAllowed(origin) {
 }
 function runRefresh() {
   const dataDir = resolveDataDir(findRepoRoot());
-  const lock = acquireLock(join6(dataDir, ".agent-lens.lock"));
+  const lock = acquireLock(join9(dataDir, ".agent-lens.lock"));
   if (!lock)
     return null;
   try {
     const collected = collectAll();
-    const archiveRoot = process.env.AGENT_LENS_ARCHIVE || join6(dataDir, "archive");
+    const archiveRoot = process.env.AGENT_LENS_ARCHIVE || join9(dataDir, "archive");
     if (!existsSync5(archiveRoot))
       mkdirSync5(archiveRoot, { recursive: true });
     runIngest([]);
@@ -3307,7 +3824,10 @@ function runRefresh() {
 // ../server/dist/app.js
 async function createApp(db, opts = {}) {
   const app = Fastify({ logger: false });
-  app.get("/api/health", async () => ({ ok: true, last_ingested: lastIngested(db) }));
+  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 };
+  });
   app.post("/api/refresh", async (req, reply) => {
     if (!originAllowed(req.headers.origin)) {
       return reply.code(403).send({ error: { code: "FORBIDDEN_ORIGIN", message: "cross-origin refresh blocked" } });
@@ -3346,6 +3866,8 @@ async function createApp(db, opts = {}) {
       from: q.from,
       to: q.to,
       kind: q.kind === "main" || q.kind === "subagent" ? q.kind : void 0,
+      sort: ["started", "title", "turns", "tokens", "cost", "duration"].find((s) => s === q.sort),
+      dir: q.dir === "asc" ? "asc" : q.dir === "desc" ? "desc" : void 0,
       limit: Math.min(Number(q.limit) || 50, 200),
       offset: Number(q.offset) || 0
     });
@@ -3421,7 +3943,7 @@ async function createApp(db, opts = {}) {
 async function startServer() {
   const here = dirname5(fileURLToPath2(import.meta.url));
   const repoRoot = findRepoRoot(here);
-  const dbPath = process.env.AGENT_LENS_DB || join7(resolveDataDir(repoRoot), "agent-lens.db");
+  const dbPath = process.env.AGENT_LENS_DB || join10(resolveDataDir(repoRoot), "agent-lens.db");
   const host = process.env.AGENT_LENS_HOST || "127.0.0.1";
   const port = Number(process.env.AGENT_LENS_PORT || 4477);
   const webDist = resolveWebDist(here, repoRoot);
@@ -3448,11 +3970,11 @@ async function startServer() {
 
 // src/watch.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { join as join11 } from "path";
 import chokidar from "chokidar";
 async function runWatch(opts = {}) {
   const sources = loadSources();
-  const lockPath = join8(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  const lockPath = join11(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
   let running = false;
   let pending = false;
   const cycle = () => {
@@ -3485,7 +4007,7 @@ async function runWatch(opts = {}) {
     }
   };
   cycle();
-  const watchPaths = sources.map((s) => join8(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");
   }
@@ -3513,14 +4035,14 @@ async function runWatch(opts = {}) {
 // src/index.ts
 function version() {
   try {
-    const pkg = JSON.parse(readFileSync5(join9(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 = join9(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");