@swestash/agent-lens 0.17.0 → 0.17.2

package/dist/agent-lens.js

@@ -592,6 +592,11 @@ var cac = (name = "") => new CAC(name);
 
 // ../core/dist/schema.js
 var SCHEMA_VERSION = 15;
+var ANALYZE_SQL = "PRAGMA analysis_limit = 1000; ANALYZE;";
+var BULK_DEFERRED = {
+  indexes: ["idx_events_type", "idx_events_ts", "idx_events_turn_reply", "idx_events_uuid_cover"],
+  triggers: ["events_ai", "events_ad", "events_au"]
+};
 var SCHEMA_SQL = (
   /* sql */
   `
@@ -694,9 +699,22 @@ CREATE TABLE IF NOT EXISTS events (
   source_file  TEXT                      -- archive path the canonical copy came from
 );
 CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
-CREATE INDEX IF NOT EXISTS idx_events_turn ON events(turn_id);
 CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
 CREATE INDEX IF NOT EXISTS idx_events_ts ON events(timestamp);
+-- Covering indexes for the dashboard joins. An events row averages ~3.4 KB (raw_json + text), so
+-- about one row fits per page, and a join that reads the row instead of an index pays one random
+-- page read per event: on the real corpus /dashboard/time took 31s from a cold cache. These hold
+-- exactly the columns those joins read. The PK lookups (token_usage, tool_calls, findings,
+-- file_changes \u2192 events by uuid) want timestamp and model, and model latency wants the first
+-- assistant timestamp per turn. Both are index-only scans now, and the guard in
+-- packages/server/test/query-plans.test.ts keeps them that way.
+-- No SCHEMA_VERSION bump: indexes need no rebuild, and CREATE IF NOT EXISTS adds them on the next
+-- incremental ingest. A bump would make that ingest refuse and demand --full.
+-- An index's columns cannot be widened in place, so idx_events_turn is replaced under a new name.
+-- idx_events_turn_reply serves every lookup the old one did, because turn_id is still its prefix.
+DROP INDEX IF EXISTS idx_events_turn;
+CREATE INDEX IF NOT EXISTS idx_events_turn_reply ON events(turn_id, role, timestamp);
+CREATE INDEX IF NOT EXISTS idx_events_uuid_cover ON events(uuid, timestamp, model);
 
 -- Tool invocations (incl. subagents / Task calls). -------------------------
 CREATE TABLE IF NOT EXISTS tool_calls (
@@ -721,13 +739,32 @@ CREATE TABLE IF NOT EXISTS tool_calls (
   input_json          TEXT,              -- tool input, verbatim
   result_summary      TEXT               -- short result projection (no secrets dumped wholesale)
 );
-CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id);
-CREATE INDEX IF NOT EXISTS idx_tool_calls_tool ON tool_calls(tool_name);
-CREATE INDEX IF NOT EXISTS idx_tool_calls_skill ON tool_calls(skill_name);
-CREATE INDEX IF NOT EXISTS idx_tool_calls_skill_id ON tool_calls(skill_id);
+-- Covering indexes for the dashboard aggregates. A tool_calls row averages ~2.3 KB (input_json), and
+-- the aggregates read only a handful of narrow columns. Each index below carries all of them, so
+-- whether the planner drives from sessions (a selective source/date filter) or scans tool_calls
+-- (no filter), it never reads the row. Before this, the errored-calls series scanned the whole
+-- table, 7.5s cold on the real corpus. packages/server/test/query-plans.test.ts holds the line.
+-- They replace the single-column session/tool/skill/skill_id/error_type indexes under new names, because
+-- CREATE IF NOT EXISTS cannot widen an index that already exists. Each new index begins with the old
+-- index's column, so every existing lookup still uses it. Same no-bump reasoning as the events
+-- indexes above.
+DROP INDEX IF EXISTS idx_tool_calls_session;
+DROP INDEX IF EXISTS idx_tool_calls_tool;
+DROP INDEX IF EXISTS idx_tool_calls_skill;
+DROP INDEX IF EXISTS idx_tool_calls_skill_id;
+DROP INDEX IF EXISTS idx_tool_calls_error_type;
+CREATE INDEX IF NOT EXISTS idx_tool_calls_by_session
+  ON tool_calls(session_id, tool_name, status, error_type, skill_name, skill_id, agent_type, event_uuid);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_by_tool     ON tool_calls(tool_name, session_id, status, error_type, event_uuid);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_by_skill    ON tool_calls(skill_name, skill_id, session_id, event_uuid);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_by_skill_id ON tool_calls(skill_id, skill_name, session_id, event_uuid);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_by_error   ON tool_calls(error_type, status, session_id, event_uuid);
 CREATE INDEX IF NOT EXISTS idx_tool_calls_spawned ON tool_calls(spawned_session_id);
 CREATE INDEX IF NOT EXISTS idx_tool_calls_workflow_run ON tool_calls(workflow_run_id);
-CREATE INDEX IF NOT EXISTS idx_tool_calls_error_type ON tool_calls(error_type);
+-- Every column that REFERENCES turns(id) needs an index: deleting a turn makes SQLite look up its
+-- referencing rows, and without one that is a full scan of this table per deleted turn. The
+-- incremental rebuild deletes the dirty sessions' turns, so five changed files cost 12.9 GB of reads.
+CREATE INDEX IF NOT EXISTS idx_tool_calls_turn ON tool_calls(turn_id);
 
 -- Skill *versions* (content-addressed). A skill firing injects the full SKILL.md body into the
 -- transcript as an isMeta user event (begins "Base directory for this skill: \u2026", then the body,
@@ -767,6 +804,8 @@ CREATE TABLE IF NOT EXISTS token_usage (
   service_tier                TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_token_usage_session ON token_usage(session_id);
+-- Foreign-key lookup for deleting turns; see idx_tool_calls_turn.
+CREATE INDEX IF NOT EXISTS idx_token_usage_turn ON token_usage(turn_id);
 -- Partial so rare usage rows lacking a message_id (e.g. <synthetic>) don't collide on NULL. --
 CREATE UNIQUE INDEX IF NOT EXISTS idx_token_usage_msg
   ON token_usage(session_id, message_id) WHERE message_id IS NOT NULL;
@@ -2282,9 +2321,11 @@ import { dirname as dirname6, join as join9 } from "node:path";
 
 // ../ingest/dist/db.js
 import { DatabaseSync } from "node:sqlite";
+var WAL_SIZE_LIMIT = 64 * 1024 * 1024;
 function openRaw(file) {
   const db = new DatabaseSync(file);
   db.exec("PRAGMA journal_mode = WAL");
+  db.exec(`PRAGMA journal_size_limit = ${WAL_SIZE_LIMIT}`);
   db.exec("PRAGMA foreign_keys = ON");
   return db;
 }
@@ -2304,7 +2345,7 @@ function openDb(file) {
   applySchema(db);
   return db;
 }
-function resetSchema(db) {
+function resetSchema(db, { bulk = false } = {}) {
   db.exec("PRAGMA foreign_keys = OFF");
   try {
     db.exec(`
@@ -2331,10 +2372,20 @@ function resetSchema(db) {
       DROP TABLE IF EXISTS meta;
     `);
     applySchema(db);
+    if (bulk) {
+      for (const name of BULK_DEFERRED.indexes)
+        db.exec(`DROP INDEX IF EXISTS ${name}`);
+      for (const name of BULK_DEFERRED.triggers)
+        db.exec(`DROP TRIGGER IF EXISTS ${name}`);
+    }
   } finally {
     db.exec("PRAGMA foreign_keys = ON");
   }
 }
+function finishBulkLoad(db) {
+  db.exec(SCHEMA_SQL);
+  db.exec("INSERT INTO events_fts(events_fts) VALUES('rebuild')");
+}
 
 // ../ingest/dist/adapters/claude-code.js
 import { readdirSync as readdirSync2 } from "node:fs";
@@ -3643,6 +3694,13 @@ function nearestGitRoot(path3, home) {
   }
   return null;
 }
+function sessionCwd(first, last) {
+  const f = strip(first);
+  const l = strip(last);
+  if (f === l || existsSync4(l))
+    return last;
+  return l.startsWith(f === "/" ? "/" : f + "/") ? first : last;
+}
 function canonicalizeProjects(db, opts = {}) {
   const home = strip(opts.homeDir ?? homedir3());
   const rows = db.prepare("SELECT id, agent_id, path FROM projects").all();
@@ -3729,6 +3787,77 @@ function xmlTag(text, tag) {
   return text.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`))?.[1]?.trim() ?? null;
 }
 
+// ../ingest/dist/skillslots.js
+var ARG_TRAILERS = ["\nARGUMENTS:", "\n## User Request\n"];
+var EMPTY_OUTPUT = "(Bash completed with no output)";
+var DYNAMIC_PLACEHOLDER = "(dynamic context: command output omitted)";
+var isMarker = (t) => t === EMPTY_OUTPUT || t === DYNAMIC_PLACEHOLDER;
+function uniqueLine(lines, text) {
+  let at = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() !== text)
+      continue;
+    if (at >= 0)
+      return -1;
+    at = i;
+  }
+  return at;
+}
+function learnSlots(body) {
+  const lines = body.split("\n");
+  const trimmed = lines.map((l) => l.trim());
+  const slots = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!isMarker(trimmed[i]))
+      continue;
+    let b = i - 1;
+    while (b >= 0 && trimmed[b] === "")
+      b--;
+    let a = i + 1;
+    while (a < lines.length && (trimmed[a] === "" || isMarker(trimmed[a])))
+      a++;
+    i = a - 1;
+    if (b < 0 || a >= lines.length)
+      continue;
+    const slot = { before: trimmed[b], after: trimmed[a] };
+    if (uniqueLine(lines, slot.before) < 0 || uniqueLine(lines, slot.after) < 0)
+      continue;
+    if (!slots.some((s) => s.before === slot.before && s.after === slot.after))
+      slots.push(slot);
+  }
+  return slots;
+}
+function mergeSlots(into, body) {
+  for (const s of learnSlots(body))
+    if (!into.some((x) => x.before === s.before && x.after === s.after))
+      into.push(s);
+  return into;
+}
+function maskDynamic(body, slots) {
+  let lines = body.split("\n");
+  for (const { before, after } of slots) {
+    const b = uniqueLine(lines, before);
+    const a = uniqueLine(lines, after);
+    if (b < 0 || a <= b)
+      continue;
+    lines = [...lines.slice(0, b + 1), "", DYNAMIC_PLACEHOLDER, "", ...lines.slice(a)];
+  }
+  return lines.join("\n");
+}
+var MIN_MASKED_ARGS = 8;
+function maskKnownValues(body, known) {
+  const subs = [];
+  const args = known.args?.trim();
+  if (args && args.length >= MIN_MASKED_ARGS)
+    subs.push([args, "$ARGUMENTS"]);
+  if (known.baseDir)
+    subs.push([known.baseDir, "${CLAUDE_SKILL_DIR}"]);
+  if (known.sessionId)
+    subs.push([known.sessionId, "${CLAUDE_SESSION_ID}"]);
+  subs.sort((x, y) => y[0].length - x[0].length);
+  return subs.reduce((out, [value, placeholder]) => out.split(value).join(placeholder), body);
+}
+
 // ../ingest/dist/pipeline.js
 function newStats() {
   return { files: 0, skipped: 0, malformed: 0, newEvents: 0 };
@@ -3750,9 +3879,15 @@ function parseSkillInjection(text) {
   const baseDir = firstLine || null;
   let body = firstNl >= 0 ? text.slice(firstNl + 1) : "";
   let args = null;
-  const argIdx = body.lastIndexOf("\nARGUMENTS:");
+  let argIdx = -1;
+  let trailer = "";
+  for (const t of ARG_TRAILERS) {
+    const i = body.lastIndexOf(t);
+    if (i > argIdx)
+      [argIdx, trailer] = [i, t];
+  }
   if (argIdx >= 0) {
-    args = body.slice(argIdx + "\nARGUMENTS:".length).trim() || null;
+    args = body.slice(argIdx + trailer.length).trim() || null;
     body = body.slice(0, argIdx);
   }
   return { baseDir, nameKey: baseDir ? skillNameKey(baseDir) : "", body: body.trim(), args };
@@ -3822,6 +3957,10 @@ function durationMs(start, end) {
     return null;
   return Math.max(0, b - a);
 }
+function isTurnStart(e) {
+  const body = e.text?.trim() ?? "";
+  return e.type === "user" && e.is_meta === 0 && body.length > 0 && !isCommandResultCarrier(body);
+}
 function buildTurns(sessionId, rows) {
   rows.sort((x, y) => (x.timestamp ?? "").localeCompare(y.timestamp ?? "") || (x.seq ?? 0) - (y.seq ?? 0) || x.uuid.localeCompare(y.uuid));
   const turns = [];
@@ -3829,9 +3968,7 @@ function buildTurns(sessionId, rows) {
   let cur = null;
   let seq = 0;
   for (const e of rows) {
-    const body = e.text?.trim() ?? "";
-    const isPrompt = e.type === "user" && e.is_meta === 0 && body.length > 0 && !isCommandResultCarrier(body);
-    if (isPrompt) {
+    if (isTurnStart(e)) {
       cur = {
         id: `${sessionId}:${seq}`,
         session_id: sessionId,
@@ -3888,7 +4025,7 @@ function expandDirtyScope(db, dirty) {
   }
 }
 function rebuildTurns(db, scope, sessionIds) {
-  const selEvents = db.prepare("SELECT uuid, seq, type, is_sidechain, is_meta, timestamp, model, text FROM events WHERE session_id = ?");
+  const selEvents = db.prepare("SELECT uuid, seq, type, is_sidechain, is_meta, timestamp, model, text, turn_id FROM events WHERE session_id = ?");
   const insTurn = db.prepare(`INSERT INTO turns (id, session_id, seq, user_event_uuid, prompt_preview, model, started_at, ended_at, duration_ms)
      VALUES (@id, @session_id, @seq, @user_event_uuid, @prompt_preview, @model, @started_at, @ended_at, @duration_ms)`);
   const updEventTurn = db.prepare("UPDATE events SET turn_id = ? WHERE uuid = ?");
@@ -3898,8 +4035,11 @@ function rebuildTurns(db, scope, sessionIds) {
       const { turns, eventTurn } = buildTurns(id, rows);
       for (const t of turns)
         runNamed(insTurn, t);
-      for (const [uuid, turnId] of eventTurn)
-        updEventTurn.run(turnId, uuid);
+      for (const r of rows) {
+        const turnId = eventTurn.get(r.uuid) ?? null;
+        if (turnId !== r.turn_id)
+          updEventTurn.run(turnId, r.uuid);
+      }
     }
   });
   tx();
@@ -3916,6 +4056,15 @@ function linkSkillVersions(db, sessionIds) {
        first_seen = MIN(first_seen, excluded.first_seen),
        base_dir   = excluded.base_dir`);
   const linkCall = db.prepare("UPDATE tool_calls SET skill_id = ? WHERE id = ?");
+  const selLinkedVersions = db.prepare("SELECT id, base_dir, body, first_seen, last_seen FROM skills WHERE name = ? AND id IN (SELECT skill_id FROM tool_calls WHERE skill_id IS NOT NULL)");
+  const upsertRemasked = db.prepare(`INSERT INTO skills (id, name, base_dir, body, summary, body_bytes, first_seen, last_seen)
+     VALUES (@id, @name, @base_dir, @body, @summary, @body_bytes, @first_seen, @last_seen)
+     ON CONFLICT(id) DO UPDATE SET
+       last_seen  = MAX(last_seen,  excluded.last_seen),
+       first_seen = MIN(first_seen, excluded.first_seen)`);
+  const relinkVersion = db.prepare("UPDATE tool_calls SET skill_id = ? WHERE skill_id = ?");
+  const delVersion = db.prepare("DELETE FROM skills WHERE id = ?");
+  const matches = [];
   const linkTx = transaction(db, () => {
     for (const { id: sid } of sessionIds) {
       const calls = selSkillCalls.all(sid);
@@ -3965,18 +4114,53 @@ function linkSkillVersions(db, sessionIds) {
           idx = 0;
         const [match] = queue.splice(idx, 1);
         const c = calls.find((x) => x.id === match.id);
-        const name = c.skill_name;
-        const vid = skillVersionId(name, inj.body);
-        upsertSkill.run({
+        const body = maskKnownValues(inj.body, { args: match.args ?? inj.args, baseDir: inj.baseDir, sessionId: sid });
+        matches.push({ callId: match.id, name: c.skill_name, baseDir: inj.baseDir, body, ts: e.timestamp });
+      }
+    }
+    const slotsByName = /* @__PURE__ */ new Map();
+    const addSlots = (name, body) => slotsByName.set(name, mergeSlots(slotsByName.get(name) ?? [], body));
+    for (const m of matches)
+      addSlots(m.name, m.body);
+    for (const name of slotsByName.keys()) {
+      for (const v of selLinkedVersions.all(name))
+        addSlots(name, v.body);
+    }
+    for (const m of matches) {
+      const body = maskDynamic(m.body, slotsByName.get(m.name));
+      const vid = skillVersionId(m.name, body);
+      upsertSkill.run({
+        id: vid,
+        name: m.name,
+        base_dir: m.baseDir,
+        body,
+        summary: skillSummary(body),
+        body_bytes: Buffer.byteLength(body, "utf8"),
+        ts: m.ts
+      });
+      linkCall.run(vid, m.callId);
+    }
+    for (const [name, slots] of slotsByName) {
+      if (!slots.length)
+        continue;
+      const versions = selLinkedVersions.all(name);
+      for (const v of versions) {
+        const body = maskDynamic(v.body, slots);
+        if (body === v.body)
+          continue;
+        const vid = skillVersionId(name, body);
+        upsertRemasked.run({
           id: vid,
           name,
-          base_dir: inj.baseDir,
-          body: inj.body,
-          summary: skillSummary(inj.body),
-          body_bytes: Buffer.byteLength(inj.body, "utf8"),
-          ts: e.timestamp
+          base_dir: v.base_dir,
+          body,
+          summary: skillSummary(body),
+          body_bytes: Buffer.byteLength(body, "utf8"),
+          first_seen: v.first_seen,
+          last_seen: v.last_seen
         });
-        linkCall.run(vid, match.id);
+        relinkVersion.run(vid, v.id);
+        delVersion.run(v.id);
       }
     }
   });
@@ -4035,26 +4219,28 @@ function rebuildDerived(db, dirty) {
     andId: incremental ? " AND id IN (SELECT id FROM _dirty)" : "",
     andSelfId: incremental ? " AND sessions.id IN (SELECT id FROM _dirty)" : ""
   };
-  if (dirty != null)
-    expandDirtyScope(db, dirty);
-  db.exec(`UPDATE events SET turn_id = NULL${scope.bySession}`);
-  db.exec(`UPDATE token_usage SET turn_id = NULL${scope.bySession}`);
-  db.exec(`UPDATE tool_calls SET turn_id = NULL${scope.bySession}`);
-  db.exec(`UPDATE tool_calls SET skill_id = NULL${scope.bySession}`);
-  db.exec(`UPDATE sessions SET parent_turn_id = NULL${scope.byId}`);
-  db.exec(`DELETE FROM turns${scope.bySession}`);
-  const sessionIds = db.prepare(`SELECT id FROM sessions${scope.byId}`).all();
-  rebuildTurns(db, scope, sessionIds);
-  linkSkillVersions(db, sessionIds);
-  linkParents(db, scope);
-  recomputeSessionAggregates(db, scope);
-  pruneOrphans(db, scope, incremental);
-  if (incremental) {
-    const expanded = new Set(db.prepare("SELECT id FROM _dirty").all().map((r) => r.id));
-    db.exec("DROP TABLE IF EXISTS _dirty");
-    return expanded;
-  }
-  return null;
+  return transaction(db, () => {
+    if (dirty != null)
+      expandDirtyScope(db, dirty);
+    db.exec("PRAGMA defer_foreign_keys = ON");
+    db.exec(`UPDATE token_usage SET turn_id = NULL${scope.bySession}`);
+    db.exec(`UPDATE tool_calls SET turn_id = NULL${scope.bySession}`);
+    db.exec(`UPDATE tool_calls SET skill_id = NULL${scope.bySession}`);
+    db.exec(`UPDATE sessions SET parent_turn_id = NULL${scope.byId}`);
+    db.exec(`DELETE FROM turns${scope.bySession}`);
+    const sessionIds = db.prepare(`SELECT id FROM sessions${scope.byId}`).all();
+    rebuildTurns(db, scope, sessionIds);
+    linkSkillVersions(db, sessionIds);
+    linkParents(db, scope);
+    recomputeSessionAggregates(db, scope);
+    pruneOrphans(db, scope, incremental);
+    if (incremental) {
+      const expanded = new Set(db.prepare("SELECT id FROM _dirty").all().map((r) => r.id));
+      db.exec("DROP TABLE IF EXISTS _dirty");
+      return expanded;
+    }
+    return null;
+  })();
 }
 function prepareStatements(db) {
   return {
@@ -4111,9 +4297,11 @@ function prepareStatements(db) {
          workflow_run_id = COALESCE(excluded.workflow_run_id, workflow_run_id)`)
   };
 }
-function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
+function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats, opts = {}) {
   const sessionMeta = {};
   let eventsInFile = 0;
+  let turnSeq = -1;
+  let firstCwd = null;
   const tx = transaction(db, () => {
     stmts.insSessionStub.run(file.sessionId, adapter.agentId, file.sourceId);
     let seq = 0;
@@ -4128,10 +4316,19 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
         continue;
       }
       const parsed = adapter.parseLine(raw, file, seq++);
-      if (parsed.meta)
+      if (parsed.meta) {
+        if (parsed.meta.cwd && firstCwd === null)
+          firstCwd = parsed.meta.cwd;
         Object.assign(sessionMeta, parsed.meta);
+      }
       if (parsed.event) {
-        const info = stmts.insEvent.run({ ...parsed.event, raw_json: packRaw(parsed.event.raw_json) });
+        let turnId = parsed.event.turn_id;
+        if (opts.provisionalTurns) {
+          if (isTurnStart(parsed.event))
+            turnSeq++;
+          turnId = turnSeq < 0 ? null : `${file.sessionId}:${turnSeq}`;
+        }
+        const info = stmts.insEvent.run({ ...parsed.event, turn_id: turnId, raw_json: packRaw(parsed.event.raw_json) });
         if (info.changes > 0) {
           stats.newEvents++;
           eventsInFile++;
@@ -4160,11 +4357,12 @@ function ingestFile(db, stmts, adapter, file, lines, meta, now2, stats) {
     }
     let projectId2 = null;
     if (sessionMeta.cwd) {
-      projectId2 = createHash5("sha1").update(`${adapter.agentId}\0${sessionMeta.cwd}`).digest("hex").slice(0, 16);
+      const cwd = sessionCwd(firstCwd ?? sessionMeta.cwd, sessionMeta.cwd);
+      projectId2 = createHash5("sha1").update(`${adapter.agentId}\0${cwd}`).digest("hex").slice(0, 16);
       stmts.upsertProject.run({
         id: projectId2,
         agent_id: adapter.agentId,
-        path: sessionMeta.cwd,
+        path: cwd,
         encoded_dir: file.encodedDir || null,
         now: now2
       });
@@ -4503,6 +4701,13 @@ function shouldReingest(path3, size, mtimeMs, prev) {
     return { action: "skip-hash", hash: hash2 };
   return { action: "ingest", hash: hash2, buf };
 }
+function assertForeignKeys(db) {
+  const bad = db.prepare("PRAGMA foreign_key_check").all();
+  if (!bad.length)
+    return;
+  const edges = [...new Set(bad.map((b) => `${b.table} -> ${b.parent}`))].join(", ");
+  throw new Error(`agent-lens-ingest: --full produced ${bad.length} foreign-key violations (${edges}); rolled back`);
+}
 function printIngestReport(db, dbPath, r) {
   const count = (sql) => db.prepare(sql).get().n;
   const sessions = count("SELECT COUNT(*) n FROM sessions");
@@ -4549,9 +4754,7 @@ function runIngest(argv = process.argv.slice(2)) {
   }
   mkdirSync4(dirname6(dbPath), { recursive: true });
   const db = args.full ? openRaw(dbPath) : openDb(dbPath);
-  if (args.full) {
-    resetSchema(db);
-  } else {
+  if (!args.full) {
     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.`);
@@ -4565,62 +4768,81 @@ function runIngest(argv = process.argv.slice(2)) {
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const excludePaths = loadExcludes();
   const excludedDirs = parseExcludes(excludePaths.join(","));
-  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);
-    if (!adapter) {
-      console.warn(`agent-lens-ingest: no adapter for agent '${source.agent}' (source '${source.label}') \u2014 skipping`);
-      continue;
-    }
-    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);
-    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 = statSync3(file.path);
-      const mtimeMs = Math.trunc(st.mtimeMs);
-      const prev = args.full ? void 0 : stmts.getState.get(file.path);
-      const decision = shouldReingest(file.path, st.size, mtimeMs, prev);
-      if (decision.action === "skip-stat") {
-        stats.skipped++;
-        continue;
-      }
-      if (decision.action === "skip-hash") {
-        stmts.setState.run({
-          file_path: file.path,
-          size: st.size,
-          mtime_ms: mtimeMs,
-          sha256: decision.hash,
-          events_ingested: prev.events_ingested,
-          ingested_at: now2
-        });
-        stats.skipped++;
-        continue;
+  const pruned = args.full ? 0 : pruneExcluded(db, excludePaths);
+  if (args.full)
+    db.exec("PRAGMA foreign_keys = OFF");
+  let report;
+  try {
+    report = transaction(db, () => {
+      if (args.full)
+        resetSchema(db, { bulk: true });
+      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);
+        if (!adapter) {
+          console.warn(`agent-lens-ingest: no adapter for agent '${source.agent}' (source '${source.label}') \u2014 skipping`);
+          continue;
+        }
+        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);
+        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 = statSync3(file.path);
+          const mtimeMs = Math.trunc(st.mtimeMs);
+          const prev = args.full ? void 0 : stmts.getState.get(file.path);
+          const decision = shouldReingest(file.path, st.size, mtimeMs, prev);
+          if (decision.action === "skip-stat") {
+            stats.skipped++;
+            continue;
+          }
+          if (decision.action === "skip-hash") {
+            stmts.setState.run({
+              file_path: file.path,
+              size: st.size,
+              mtime_ms: mtimeMs,
+              sha256: decision.hash,
+              events_ingested: prev.events_ingested,
+              ingested_at: now2
+            });
+            stats.skipped++;
+            continue;
+          }
+          const lines = decision.buf ? decision.buf.toString("utf8").split("\n") : streamLines(file.path);
+          ingestFile(db, stmts, adapter, file, lines, { size: st.size, mtimeMs, hash: decision.hash }, now2, stats, { provisionalTurns: args.full });
+          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);
       }
-      const lines = decision.buf ? decision.buf.toString("utf8").split("\n") : streamLines(file.path);
-      ingestFile(db, stmts, adapter, file, lines, { size: st.size, mtimeMs, hash: decision.hash }, 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);
+      const expanded = rebuildDerived(db, args.full ? null : dirty);
+      if (args.full)
+        finishBulkLoad(db);
+      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);
+      db.exec(ANALYZE_SQL);
+      if (args.full)
+        assertForeignKeys(db);
+      return { stats, classified, detected, fileChanges, wfStats, metaStats, trStats };
+    })();
+  } finally {
+    if (args.full)
+      db.exec("PRAGMA foreign_keys = ON");
   }
-  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);
-  printIngestReport(db, dbPath, { stats, pruned, classified, detected, fileChanges, wfStats, metaStats, trStats });
+  db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  printIngestReport(db, dbPath, { ...report, pruned });
 }
 function runMetrics(argv = process.argv.slice(2)) {
   let dbArg = "";
@@ -4739,9 +4961,11 @@ function costOf(rows) {
 }
 
 // ../server/dist/db.js
+var READ_CACHE_KIB = 64 * 1024;
 function openReadonly(file) {
   const db = new DatabaseSync2(file, { readOnly: true });
   db.exec("PRAGMA query_only = ON");
+  db.exec(`PRAGMA cache_size = -${READ_CACHE_KIB}`);
   return db;
 }
 function schemaStatus(db) {
@@ -6161,6 +6385,31 @@ function setPref(db, key, value) {
      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
 }
 
+// ../server/dist/response-cache.js
+function dataVersionCache(db, max = 64) {
+  const version2 = db.prepare("PRAGMA data_version");
+  const entries = /* @__PURE__ */ new Map();
+  let seen;
+  return (key, compute) => {
+    const v = version2.get().data_version;
+    if (v !== seen) {
+      entries.clear();
+      seen = v;
+    }
+    if (entries.has(key)) {
+      const hit = entries.get(key);
+      entries.delete(key);
+      entries.set(key, hit);
+      return hit;
+    }
+    const value = compute();
+    entries.set(key, value);
+    if (entries.size > max)
+      entries.delete(entries.keys().next().value);
+    return value;
+  };
+}
+
 // ../server/dist/app.js
 function notFound(reply, message = "not found") {
   return reply.code(404).send({ error: { code: "NOT_FOUND", message } });
@@ -6239,19 +6488,20 @@ async function createApp(db, opts = {}) {
     const q = req.query;
     return { source: q.source, from: q.from, to: q.to, models: q.models?.split(",").filter(Boolean) };
   };
-  app.get("/api/dashboard/overview", async (req) => dashboardOverview(db, dashFilters(req)));
+  const cached2 = dataVersionCache(db);
+  app.get("/api/dashboard/overview", async (req) => cached2(req.url, () => dashboardOverview(db, dashFilters(req))));
   app.get("/api/dashboard/timeseries", async (req) => {
     const q = req.query;
-    return dashboardTimeseries(db, dashFilters(req), q.bucket);
+    return cached2(req.url, () => dashboardTimeseries(db, dashFilters(req), q.bucket));
   });
-  app.get("/api/dashboard/breakdowns", async (req) => dashboardBreakdowns(db, dashFilters(req)));
+  app.get("/api/dashboard/breakdowns", async (req) => cached2(req.url, () => dashboardBreakdowns(db, dashFilters(req))));
   app.get("/api/dashboard/time", async (req) => {
     const q = req.query;
-    return dashboardTime(db, dashFilters(req), q.bucket);
+    return cached2(req.url, () => dashboardTime(db, dashFilters(req), q.bucket));
   });
   app.get("/api/dashboard/audit", async (req) => {
     const q = req.query;
-    return dashboardAudit(db, dashFilters(req), q.bucket);
+    return cached2(req.url, () => dashboardAudit(db, dashFilters(req), q.bucket));
   });
   const PREF_KEY = /^[a-z0-9._-]{1,64}$/i;
   app.get("/api/prefs/:key", async (req, reply) => {