@swestash/agent-lens 0.14.1 → 0.15.0

package/dist/agent-lens.js

@@ -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)
@@ -4568,6 +4572,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 +4665,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 +4718,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 +4732,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 +4836,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 +4888,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 +4942,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 +5018,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 +5412,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 +5506,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 +5523,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 +5562,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 +5576,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 +5593,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 +5612,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 +5653,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 +5687,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 +5718,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 +6126,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 +6134,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;