@swestash/agent-lens 0.14.1 → 0.16.0

package/dist/agent-lens.js

@@ -812,9 +812,9 @@ 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
+-- File modifications derived from tool calls (ADR-022). One row per (tool_call, file):
+-- Edit/Write/NotebookEdit are 1:1; a Bash call can write several files, which the hash id already
+-- accommodated 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).
@@ -826,7 +826,7 @@ CREATE TABLE IF NOT EXISTS file_changes (
   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
+  tool_name      TEXT NOT NULL,                   -- Edit | Write | NotebookEdit | Bash
   lines_added    INTEGER,                         -- newline-count delta (NULL when unknowable)
   lines_removed  INTEGER,
   timestamp      TEXT,                            -- ISO8601, from the tool call's event
@@ -1363,6 +1363,10 @@ function rateForModel(model) {
   }
   return best?.rate ?? null;
 }
+var DATED_SNAPSHOT = /-\d{8}$/;
+function canonicalModel(model) {
+  return model && DATED_SNAPSHOT.test(model) ? model.slice(0, -9) : model;
+}
 function costForUsage(model, u) {
   const r = rateForModel(model);
   if (!r)
@@ -3423,8 +3427,98 @@ function classifyErrors(db, dirty) {
 // ../ingest/dist/filechanges.js
 import { createHash as createHash3 } from "node:crypto";
 import { posix as path2 } from "node:path";
-var FILECHANGES_VERSION = 1;
-var FILE_TOOLS = ["Edit", "Write", "NotebookEdit"];
+
+// ../ingest/dist/shellwrites.js
+var TARGET = `"([^"]+)"|'([^']+)'|([^\\s;|&<>()]+)`;
+var REDIRECT = new RegExp(`(?:^|[\\s;|&(])\\d?>{1,2}\\s*(?:${TARGET})`, "g");
+var TEE = new RegExp(`(?:^|[\\s;|&(])tee\\s+(?:-a\\s+)?(?:${TARGET})`, "g");
+var SED_I = new RegExp(`(?:^|[\\s;|&(])sed\\s+(?:-[a-zA-Z]*i[a-zA-Z]*(?:\\.\\w+)?)\\s+(?:(?:-e\\s+)?(?:'[^']*'|"[^"]*"|\\S+)\\s+)+?(?:${TARGET})`, "g");
+var CD = new RegExp(`^\\s*cd\\s+(?:${TARGET})`);
+var HEREDOC = /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1/g;
+var REDIRECT_BEFORE_HEREDOC = new RegExp(`\\d?>{1,2}\\s*(?:${TARGET})\\s*$`);
+function target(m, first) {
+  return m[first] ?? m[first + 1] ?? m[first + 2] ?? null;
+}
+function usable(path3) {
+  if (!path3)
+    return false;
+  if (/[$*?`~]/.test(path3))
+    return false;
+  if (path3.startsWith("&"))
+    return false;
+  if (path3 === "/dev/null" || path3.startsWith("/dev/"))
+    return false;
+  return true;
+}
+function bodyLines(body) {
+  const trimmed = body.replace(/\n$/, "");
+  return trimmed === "" ? 0 : trimmed.split("\n").length;
+}
+function stripHeredocs(command) {
+  const writes = [];
+  let scan = command;
+  HEREDOC.lastIndex = 0;
+  let m;
+  while (m = HEREDOC.exec(scan)) {
+    const delim = m[2];
+    const openerEnd = scan.indexOf("\n", m.index);
+    if (openerEnd === -1)
+      break;
+    const terminator = new RegExp(`^[ \\t]*${delim}[ \\t]*$`, "m");
+    const rest = scan.slice(openerEnd + 1);
+    const end = rest.search(terminator);
+    const bodyEnd = end === -1 ? rest.length : end;
+    const before = scan.slice(0, m.index);
+    const red = before.match(REDIRECT_BEFORE_HEREDOC);
+    if (red) {
+      const p = target(red, 1);
+      if (usable(p))
+        writes.push({ at: red.index ?? m.index, write: { path: p, linesAdded: bodyLines(rest.slice(0, bodyEnd)) } });
+    }
+    const stripEnd = end === -1 ? scan.length : openerEnd + 1 + bodyEnd + delim.length;
+    scan = scan.slice(0, m.index) + " ".repeat(stripEnd - m.index) + scan.slice(stripEnd);
+    HEREDOC.lastIndex = stripEnd;
+  }
+  return { scan, writes };
+}
+function parseShellWrites(command) {
+  if (typeof command !== "string" || !command)
+    return { cwd: null, writes: [] };
+  const cdMatch = command.match(CD);
+  const cdPath = cdMatch ? target(cdMatch, 1) : null;
+  const cwd = cdPath && cdPath.startsWith("/") && !/[$*?`~]/.test(cdPath) ? cdPath : null;
+  const { scan, writes: found } = stripHeredocs(command);
+  for (const [re, group] of [
+    [REDIRECT, 1],
+    [TEE, 1],
+    [SED_I, 1]
+  ]) {
+    re.lastIndex = 0;
+    let m;
+    while (m = re.exec(scan)) {
+      const p = target(m, group);
+      if (usable(p))
+        found.push({ at: m.index, write: { path: p, linesAdded: null } });
+    }
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const entry of found) {
+    const prev = byPath.get(entry.write.path);
+    if (!prev) {
+      byPath.set(entry.write.path, entry);
+      continue;
+    }
+    byPath.set(entry.write.path, {
+      at: Math.min(prev.at, entry.at),
+      write: { path: entry.write.path, linesAdded: prev.write.linesAdded ?? entry.write.linesAdded }
+    });
+  }
+  return { cwd, writes: [...byPath.values()].sort((a, b) => a.at - b.at).map((e) => e.write) };
+}
+
+// ../ingest/dist/filechanges.js
+var FILECHANGES_VERSION = 2;
+var FILE_TOOLS = ["Edit", "Write", "NotebookEdit", "Bash"];
 function fileChangeId(toolCallId, filePath) {
   return createHash3("sha1").update(toolCallId).update("\0").update(filePath).digest("hex").slice(0, 16);
 }
@@ -3485,31 +3579,40 @@ function deriveFileChanges(db, dirty) {
       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);
+      const targets = [];
+      if (row.tool_name === "Bash") {
+        const { cwd, writes } = parseShellWrites(input.command);
+        for (const w of writes) {
+          const filePath = normalizeFilePath(w.path, cwd ?? p?.path ?? null);
+          if (filePath)
+            targets.push({ filePath, added: w.linesAdded, removed: null });
+        }
+      } else {
+        const filePath = normalizeFilePath(input.file_path ?? input.notebook_path, p?.path ?? null);
+        if (filePath) {
+          targets.push({
+            filePath,
+            added: row.tool_name === "Edit" ? lineCount(input.new_string) : row.tool_name === "Write" ? lineCount(input.content) : null,
+            removed: row.tool_name === "Edit" ? lineCount(input.old_string) : null
+          });
+        }
+      }
+      for (const t of targets) {
+        insert.run({
+          id: fileChangeId(row.id, t.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: t.filePath,
+          tool_name: row.tool_name,
+          lines_added: t.added,
+          lines_removed: t.removed,
+          timestamp: row.timestamp,
+          derive_version: FILECHANGES_VERSION
+        });
       }
-      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();
@@ -3581,15 +3684,15 @@ function canonicalizeProjects(db, opts = {}) {
   const touched = /* @__PURE__ */ new Set();
   transaction(db, () => {
     for (const r of rows) {
-      const target = canon(r.path);
-      if (target === strip(r.path))
+      const target2 = canon(r.path);
+      if (target2 === strip(r.path))
         continue;
-      const targetId = byPath.get(target)?.id ?? projectId(r.agent_id, target);
+      const targetId = byPath.get(target2)?.id ?? projectId(r.agent_id, target2);
       if (targetId === r.id)
         continue;
-      if (!byPath.has(target)) {
-        upsertProject.run(targetId, r.agent_id, target);
-        byPath.set(target, { id: targetId, agent_id: r.agent_id });
+      if (!byPath.has(target2)) {
+        upsertProject.run(targetId, r.agent_id, target2);
+        byPath.set(target2, { id: targetId, agent_id: r.agent_id });
       }
       repointSessions.run(targetId, r.id);
       repointFileChanges.run(targetId, r.id);
@@ -4568,6 +4671,10 @@ function pushDateRange(clauses, params, col, from, to) {
     params.push(to);
   }
 }
+function canonModelSql(col) {
+  return `CASE WHEN ${col} GLOB '*-[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]'
+      THEN substr(${col}, 1, length(${col}) - 9) ELSE ${col} END`;
+}
 function metaJoin(hasMeta) {
   return hasMeta ? "LEFT JOIN session_meta sm ON sm.session_id = s.id" : "";
 }
@@ -4657,7 +4764,8 @@ function listProjects(db) {
      FROM projects p ORDER BY session_count DESC, p.path`);
 }
 function listModels(db) {
-  return queryAll(db, `SELECT DISTINCT model FROM token_usage WHERE model IS NOT NULL ORDER BY model`).map((r) => r.model);
+  return queryAll(db, `SELECT DISTINCT ${canonModelSql("m")} AS model
+     FROM (SELECT DISTINCT model m FROM token_usage WHERE model IS NOT NULL) ORDER BY 1`).map((r) => r.model);
 }
 function toFtsQuery(raw) {
   return raw.trim().split(/\s+/).filter(Boolean).map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
@@ -4709,8 +4817,8 @@ function listSessions(db, f) {
     params.push(...f.errorType);
   }
   if (f.model) {
-    where.push("EXISTS (SELECT 1 FROM token_usage t WHERE t.session_id = s.id AND t.model = ?)");
-    params.push(f.model);
+    where.push(`EXISTS (SELECT 1 FROM token_usage t WHERE t.session_id = s.id AND ${canonModelSql("t.model")} = ?)`);
+    params.push(canonicalModel(f.model));
   }
   if (f.q && f.q.trim()) {
     const like = `%${f.q.trim()}%`;
@@ -4723,7 +4831,7 @@ function listSessions(db, f) {
   const total = queryGet(db, `SELECT COUNT(*) n FROM sessions s ${whereSql}`, ...params).n;
   const baseSelect = `SELECT s.id, s.ai_title, s.slug, s.source_id, s.is_sidechain, s.started_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,
+              (SELECT GROUP_CONCAT(DISTINCT ${canonModelSql("model")}) FROM token_usage t WHERE t.session_id = s.id) AS models,
               (SELECT COUNT(*) FROM tool_calls tc WHERE tc.session_id = s.id) AS tool_call_count,
               (SELECT COUNT(*) FROM tool_calls tc WHERE tc.session_id = s.id AND tc.status = 'error') AS tool_error_count,
               (SELECT COUNT(*) FROM findings fd WHERE fd.session_id = s.id) AS finding_count,
@@ -4827,8 +4935,51 @@ function loadFindings(db, id, toolRows) {
 function toResponseToolCall({ event_uuid: _e, error_type: _t, ...call }) {
   return call;
 }
+function rendersSomething(e, toolsByEvent) {
+  return !!(e.text || e.thinking || toolsByEvent.get(e.uuid)?.length);
+}
+function addSplit(a, b) {
+  if (!b)
+    return a;
+  if (!a)
+    return { ...b };
+  return {
+    input: a.input + b.input,
+    output: a.output + b.output,
+    cache_creation: a.cache_creation + b.cache_creation,
+    cache_read: a.cache_read + b.cache_read
+  };
+}
+function foldUsage(eventRows, toolsByEvent, usageByEvent) {
+  const out = /* @__PURE__ */ new Map();
+  if (usageByEvent.size === 0)
+    return out;
+  const byTurn = /* @__PURE__ */ new Map();
+  for (const e of eventRows)
+    pushGrouped(byTurn, e.turn_id ?? "", e);
+  for (const group of byTurn.values()) {
+    const ordered = [...group].sort((a, b) => a.seq - b.seq);
+    let pending = null;
+    let lastRendering = null;
+    for (const e of ordered) {
+      const own = usageByEvent.get(e.uuid);
+      if (rendersSomething(e, toolsByEvent)) {
+        const total = addSplit(pending, own);
+        if (total)
+          out.set(e.uuid, total);
+        pending = null;
+        lastRendering = e.uuid;
+      } else {
+        pending = addSplit(pending, own);
+      }
+    }
+    if (pending && lastRendering)
+      out.set(lastRendering, addSplit(out.get(lastRendering) ?? null, pending));
+  }
+  return out;
+}
 function loadEvents(db, id, toolRows) {
-  const eventRows = queryAll(db, `SELECT uuid, type, role, timestamp, model, is_sidechain, turn_id, text, thinking
+  const eventRows = queryAll(db, `SELECT uuid, seq, type, role, timestamp, model, is_sidechain, turn_id, text, thinking
      FROM events WHERE session_id = ? ORDER BY timestamp, seq`, id);
   const toolsByEvent = /* @__PURE__ */ new Map();
   for (const t of toolRows) {
@@ -4836,18 +4987,30 @@ function loadEvents(db, id, toolRows) {
       continue;
     pushGrouped(toolsByEvent, t.event_uuid, t);
   }
-  return eventRows.map((e) => ({
-    uuid: e.uuid,
-    type: e.type,
-    role: e.role,
-    timestamp: e.timestamp,
-    model: e.model,
-    is_sidechain: e.is_sidechain,
-    turn_id: e.turn_id,
-    text: e.text,
-    thinking: e.thinking,
-    toolCalls: (toolsByEvent.get(e.uuid) ?? []).map(toResponseToolCall)
-  }));
+  const usageByEvent = /* @__PURE__ */ new Map();
+  for (const u of queryAll(db, `SELECT event_uuid, input_tokens i, output_tokens o, cache_creation_input_tokens cw,
+            cache_read_input_tokens cr
+     FROM token_usage WHERE session_id = ?`, id)) {
+    usageByEvent.set(u.event_uuid, { input: u.i, output: u.o, cache_creation: u.cw, cache_read: u.cr });
+  }
+  const folded = foldUsage(eventRows, toolsByEvent, usageByEvent);
+  return eventRows.map((e) => {
+    const usage = folded.get(e.uuid);
+    return {
+      uuid: e.uuid,
+      type: e.type,
+      role: e.role,
+      timestamp: e.timestamp,
+      model: e.model,
+      is_sidechain: e.is_sidechain,
+      turn_id: e.turn_id,
+      text: e.text,
+      thinking: e.thinking,
+      toolCalls: (toolsByEvent.get(e.uuid) ?? []).map(toResponseToolCall),
+      // Spread so the key is ABSENT, not null, on the majority of events that carry no usage row.
+      ...usage ? { usage } : {}
+    };
+  });
 }
 function loadClassification(db, id) {
   const cls = queryGet(db, `SELECT category, complexity_score, complexity_band, signals_json, classifier_version
@@ -4878,7 +5041,7 @@ function loadParent(db, session) {
 function loadChildren(db, id) {
   const hasMeta = tableExists(db, "session_meta");
   const children = queryAll(db, `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
+            (SELECT GROUP_CONCAT(DISTINCT ${canonModelSql("model")}) FROM token_usage t WHERE t.session_id = s.id) AS models
             ${metaProjection(hasMeta)}
      FROM sessions s ${metaJoin(hasMeta)}
      WHERE s.parent_session_id = ? ORDER BY s.started_at`, id);
@@ -4954,7 +5117,7 @@ function safeJson(s) {
 function loadAgents(db, runId) {
   const hasMeta = tableExists(db, "session_meta");
   const agentRows = queryAll(db, `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
+            (SELECT GROUP_CONCAT(DISTINCT ${canonModelSql("model")}) FROM token_usage t WHERE t.session_id = s.id) AS models
             ${metaProjection(hasMeta)}
      FROM sessions s ${metaJoin(hasMeta)}
      WHERE s.workflow_run_id = ? ORDER BY s.started_at`, runId);
@@ -5348,8 +5511,24 @@ function sessionWhere(f) {
   if (f.source)
     where.push("s.source_id = ?"), params.push(f.source);
   pushDateRange(where, params, "s.started_at", f.from, f.to);
-  return { sql: where.length ? `WHERE ${where.join(" AND ")}` : "", params };
-}
+  const models = f.models?.length ? [...new Set(f.models.map((m) => canonicalModel(m)))] : void 0;
+  if (models) {
+    where.push(`EXISTS (SELECT 1 FROM token_usage t WHERE t.session_id = s.id AND ${canonModelSql("t.model")} IN (${placeholders(models)}))`);
+    params.push(...models);
+  }
+  return { sql: where.length ? `WHERE ${where.join(" AND ")}` : "", params, models };
+}
+var placeholders = (xs) => xs.map(() => "?").join(",");
+var and = (w, sql, params = []) => ({
+  sql: `${andWhere(w)} ${sql}`,
+  params: [...w.params, ...params],
+  models: w.models
+});
+var withModel = (w, col) => w.models ? and(w, `${canonModelSql(col)} IN (${placeholders(w.models)})`, w.models) : w;
+var toolModelJoin = (w) => w.models ? "JOIN events e ON e.uuid = tc.event_uuid" : "";
+var eventJoin = "JOIN events e ON e.uuid = tc.event_uuid";
+var andWhere = (w) => w.sql ? w.sql + " AND" : "WHERE";
+var mainOnly = (w) => ({ sql: `${andWhere(w)} s.is_sidechain = 0`, params: w.params, models: w.models });
 var zeroSplit = () => ({ input: 0, output: 0, cache_creation: 0, cache_read: 0 });
 function addUsage(acc, r) {
   acc.input += r.i ?? 0;
@@ -5426,11 +5605,13 @@ function dashboardOverview(db, f) {
        SUM(turn_count) turns,
        COUNT(DISTINCT project_id) projects
      FROM sessions s ${w.sql}`, ...w.params);
-  const toolCount = queryGet(db, `SELECT COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id ${w.sql}`, ...w.params).n;
+  const tw = withModel(w, "e.model");
+  const toolCount = queryGet(db, `SELECT COUNT(*) n FROM tool_calls tc ${toolModelJoin(w)} JOIN sessions s ON s.id = tc.session_id ${tw.sql}`, ...tw.params).n;
+  const uw = withModel(w, "t.model");
   const usage = queryAll(db, `SELECT t.model model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
             SUM(t.cache_creation_input_tokens) cw, SUM(t.cache_read_input_tokens) cr
-     FROM token_usage t JOIN sessions s ON s.id = t.session_id ${w.sql}
-     GROUP BY t.model`, ...w.params);
+     FROM token_usage t JOIN sessions s ON s.id = t.session_id ${uw.sql}
+     GROUP BY t.model`, ...uw.params);
   const tokens = zeroSplit();
   let cost = 0;
   const unpriced2 = [];
@@ -5441,16 +5622,20 @@ function dashboardOverview(db, f) {
       unpriced2.push(u.model);
   }
   const totalTokens = tokens.input + tokens.output + tokens.cache_creation + tokens.cache_read;
+  const tnw = withModel(w, "tn.model");
+  const turns = tnw.models ? queryGet(db, `SELECT COUNT(*) n FROM turns tn JOIN sessions s ON s.id = tn.session_id ${tnw.sql}`, ...tnw.params)?.n ?? 0 : counts.turns ?? 0;
   const turnDur = percentiles(db, `SELECT tn.duration_ms v FROM turns tn JOIN sessions s ON s.id = tn.session_id
-     ${w.sql ? w.sql + " AND" : "WHERE"} tn.duration_ms IS NOT NULL`, w.params);
-  const sessDur = percentiles(db, `SELECT s.duration_ms v FROM sessions s
-     ${w.sql ? w.sql + " AND" : "WHERE"} s.is_sidechain = 0 AND s.duration_ms IS NOT NULL`, w.params);
+     ${andWhere(tnw)} tn.duration_ms IS NOT NULL`, tnw.params);
+  const mw = mainOnly(w);
+  const sessDur = percentiles(db, `SELECT s.duration_ms v FROM sessions s ${mw.sql} AND s.duration_ms IS NOT NULL`, mw.params);
   return {
-    range: { from: f.from ?? null, to: f.to ?? null, source: f.source ?? null },
+    // `w.models`, not `f.models`: the echo names the models actually queried, so a link that arrived
+    // with a raw dated id reports the family key it resolved to rather than the string it was sent.
+    range: { from: f.from ?? null, to: f.to ?? null, source: f.source ?? null, models: w.models ?? null },
     sessions: counts.sessions ?? 0,
     sessions_main: counts.main ?? 0,
     sessions_subagent: counts.subagent ?? 0,
-    turns: counts.turns ?? 0,
+    turns,
     projects: counts.projects ?? 0,
     tool_calls: toolCount ?? 0,
     tokens,
@@ -5476,15 +5661,11 @@ function chooseBucket(db, f) {
     return "week";
   return "month";
 }
-var BUCKET_EXPR = {
-  day: "strftime('%Y-%m-%d', s.started_at)",
-  week: "strftime('%Y-W%W', s.started_at)",
-  month: "strftime('%Y-%m', s.started_at)"
-};
+var bucketExpr = (b, col) => b === "day" ? `strftime('%Y-%m-%d', ${col})` : b === "week" ? `strftime('%Y-W%W', ${col})` : `strftime('%Y-%m', ${col})`;
 function dashboardTimeseries(db, f, bucketParam) {
   const bucket = bucketParam === "day" || bucketParam === "week" || bucketParam === "month" ? bucketParam : chooseBucket(db, f);
   const w = sessionWhere(f);
-  const expr = BUCKET_EXPR[bucket];
+  const expr = bucketExpr(bucket, "s.started_at");
   const byBucket = /* @__PURE__ */ new Map();
   const get = (b) => {
     let r = byBucket.get(b);
@@ -5494,10 +5675,13 @@ function dashboardTimeseries(db, f, bucketParam) {
     }
     return r;
   };
+  const uw = withModel(w, "t.model");
+  const tnw = withModel(w, "tn.model");
+  const ew = withModel(w, "e.model");
   for (const u of queryAll(db, `SELECT ${expr} b, t.model model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
             SUM(t.cache_creation_input_tokens) cw, SUM(t.cache_read_input_tokens) cr
      FROM token_usage t JOIN sessions s ON s.id = t.session_id
-     ${w.sql} GROUP BY b, t.model`, ...w.params)) {
+     ${uw.sql} GROUP BY b, t.model`, ...uw.params)) {
     if (!u.b)
       continue;
     const r = get(u.b);
@@ -5508,12 +5692,12 @@ function dashboardTimeseries(db, f, bucketParam) {
     if (s.b)
       get(s.b).sessions = s.n;
   }
-  for (const t of queryAll(db, `SELECT ${expr} b, COUNT(*) n FROM turns tn JOIN sessions s ON s.id = tn.session_id ${w.sql} GROUP BY b`, ...w.params)) {
+  for (const t of queryAll(db, `SELECT ${expr} b, COUNT(*) n FROM turns tn JOIN sessions s ON s.id = tn.session_id ${tnw.sql} GROUP BY b`, ...tnw.params)) {
     if (t.b)
       get(t.b).turns = t.n;
   }
-  for (const e of queryAll(db, `SELECT ${expr} b, tc.error_type et, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
-     ${w.sql ? w.sql + " AND" : "WHERE"} tc.status = 'error' GROUP BY b, tc.error_type`, ...w.params)) {
+  for (const e of queryAll(db, `SELECT ${expr} b, tc.error_type et, COUNT(*) n FROM tool_calls tc ${toolModelJoin(w)} JOIN sessions s ON s.id = tc.session_id
+     ${andWhere(ew)} tc.status = 'error' GROUP BY b, tc.error_type`, ...ew.params)) {
     if (!e.b)
       continue;
     const r = get(e.b);
@@ -5527,35 +5711,40 @@ function dashboardTimeseries(db, f, bucketParam) {
     r.cost = Number(r.cost.toFixed(4));
   return { bucket, series };
 }
-var andWhere = (w) => w.sql ? w.sql + " AND" : "WHERE";
 function modelBreakdown(db, w) {
-  const modelRows = queryAll(
-    db,
-    // COALESCE the bucket label, exactly as by_source does for a null source_id: token_usage.model is
-    // nullable and this GROUP BY — unlike the model FILTER list — does not exclude nulls, so a
-    // null-model bucket reaches the chart. It used to render as a nameless bar.
-    `SELECT COALESCE(t.model, '(unknown)') model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
+  const uw = withModel(w, "t.model");
+  const canon = canonModelSql("t.model");
+  const modelRows = queryAll(db, `SELECT COALESCE(${canon}, '(unknown)') model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
             SUM(t.cache_creation_input_tokens) cw, SUM(t.cache_read_input_tokens) cr,
             COUNT(DISTINCT t.session_id) sessions
-     FROM token_usage t JOIN sessions s ON s.id = t.session_id ${w.sql}
-     GROUP BY t.model ORDER BY (SUM(t.input_tokens)+SUM(t.output_tokens)+SUM(t.cache_creation_input_tokens)+SUM(t.cache_read_input_tokens)) DESC`,
-    ...w.params
-  );
+     FROM token_usage t JOIN sessions s ON s.id = t.session_id ${uw.sql}
+     GROUP BY 1 ORDER BY (SUM(t.input_tokens)+SUM(t.output_tokens)+SUM(t.cache_creation_input_tokens)+SUM(t.cache_read_input_tokens)) DESC`, ...uw.params);
+  const cost = /* @__PURE__ */ new Map();
+  const unpriced2 = /* @__PURE__ */ new Set();
+  for (const u of queryAll(db, `SELECT COALESCE(t.model, '(unknown)') model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
+            SUM(t.cache_creation_input_tokens) cw, SUM(t.cache_read_input_tokens) cr
+     FROM token_usage t JOIN sessions s ON s.id = t.session_id ${uw.sql} GROUP BY t.model`, ...uw.params)) {
+    const key = canonicalModel(u.model);
+    cost.set(key, (cost.get(key) ?? 0) + costForUsage(u.model, usageForCost(u)));
+    if (!rateForModel(u.model))
+      unpriced2.add(key);
+  }
   return modelRows.map((u) => ({
     model: u.model,
     tokens: { input: u.i ?? 0, output: u.o ?? 0, cache_creation: u.cw ?? 0, cache_read: u.cr ?? 0 },
     total_tokens: (u.i ?? 0) + (u.o ?? 0) + (u.cw ?? 0) + (u.cr ?? 0),
-    cost: Number(costForUsage(u.model, usageForCost(u)).toFixed(4)),
+    cost: Number((cost.get(u.model) ?? 0).toFixed(4)),
     sessions: u.sessions ?? 0,
-    priced: !!rateForModel(u.model)
+    priced: !unpriced2.has(u.model)
   }));
 }
 function sourceBreakdown(db, w) {
-  return queryAll(db, `SELECT COALESCE(s.source_id, '(none)') source, COUNT(*) sessions, SUM(s.turn_count) turns
-     FROM sessions s ${w.sql} GROUP BY s.source_id ORDER BY sessions DESC`, ...w.params);
+  const perSourceTurns = w.models ? `SUM((SELECT COUNT(*) FROM turns tn WHERE tn.session_id = s.id AND ${canonModelSql("tn.model")} IN (${placeholders(w.models)})))` : "SUM(s.turn_count)";
+  return queryAll(db, `SELECT COALESCE(s.source_id, '(none)') source, COUNT(*) sessions, ${perSourceTurns} turns
+     FROM sessions s ${w.sql} GROUP BY s.source_id ORDER BY sessions DESC`, ...w.models ?? [], ...w.params);
 }
 function classificationBreakdowns(db, w) {
-  const mainW = { sql: w.sql ? w.sql + " AND s.is_sidechain = 0" : "WHERE s.is_sidechain = 0", params: w.params };
+  const mainW = mainOnly(w);
   const byCategory = queryAll(db, `SELECT c.category, COUNT(*) n FROM classifications c JOIN sessions s ON s.id = c.target_id
      ${mainW.sql} GROUP BY c.category ORDER BY n DESC`, ...mainW.params);
   const byComplexity = queryAll(db, `SELECT c.complexity_band band, COUNT(*) n FROM classifications c JOIN sessions s ON s.id = c.target_id
@@ -5563,26 +5752,30 @@ function classificationBreakdowns(db, w) {
   return { byCategory, byComplexity };
 }
 function toolBreakdown(db, w) {
-  return queryAll(db, `SELECT tc.tool_name name, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
-     ${w.sql} GROUP BY tc.tool_name ORDER BY n DESC LIMIT 20`, ...w.params);
+  const ew = withModel(w, "e.model");
+  return queryAll(db, `SELECT tc.tool_name name, COUNT(*) n FROM tool_calls tc ${toolModelJoin(w)} JOIN sessions s ON s.id = tc.session_id
+     ${ew.sql} GROUP BY tc.tool_name ORDER BY n DESC LIMIT 20`, ...ew.params);
 }
 function skillBreakdowns(db, w) {
-  const skills = queryAll(db, `SELECT tc.skill_name name, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
-     ${andWhere(w)} tc.skill_name IS NOT NULL GROUP BY tc.skill_name ORDER BY n DESC LIMIT 20`, ...w.params);
+  const ew = withModel(w, "e.model");
+  const skills = queryAll(db, `SELECT tc.skill_name name, COUNT(*) n FROM tool_calls tc ${toolModelJoin(w)} JOIN sessions s ON s.id = tc.session_id
+     ${andWhere(ew)} tc.skill_name IS NOT NULL GROUP BY tc.skill_name ORDER BY n DESC LIMIT 20`, ...ew.params);
   const skillVersions = queryAll(db, `SELECT tc.skill_name name, sk.id version_id, sk.summary, sk.last_seen, COUNT(*) n
      FROM tool_calls tc
+     ${toolModelJoin(w)}
      JOIN skills sk ON sk.id = tc.skill_id
      JOIN sessions s ON s.id = tc.session_id
-     ${andWhere(w)} tc.skill_id IS NOT NULL
-     GROUP BY tc.skill_name, sk.id ORDER BY name, n DESC`, ...w.params);
+     ${andWhere(ew)} tc.skill_id IS NOT NULL
+     GROUP BY tc.skill_name, sk.id ORDER BY name, n DESC`, ...ew.params);
   return { skills, skillVersions };
 }
 function subagentFanoutBreakdown(db, w) {
-  const subagentByType = queryAll(db, `SELECT tc.agent_type type, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
-     ${andWhere(w)} tc.agent_type IS NOT NULL GROUP BY tc.agent_type ORDER BY n DESC`, ...w.params);
-  const perSession = queryAll(db, `SELECT COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
-     ${andWhere(w)} s.is_sidechain = 0 AND tc.tool_name IN ('Agent','Task')
-     GROUP BY tc.session_id`, ...w.params);
+  const ew = withModel(w, "e.model");
+  const subagentByType = queryAll(db, `SELECT tc.agent_type type, COUNT(*) n FROM tool_calls tc ${toolModelJoin(w)} JOIN sessions s ON s.id = tc.session_id
+     ${andWhere(ew)} tc.agent_type IS NOT NULL GROUP BY tc.agent_type ORDER BY n DESC`, ...ew.params);
+  const perSession = queryAll(db, `SELECT COUNT(*) n FROM tool_calls tc ${toolModelJoin(w)} JOIN sessions s ON s.id = tc.session_id
+     ${mainOnly(ew).sql} AND tc.tool_name IN ('Agent','Task')
+     GROUP BY tc.session_id`, ...ew.params);
   const counts = perSession.map((r) => r.n);
   return {
     by_type: subagentByType,
@@ -5593,8 +5786,9 @@ function subagentFanoutBreakdown(db, w) {
   };
 }
 function errorTypeBreakdown(db, w) {
-  const errorRows = queryAll(db, `SELECT COALESCE(tc.error_type, 'other') type, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
-     ${andWhere(w)} tc.status = 'error' GROUP BY tc.error_type ORDER BY n DESC`, ...w.params);
+  const ew = withModel(w, "e.model");
+  const errorRows = queryAll(db, `SELECT COALESCE(tc.error_type, 'other') type, COUNT(*) n FROM tool_calls tc ${toolModelJoin(w)} JOIN sessions s ON s.id = tc.session_id
+     ${andWhere(ew)} tc.status = 'error' GROUP BY tc.error_type ORDER BY n DESC`, ...ew.params);
   let failures = 0;
   let rejections = 0;
   const byType = errorRows.map((r) => {
@@ -5623,6 +5817,143 @@ function dashboardBreakdowns(db, f) {
     error_types: errorTypeBreakdown(db, w)
   };
 }
+var bucketFor = (b) => b === "day" || b === "week" || b === "month" ? b : "day";
+function dashboardTime(db, f, bucketParam) {
+  const w = sessionWhere(f);
+  const mw = mainOnly(w);
+  const uw = withModel(w, "t.model");
+  const burn_hours = queryAll(db, `SELECT strftime('%Y-%m-%dT%H', e.timestamp) h, s.source_id src,
+            SUM(t.input_tokens + t.output_tokens + t.cache_creation_input_tokens) work
+     FROM token_usage t
+     JOIN events e ON e.uuid = t.event_uuid
+     JOIN sessions s ON s.id = t.session_id
+     ${uw.sql} GROUP BY h, src ORDER BY h`, ...uw.params).filter((r) => r.h != null).map((r) => ({ hour: r.h, source: r.src, work: r.work ?? 0 }));
+  const tw = withModel(mw, "t.model");
+  const turn_hours = queryAll(db, `SELECT strftime('%Y-%m-%dT%H', t.started_at) h, s.source_id src, COUNT(*) turns
+     FROM turns t
+     JOIN sessions s ON s.id = t.session_id
+     ${tw.sql} GROUP BY h, src ORDER BY h`, ...tw.params).filter((r) => r.h != null).map((r) => ({ hour: r.h, source: r.src, turns: r.turns ?? 0 }));
+  return {
+    burn_hours,
+    turn_hours,
+    latency: modelLatency(db, mw, bucketParam ? bucketFor(bucketParam) : chooseBucket(db, f)),
+    review: reviewLatency(db, mw)
+  };
+}
+var MIN_LATENCY_SAMPLES = 5;
+function modelLatency(db, mw, bucket) {
+  const expr = bucketExpr(bucket, "s.started_at");
+  const lw = withModel(mw, "tn.model");
+  const series = queryAll(db, `WITH lat AS MATERIALIZED (
+       SELECT ${expr} b, COALESCE(${canonModelSql("tn.model")}, '(unknown)') model,
+              (julianday(MIN(e.timestamp)) - julianday(tn.started_at)) * 86400000.0 ms
+       FROM turns tn
+       JOIN sessions s ON s.id = tn.session_id
+       JOIN events e ON e.turn_id = tn.id AND e.role = 'assistant'
+       ${lw.sql} AND tn.started_at IS NOT NULL AND tn.model IS NOT '<synthetic>'
+       GROUP BY tn.id
+     ),
+     ranked AS (
+       SELECT b, model, ms,
+              ROW_NUMBER() OVER (PARTITION BY b, model ORDER BY ms) rn,
+              COUNT(*) OVER (PARTITION BY b, model) c
+       FROM lat WHERE ms IS NOT NULL AND ms >= 0
+     )
+     SELECT b, model, MAX(c) n,
+            MAX(CASE WHEN rn = MAX(1, CAST(ceil(0.5 * c) AS INTEGER)) THEN ms END) p50,
+            MAX(CASE WHEN rn = MAX(1, CAST(ceil(0.9 * c) AS INTEGER)) THEN ms END) p90
+     FROM ranked GROUP BY b, model HAVING MAX(c) >= ${MIN_LATENCY_SAMPLES} ORDER BY b, model`, ...lw.params).filter((r) => r.b != null).map((r) => ({
+    bucket: r.b,
+    model: r.model ?? "(unknown)",
+    p50_ms: Math.round(r.p50 ?? 0),
+    p90_ms: Math.round(r.p90 ?? 0),
+    n: r.n
+  }));
+  return { bucket, series };
+}
+function reviewLatency(db, mw) {
+  const empty = () => ({ n: 0, under_10s: 0, under_30s: 0, under_2min: 0 });
+  const out = { wrote: empty(), none: empty() };
+  for (const r of queryAll(
+    db,
+    // `wrote` is resolved against a materialized set of turn ids rather than a correlated EXISTS:
+    // file_changes has no index on turn_id, so the per-turn subquery rescanned the table once per
+    // turn and cost 5.7s on the real corpus against 0.02s for this. Same counts either way.
+    `WITH wrote_turns AS MATERIALIZED (SELECT DISTINCT turn_id FROM file_changes WHERE turn_id IS NOT NULL),
+     turnaround AS MATERIALIZED (
+       SELECT (tn.id IN (SELECT turn_id FROM wrote_turns)) wrote,
+              (julianday(LEAD(tn.started_at) OVER (PARTITION BY tn.session_id ORDER BY tn.seq))
+               - julianday(tn.ended_at)) * 86400000.0 d
+       FROM turns tn JOIN sessions s ON s.id = tn.session_id ${mw.sql}
+     )
+     SELECT wrote, COUNT(*) n,
+            SUM(CASE WHEN d <= 10000 THEN 1 ELSE 0 END) u10,
+            SUM(CASE WHEN d <= 30000 THEN 1 ELSE 0 END) u30,
+            SUM(CASE WHEN d <= 120000 THEN 1 ELSE 0 END) u120
+     FROM turnaround WHERE d IS NOT NULL AND d >= 0 GROUP BY wrote`,
+    ...mw.params
+  )) {
+    out[r.wrote ? "wrote" : "none"] = { n: r.n, under_10s: r.u10 ?? 0, under_30s: r.u30 ?? 0, under_2min: r.u120 ?? 0 };
+  }
+  return out;
+}
+function dashboardAudit(db, f, bucketParam) {
+  const w = sessionWhere(f);
+  const bucket = bucketParam ? bucketFor(bucketParam) : chooseBucket(db, f);
+  return {
+    bucket,
+    edit_reliability: editReliability(db, w),
+    plan_rejections: planRejections(db, mainOnly(w), bucket),
+    file_rework: fileRework(db, w),
+    findings_over_time: findingsOverTime(db, w, bucket)
+  };
+}
+function editReliability(db, w) {
+  const ew = withModel(w, "e.model");
+  return queryAll(db, `SELECT COALESCE(${canonModelSql("e.model")}, '(unknown)') model, COUNT(*) calls,
+            SUM(CASE WHEN tc.status = 'error' THEN 1 ELSE 0 END) errors
+     FROM tool_calls tc ${eventJoin} JOIN sessions s ON s.id = tc.session_id
+     ${andWhere(ew)} tc.tool_name IN ('Edit', 'Write', 'NotebookEdit')
+     GROUP BY 1 ORDER BY calls DESC`, ...ew.params);
+}
+function planRejections(db, mw, bucket) {
+  const ew = withModel(mw, "e.model");
+  const rejected = (tool) => `SUM(CASE WHEN tc.tool_name = '${tool}' AND tc.error_type = 'user-rejected' THEN 1 ELSE 0 END)`;
+  const calls = (tool) => `SUM(CASE WHEN tc.tool_name = '${tool}' THEN 1 ELSE 0 END)`;
+  return queryAll(db, `SELECT ${bucketExpr(bucket, "s.started_at")} bucket,
+            ${calls("ExitPlanMode")} plan_calls, ${rejected("ExitPlanMode")} plan_rejected,
+            ${calls("AskUserQuestion")} question_calls, ${rejected("AskUserQuestion")} question_rejected
+     FROM tool_calls tc ${eventJoin} JOIN sessions s ON s.id = tc.session_id
+     ${andWhere(ew)} tc.tool_name IN ('ExitPlanMode', 'AskUserQuestion')
+     GROUP BY bucket ORDER BY bucket`, ...ew.params).filter((r) => r.bucket != null);
+}
+var REWORK_BANDS = ["1", "2-3", "4-6", "7-12", "13+"];
+function fileRework(db, w) {
+  const ew = withModel(w, "e.model");
+  const rows = queryAll(db, `WITH pairs AS (
+       SELECT COUNT(*) n
+       FROM file_changes fc
+       JOIN events e ON e.uuid = fc.event_uuid
+       JOIN sessions s ON s.id = fc.session_id
+       ${ew.sql} GROUP BY fc.session_id, fc.file_path
+     )
+     SELECT CASE WHEN n = 1 THEN '1' WHEN n <= 3 THEN '2-3' WHEN n <= 6 THEN '4-6'
+                 WHEN n <= 12 THEN '7-12' ELSE '13+' END band,
+            COUNT(*) pairs, SUM(n) changes
+     FROM pairs GROUP BY band`, ...ew.params);
+  const byBand = new Map(rows.map((r) => [r.band, r]));
+  return REWORK_BANDS.map((band2) => byBand.get(band2) ?? { band: band2, pairs: 0, changes: 0 });
+}
+function findingsOverTime(db, w, bucket) {
+  const ew = withModel(w, "e.model");
+  const sev = (s) => `SUM(CASE WHEN f.severity = '${s}' THEN 1 ELSE 0 END) ${s}`;
+  return queryAll(db, `SELECT ${bucketExpr(bucket, "e.timestamp")} bucket,
+            ${sev("info")}, ${sev("low")}, ${sev("medium")}, ${sev("high")}, ${sev("critical")}
+     FROM findings f
+     JOIN events e ON e.uuid = f.event_uuid
+     JOIN sessions s ON s.id = f.session_id
+     ${ew.sql} GROUP BY bucket ORDER BY bucket`, ...ew.params).filter((r) => r.bucket != null);
+}
 
 // ../server/dist/refresh.js
 import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "node:fs";
@@ -5894,7 +6225,7 @@ async function createApp(db, opts = {}) {
   app.get("/api/models", async () => listModels(db));
   const dashFilters = (req) => {
     const q = req.query;
-    return { source: q.source, from: q.from, to: q.to };
+    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)));
   app.get("/api/dashboard/timeseries", async (req) => {
@@ -5902,6 +6233,14 @@ async function createApp(db, opts = {}) {
     return dashboardTimeseries(db, dashFilters(req), q.bucket);
   });
   app.get("/api/dashboard/breakdowns", async (req) => dashboardBreakdowns(db, dashFilters(req)));
+  app.get("/api/dashboard/time", async (req) => {
+    const q = req.query;
+    return dashboardTime(db, dashFilters(req), q.bucket);
+  });
+  app.get("/api/dashboard/audit", async (req) => {
+    const q = req.query;
+    return dashboardAudit(db, dashFilters(req), q.bucket);
+  });
   const PREF_KEY = /^[a-z0-9._-]{1,64}$/i;
   app.get("/api/prefs/:key", async (req, reply) => {
     const { key } = req.params;
@@ -6251,8 +6590,8 @@ cli.command("export <sessionId>", "Write a session to a shareable Markdown file
 cli.command(
   "service <action> [target]",
   "Install/uninstall/status OS services \u2014 action: install|uninstall|status; target: collector|server|all (default all)"
-).option("--times <hours>", "Collector cadence: comma-separated hours 0-23 (default: 9,13,17,21)").action((action, target, opts) => {
-  const targets = parseTargets(target);
+).option("--times <hours>", "Collector cadence: comma-separated hours 0-23 (default: 9,13,17,21)").action((action, target2, opts) => {
+  const targets = parseTargets(target2);
   const hours = action === "install" ? parseHours(opts.times) : void 0;
   runService(action, { cliEntry: fileURLToPath4(import.meta.url), hours, targets });
 });