@kitsunemori96/opencode-session-metrics 0.0.0-stage → 0.2.0

package/server/dist/index.js

@@ -0,0 +1,3892 @@
+// src/index.ts
+import express2 from "express";
+import { existsSync as existsSync5 } from "node:fs";
+import path3 from "node:path";
+
+// src/config.ts
+import * as os from "node:os";
+import * as path from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+var ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+var INSTALLED = `${path.sep}node_modules${path.sep}`;
+var USER_DATA_DIR = path.join(
+  process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"),
+  "opencode-session-metrics"
+);
+var DATA_DIR = process.env.OSM_DATA_DIR ?? (ROOT.includes(INSTALLED) ? USER_DATA_DIR : path.join(ROOT, ".data"));
+var SOURCE_DB = process.env.OSM_SOURCE_DB ?? path.join(os.homedir(), ".local", "share", "opencode", "opencode.db");
+var QODER_HOME = process.env.OSM_QODER_HOME ?? path.join(os.homedir(), ".qoder");
+var QODER_PROJECTS = path.join(QODER_HOME, "projects");
+var QODER_LOGS = path.join(QODER_HOME, "logs", "sessions");
+var SOURCE_KINDS = ["opencode", "qoder"];
+function resolveSourceKind() {
+  const explicit = process.env.OSM_SOURCE?.trim();
+  if (explicit === "qoder" || explicit === "opencode") return explicit;
+  if (process.env.OSM_SOURCE_DB) return "opencode";
+  if (existsSync(SOURCE_DB)) return "opencode";
+  if (existsSync(QODER_PROJECTS)) return "qoder";
+  return "opencode";
+}
+var SOURCE_KIND = resolveSourceKind();
+var METRICS_DB_BY_KIND = {
+  opencode: path.join(DATA_DIR, "metrics.db"),
+  qoder: path.join(DATA_DIR, "metrics-qoder.db")
+};
+var metricsDbPath = (kind) => METRICS_DB_BY_KIND[kind];
+var METRICS_DB = METRICS_DB_BY_KIND.opencode;
+var sourceProbe = (kind) => kind === "qoder" ? QODER_PROJECTS : SOURCE_DB;
+var sourceAvailable = (kind) => existsSync(sourceProbe(kind));
+var MODEL_CATALOG = path.join(DATA_DIR, "model-catalog.json");
+var MODEL_OVERRIDES = path.join(DATA_DIR, "model-overrides.json");
+var HOST = process.env.OSM_HOST ?? "127.0.0.1";
+var PORT = Number(process.env.OSM_PORT ?? 8787);
+var BUCKET_MS = 5 * 60 * 1e3;
+
+// src/api.ts
+import express from "express";
+import cors from "cors";
+
+// src/metrics/schema.ts
+import { DatabaseSync } from "node:sqlite";
+
+// src/metrics/histogram.ts
+var logLadder = (name, perOctave) => ({
+  name,
+  key: (col) => `CAST(log2(MAX(${col}, 0) + 1) * ${perOctave} AS INTEGER)`,
+  lower: (bin) => Math.max(0, Math.pow(2, bin / perOctave) - 1)
+});
+var linearLadder = (name, step) => ({
+  name,
+  key: (col) => `CAST(MAX(${col}, 0) / ${step} AS INTEGER)`,
+  lower: (bin) => Math.max(0, bin * step)
+});
+var ladder = {
+  ms: logLadder("ms", 128),
+  share: linearLadder("share", 2e-3),
+  rate: linearLadder("rate", 0.25)
+};
+function histogramOf(rows) {
+  const h = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const bin = Number(r.bin) || 0;
+    h.set(bin, (h.get(bin) ?? 0) + (Number(r.n) || 0));
+  }
+  return h;
+}
+function histogramCount(h) {
+  let n = 0;
+  for (const c of h.values()) n += c;
+  return n;
+}
+function quantile(h, p, l, ceiling = Infinity) {
+  const total = histogramCount(h);
+  if (total <= 0) return 0;
+  const clamped = Math.min(1, Math.max(0, p));
+  const rank = Math.min(total - 1, Math.max(0, Math.round(clamped * (total - 1))));
+  let before = 0;
+  for (const bin of [...h.keys()].sort((x, y) => x - y)) {
+    const n = h.get(bin) ?? 0;
+    if (rank < before + n) {
+      const inside = n > 0 ? (rank - before + 0.5) / n : 0;
+      const lo = l.lower(bin);
+      const hi = l.lower(bin + 1);
+      const at = lo + (hi - lo) * Math.min(1, Math.max(0, inside));
+      return Math.min(ceiling, Math.max(0, at));
+    }
+    before += n;
+  }
+  return Math.min(ceiling, l.lower([...h.keys()].sort((x, y) => x - y).pop() ?? 0));
+}
+function histMedian(h, l, ceiling = Infinity) {
+  return quantile(h, 0.5, l, ceiling);
+}
+
+// src/metrics/rollup.ts
+var ROLL_VERSION = "2";
+var DDL = (
+  /* sql */
+  `
+CREATE TABLE IF NOT EXISTS roll_cell (
+  session_id TEXT NOT NULL,
+  day INTEGER NOT NULL,
+  project TEXT NOT NULL,
+  model TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  turns INTEGER NOT NULL,
+  input INTEGER NOT NULL,
+  output INTEGER NOT NULL,
+  reasoning INTEGER NOT NULL,
+  cache_read INTEGER NOT NULL,
+  cache_write INTEGER NOT NULL,
+  cost REAL NOT NULL,
+  tools INTEGER NOT NULL,
+  tool_errors INTEGER NOT NULL,
+  additions INTEGER NOT NULL,
+  deletions INTEGER NOT NULL,
+  write_lines INTEGER NOT NULL,
+  win INTEGER NOT NULL,
+  stopped INTEGER NOT NULL,
+  first_created INTEGER NOT NULL,
+  last_completed INTEGER NOT NULL,
+  PRIMARY KEY (session_id, day, project, model, agent)
+) WITHOUT ROWID;
+
+CREATE INDEX IF NOT EXISTS roll_cell_day ON roll_cell(day);
+
+CREATE TABLE IF NOT EXISTS roll_hour (
+  day INTEGER NOT NULL,
+  hour INTEGER NOT NULL,
+  project TEXT NOT NULL,
+  model TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  turns INTEGER NOT NULL,
+  PRIMARY KEY (day, hour, project, model, agent)
+) WITHOUT ROWID;
+
+CREATE INDEX IF NOT EXISTS roll_hour_day ON roll_hour(day);
+
+CREATE TABLE IF NOT EXISTS roll_tool (
+  day INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  project TEXT NOT NULL,
+  model TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  calls INTEGER NOT NULL,
+  errors INTEGER NOT NULL,
+  ms_sum INTEGER NOT NULL,
+  ms_max INTEGER NOT NULL,
+  PRIMARY KEY (day, name, session_id, project, model, agent)
+) WITHOUT ROWID;
+
+-- Day first, then name, then bin: a window is one contiguous range of the b-tree, and
+-- the rows arrive nearly grouped the way the panel groups them. With the name first this
+-- scan cost twice as much on a decade of calls (400k rows, one bin each).
+CREATE TABLE IF NOT EXISTS roll_tool_bin (
+  day INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  bin INTEGER NOT NULL,
+  project TEXT NOT NULL,
+  model TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  n INTEGER NOT NULL,
+  PRIMARY KEY (day, name, bin, project, model, agent)
+) WITHOUT ROWID;
+`
+);
+var CELL_COLS = [
+  "session_id",
+  "day",
+  "project",
+  "model",
+  "agent",
+  "turns",
+  "input",
+  "output",
+  "reasoning",
+  "cache_read",
+  "cache_write",
+  "cost",
+  "tools",
+  "tool_errors",
+  "additions",
+  "deletions",
+  "write_lines",
+  "win",
+  "stopped",
+  "first_created",
+  "last_completed"
+];
+var CELL_SELECT = `t.session_id, t.day, COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main'),
+  COUNT(*), SUM(t.input), SUM(t.output), SUM(t.reasoning), SUM(t.cache_read), SUM(t.cache_write), SUM(t.cost),
+  SUM(COALESCE(t.tool_calls,0)), SUM(COALESCE(t.tool_errors,0)),
+  SUM(COALESCE(t.additions,0)), SUM(COALESCE(t.deletions,0)), SUM(COALESCE(t.write_lines,0)),
+  MAX(COALESCE(t.context_window,0)),
+  SUM(CASE WHEN COALESCE(t.finish,'') <> '' AND t.finish <> 'stop' THEN 1 ELSE 0 END),
+  MIN(t.created), MAX(COALESCE(t.completed, t.created))`;
+var CELL_GROUP = "GROUP BY t.session_id, t.day, COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main')";
+var HOUR_SELECT = `t.day, t.hour, COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main'), COUNT(*)`;
+var HOUR_GROUP = "GROUP BY t.day, t.hour, COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main')";
+var TOOL_SELECT = `t.day, tl.name, tl.session_id, COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main'),
+  COUNT(*), SUM(CASE WHEN tl.status = 'error' THEN 1 ELSE 0 END),
+  SUM(COALESCE(tl.dur_ms,0)), MAX(COALESCE(tl.dur_ms,0))`;
+var TOOL_GROUP = "GROUP BY tl.name, t.day, tl.session_id, COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main')";
+var TOOL_FROM = "FROM tools tl JOIN turns t ON t.id = tl.turn_id WHERE t.role = 'assistant'";
+var DROP = "DROP TABLE IF EXISTS roll_cell; DROP TABLE IF EXISTS roll_hour; DROP TABLE IF EXISTS roll_tool; DROP TABLE IF EXISTS roll_tool_bin;";
+var ready = /* @__PURE__ */ new WeakSet();
+function ceilDay(ts) {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime() >= ts ? d.getTime() : d.getTime() + nextDayMs(d);
+}
+function floorDay(ts) {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+function nextDayMs(midnight) {
+  const next = new Date(midnight.getTime());
+  next.setDate(next.getDate() + 1);
+  return next.getTime() - midnight.getTime();
+}
+function hasTurns(db) {
+  return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='turns'").get();
+}
+function rebuildAll(db) {
+  db.exec("BEGIN");
+  try {
+    db.exec("DELETE FROM roll_cell; DELETE FROM roll_hour; DELETE FROM roll_tool; DELETE FROM roll_tool_bin");
+    db.exec(
+      `INSERT INTO roll_cell(${CELL_COLS.join(",")}) SELECT ${CELL_SELECT} FROM turns t WHERE t.role = 'assistant' ${CELL_GROUP}`
+    );
+    db.exec(
+      `INSERT INTO roll_hour(day,hour,project,model,agent,turns) SELECT ${HOUR_SELECT} FROM turns t WHERE t.role = 'assistant' ${HOUR_GROUP}`
+    );
+    db.exec(`INSERT INTO roll_tool(day,name,session_id,project,model,agent,calls,errors,ms_sum,ms_max)
+             SELECT ${TOOL_SELECT} ${TOOL_FROM} ${TOOL_GROUP}`);
+    db.exec(
+      `INSERT INTO roll_tool_bin(day,name,bin,project,model,agent,n)
+       SELECT t.day, tl.name, ${ladder.ms.key("COALESCE(tl.dur_ms,0)")},
+              COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main'), COUNT(*)
+       ${TOOL_FROM}
+       GROUP BY 1,2,3,4,5,6`
+    );
+    setMeta(db, "rollVersion", ROLL_VERSION);
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+  ready.add(db);
+}
+function refreshRollups(db, sessionIds, days, full = false) {
+  if (!hasTurns(db)) return;
+  if (full) {
+    db.exec("DELETE FROM roll_cell; DELETE FROM roll_hour; DELETE FROM roll_tool; DELETE FROM roll_tool_bin");
+  }
+  if (sessionIds.length) {
+    const ph = sessionIds.map(() => "?").join(",");
+    db.prepare(`DELETE FROM roll_cell WHERE session_id IN (${ph})`).run(...sessionIds);
+    db.prepare(
+      `INSERT INTO roll_cell(${CELL_COLS.join(",")})
+       SELECT ${CELL_SELECT} FROM turns t WHERE t.role = 'assistant' AND t.session_id IN (${ph}) ${CELL_GROUP}`
+    ).run(...sessionIds);
+    db.prepare(`DELETE FROM roll_tool WHERE session_id IN (${ph})`).run(...sessionIds);
+    db.prepare(`INSERT INTO roll_tool(day,name,session_id,project,model,agent,calls,errors,ms_sum,ms_max)
+       SELECT ${TOOL_SELECT} ${TOOL_FROM} AND tl.session_id IN (${ph}) ${TOOL_GROUP}`).run(
+      ...sessionIds
+    );
+  }
+  if (days.length) {
+    const ph = days.map(() => "?").join(",");
+    db.prepare(`DELETE FROM roll_hour WHERE day IN (${ph})`).run(...days);
+    db.prepare(
+      `INSERT INTO roll_hour(day,hour,project,model,agent,turns)
+       SELECT ${HOUR_SELECT} FROM turns t WHERE t.role = 'assistant' AND t.day IN (${ph}) ${HOUR_GROUP}`
+    ).run(...days);
+    db.prepare(`DELETE FROM roll_tool_bin WHERE day IN (${ph})`).run(...days);
+    db.prepare(
+      `INSERT INTO roll_tool_bin(day,name,bin,project,model,agent,n)
+       SELECT t.day, tl.name, ${ladder.ms.key("COALESCE(tl.dur_ms,0)")},
+              COALESCE(t.project,'\u2014'), COALESCE(t.model,'unknown'), COALESCE(t.agent,'main'), COUNT(*)
+       ${TOOL_FROM} AND t.day IN (${ph})
+       GROUP BY 1,2,3,4,5,6`
+    ).run(...days);
+  }
+  setMeta(db, "rollVersion", ROLL_VERSION);
+  ready.add(db);
+}
+function ensureRollups(db) {
+  if (!hasTurns(db)) return;
+  const version = getMeta(db, "rollVersion");
+  if (version !== ROLL_VERSION) {
+    db.exec(DROP);
+  }
+  db.exec(DDL);
+  const seeded = db.prepare("SELECT 1 FROM turns WHERE role='assistant' LIMIT 1").get();
+  if (version !== ROLL_VERSION && seeded) rebuildAll(db);
+  ready.add(db);
+}
+function rollupsReady(db) {
+  return ready.has(db) && getMeta(db, "rollVersion") === ROLL_VERSION;
+}
+function rollSpan(db, slice) {
+  if (!rollupsReady(db)) return null;
+  const lo = ceilDay(slice.from);
+  const hi = floorDay(slice.to);
+  if (hi <= lo) return null;
+  return { lo, hi };
+}
+function cellFacet(slice) {
+  const parts = [];
+  const args = [];
+  if (slice.project) parts.push("project = ?"), args.push(slice.project);
+  if (slice.model) parts.push("model = ?"), args.push(slice.model);
+  if (slice.agent) parts.push("agent = ?"), args.push(slice.agent);
+  return { sql: parts.length ? ` AND ${parts.join(" AND ")}` : "", args };
+}
+function turnFacet(slice) {
+  const parts = [];
+  const args = [];
+  if (slice.project) parts.push("COALESCE(t.project,'\u2014') = ?"), args.push(slice.project);
+  if (slice.model) parts.push("COALESCE(t.model,'unknown') = ?"), args.push(slice.model);
+  if (slice.agent) parts.push("COALESCE(t.agent,'main') = ?"), args.push(slice.agent);
+  return { sql: parts.length ? ` AND ${parts.join(" AND ")}` : "", args };
+}
+function edgeSql(slice, span) {
+  const f = turnFacet(slice);
+  return {
+    sql: `t.role = 'assistant' AND ((t.created >= ? AND t.created < ?) OR (t.created >= ? AND t.created < ?))${f.sql}`,
+    args: [slice.from, span.lo, span.hi, slice.to, ...f.args]
+  };
+}
+var TURN_COLUMNS = `t.session_id, COALESCE(t.project,'\u2014') project, COALESCE(t.model,'unknown') model,
+  COALESCE(t.agent,'main') agent, t.day, t.bucket, t.created, COALESCE(t.completed,t.created) ended,
+  1 turns, t.input, t.output, t.reasoning, t.cache_read, t.cache_write, t.cost,
+  COALESCE(t.tool_calls,0) tools, COALESCE(t.tool_errors,0) tool_errors,
+  COALESCE(t.additions,0) additions, COALESCE(t.deletions,0) deletions,
+  COALESCE(t.write_lines,0) write_lines, COALESCE(t.context_window,0) win,
+  CASE WHEN COALESCE(t.finish,'') <> '' AND t.finish <> 'stop' THEN 1 ELSE 0 END stopped`;
+var CELL_TURNS = `session_id, project, model, agent, day, day bucket, first_created created, last_completed ended,
+  turns, input, output, reasoning, cache_read, cache_write, cost, tools, tool_errors,
+  additions, deletions, write_lines, win, stopped`;
+function turnsFrom(where) {
+  return `SELECT ${TURN_COLUMNS} FROM turns t WHERE ${where.sql}`;
+}
+function rawCellSource(slice) {
+  const f = turnFacet(slice);
+  return {
+    sql: turnsFrom({ sql: `t.role = 'assistant' AND t.created >= ? AND t.created < ?${f.sql}`, args: [] }),
+    args: [slice.from, slice.to, ...f.args]
+  };
+}
+function cellSource(slice, span) {
+  const f = cellFacet(slice);
+  const e = edgeSql(slice, span);
+  return {
+    sql: `SELECT ${CELL_TURNS} FROM roll_cell WHERE day >= ? AND day < ?${f.sql}
+          UNION ALL ${turnsFrom(e)}`,
+    args: [span.lo, span.hi, ...f.args, ...e.args]
+  };
+}
+var TOOL_COLUMNS = `tl.name, tl.session_id, COALESCE(t.agent,'main') agent, t.day,
+  1 calls, CASE WHEN tl.status = 'error' THEN 1 ELSE 0 END errors,
+  COALESCE(tl.dur_ms,0) ms, COALESCE(tl.dur_ms,0) mx`;
+var TOOL_TURNS = "tools tl JOIN turns t ON t.id = tl.turn_id";
+function rawToolSource(slice) {
+  const f = turnFacet(slice);
+  return {
+    sql: `SELECT ${TOOL_COLUMNS} FROM ${TOOL_TURNS}
+           WHERE t.role = 'assistant' AND t.created >= ? AND t.created < ?${f.sql}`,
+    args: [slice.from, slice.to, ...f.args]
+  };
+}
+function toolSource(slice, span) {
+  const f = cellFacet(slice);
+  const e = edgeSql(slice, span);
+  return {
+    sql: `SELECT name, session_id, agent, day, calls, errors, ms_sum ms, ms_max mx
+            FROM roll_tool WHERE day >= ? AND day < ?${f.sql}
+          UNION ALL
+          SELECT ${TOOL_COLUMNS} FROM ${TOOL_TURNS} WHERE ${e.sql}`,
+    args: [span.lo, span.hi, ...f.args, ...e.args]
+  };
+}
+var LATENCY_BINS = ladder.ms.key("COALESCE(tl.dur_ms,0)");
+function turnBins(where) {
+  return `SELECT tl.name, ${LATENCY_BINS} bin, COUNT(*) n FROM ${TOOL_TURNS}
+           WHERE ${where.sql} GROUP BY tl.name, bin`;
+}
+function rawToolBins(slice) {
+  const f = turnFacet(slice);
+  return {
+    sql: turnBins({ sql: `t.role = 'assistant' AND t.created >= ? AND t.created < ?${f.sql}`, args: [] }),
+    args: [slice.from, slice.to, ...f.args]
+  };
+}
+function toolBins(slice, span) {
+  const f = cellFacet(slice);
+  const e = edgeSql(slice, span);
+  return {
+    sql: `SELECT name, bin, SUM(n) n FROM (
+            SELECT name, bin, n FROM roll_tool_bin WHERE day >= ? AND day < ?${f.sql}
+            UNION ALL ${turnBins(e)}
+          ) GROUP BY name, bin`,
+    args: [span.lo, span.hi, ...f.args, ...e.args]
+  };
+}
+function hourSource(slice, span) {
+  const f = cellFacet(slice);
+  const e = edgeSql(slice, span);
+  return {
+    sql: `SELECT day, hour, SUM(turns) n FROM roll_hour WHERE day >= ? AND day < ?${f.sql} GROUP BY day, hour
+          UNION ALL
+          SELECT t.day, t.hour, COUNT(*) FROM turns t WHERE ${e.sql} GROUP BY t.day, t.hour`,
+    args: [span.lo, span.hi, ...f.args, ...e.args]
+  };
+}
+function rawHourSource(slice) {
+  const f = turnFacet(slice);
+  return {
+    sql: `SELECT t.day, t.hour, COUNT(*) n FROM turns t
+           WHERE t.role = 'assistant' AND t.created >= ? AND t.created < ?${f.sql}
+           GROUP BY t.day, t.hour`,
+    args: [slice.from, slice.to, ...f.args]
+  };
+}
+
+// src/metrics/schema.ts
+import { mkdirSync } from "node:fs";
+function openMetrics(file = METRICS_DB) {
+  mkdirSync(DATA_DIR, { recursive: true });
+  const db = new DatabaseSync(file);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = OFF");
+  ensureIndexes(db);
+  ensureRollups(db);
+  return db;
+}
+var FACT_TABLES = ["turns", "tools", "parts", "events", "sessions", "flow", "heat"];
+var SCHEMA = (
+  /* sql */
+  `
+CREATE TABLE IF NOT EXISTS models (
+  id TEXT PRIMARY KEY, provider TEXT, label TEXT,
+  context INTEGER DEFAULT 128000,
+  cost_input REAL DEFAULT 0, cost_output REAL DEFAULT 0,
+  cost_cache_read REAL DEFAULT 0, cost_cache_write REAL DEFAULT 0,
+  source TEXT
+);
+
+CREATE TABLE IF NOT EXISTS turns (
+  id TEXT PRIMARY KEY, session_id TEXT NOT NULL, project TEXT NOT NULL,
+  seq INTEGER, created INTEGER, completed INTEGER, dur_ms INTEGER,
+  role TEXT, provider TEXT, model TEXT, variant TEXT, agent TEXT,
+  input INTEGER, output INTEGER, reasoning INTEGER,
+  cache_read INTEGER, cache_write INTEGER, cost REAL,
+  credits_micro INTEGER DEFAULT 0,
+  prompt_total INTEGER, occupancy INTEGER, context_window INTEGER,
+  fill REAL, fill_after REAL,
+  bucket INTEGER, day INTEGER, hour INTEGER,
+  finish TEXT, has_error INTEGER, tool_calls INTEGER, tool_errors INTEGER,
+  additions INTEGER, deletions INTEGER, write_lines INTEGER, text TEXT
+);
+CREATE INDEX IF NOT EXISTS turns_session ON turns(session_id);
+CREATE INDEX IF NOT EXISTS turns_project_time ON turns(project, created);
+CREATE INDEX IF NOT EXISTS turns_time ON turns(created);
+CREATE INDEX IF NOT EXISTS turns_bucket ON turns(bucket);
+
+CREATE TABLE IF NOT EXISTS tools (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT, turn_id TEXT, call_id TEXT, name TEXT, status TEXT,
+  started INTEGER, ended INTEGER, dur_ms INTEGER,
+  title TEXT, output_chars INTEGER, additions INTEGER, deletions INTEGER, files INTEGER, write_lines INTEGER,
+  error TEXT, sig TEXT, input_preview TEXT, target_session TEXT
+);
+CREATE INDEX IF NOT EXISTS tools_session ON tools(session_id, started);
+CREATE INDEX IF NOT EXISTS tools_target ON tools(target_session);
+
+-- The ordered content stream of every assistant turn: the text it wrote, the
+-- reasoning it produced, and each tool call with its input and output. This is the
+-- one table that is a transcript rather than a metric, so bodies are capped (see
+-- PARTS_CAP in build.ts) \u2014 the UI renders at most 40 output lines and one input row
+-- per key, and the caps keep a 234 MB source from becoming a 234 MB copy.
+CREATE TABLE IF NOT EXISTS parts (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL, turn_id TEXT NOT NULL, ordinal INTEGER,
+  kind TEXT NOT NULL,              -- text | reasoning | tool
+  text TEXT,                       -- body for text/reasoning
+  name TEXT, call_id TEXT, status TEXT, title TEXT,
+  input TEXT, output TEXT, exit_code INTEGER, truncated INTEGER,
+  started INTEGER, ended INTEGER, chars INTEGER
+);
+CREATE INDEX IF NOT EXISTS parts_turn ON parts(turn_id);
+CREATE INDEX IF NOT EXISTS parts_session ON parts(session_id, id);
+
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT, turn_id TEXT, type TEXT, at INTEGER, end_at INTEGER, count INTEGER,
+  fill REAL, detail TEXT
+);
+CREATE INDEX IF NOT EXISTS events_session ON events(session_id, at);
+CREATE INDEX IF NOT EXISTS events_time ON events(at);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY, project TEXT, directory TEXT, title TEXT,
+  agent TEXT, provider TEXT, model TEXT, variant TEXT, parent_id TEXT, depth INTEGER,
+  created INTEGER, updated INTEGER,
+  t_input INTEGER, t_output INTEGER, t_reasoning INTEGER, t_cache_read INTEGER, t_cache_write INTEGER,
+  cost REAL, credits_micro INTEGER DEFAULT 0, turns INTEGER, tool_calls INTEGER, tool_errors INTEGER,
+  compactions INTEGER, retries INTEGER, loops INTEGER,
+  additions INTEGER, deletions INTEGER, files_changed INTEGER,
+  peak_fill REAL, avg_fill REAL, eff_score REAL, tokens_per_line REAL,
+  first_prompt TEXT, duration_ms INTEGER, dominant_model TEXT, output_rate REAL
+);
+CREATE INDEX IF NOT EXISTS sessions_project ON sessions(project, created);
+CREATE INDEX IF NOT EXISTS sessions_parent ON sessions(parent_id);
+
+-- ECG substrate: token flow per (project, 5-min bucket). tokens_gen is the
+-- generation signal (input+output+reasoning); cache_read is kept separate because
+-- it is ~14x larger and would otherwise drown the waveform.
+CREATE TABLE IF NOT EXISTS flow (
+  project TEXT, bucket INTEGER,
+  tokens_gen INTEGER, tokens_cache_read INTEGER, cost REAL,
+  sessions INTEGER, dominant_model TEXT, peak_fill REAL,
+  PRIMARY KEY (project, bucket)
+);
+CREATE INDEX IF NOT EXISTS flow_time ON flow(bucket);
+CREATE INDEX IF NOT EXISTS flow_project ON flow(project, bucket);
+
+-- Circadian spectrogram: kept per local day so the time scrubber can re-slice it.
+CREATE TABLE IF NOT EXISTS heat (
+  project TEXT, day INTEGER, hour INTEGER,
+  tokens_gen INTEGER, tokens_cache_read INTEGER, cost REAL, turns INTEGER,
+  PRIMARY KEY (project, day, hour)
+);
+CREATE INDEX IF NOT EXISTS heat_idx ON heat(day, hour);
+
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+`
+);
+function initSchema(db, opts = {}) {
+  if (opts.drop) {
+    for (const t of FACT_TABLES) db.exec(`DROP TABLE IF EXISTS ${t}`);
+  }
+  db.exec(SCHEMA);
+  ensureIndexes(db);
+  ensureRollups(db);
+  setMeta(db, "schemaSig", SCHEMA_SIG);
+}
+var INDEXES = (
+  /* sql */
+  `
+CREATE INDEX IF NOT EXISTS tools_turn ON tools(turn_id);
+`
+);
+function ensureIndexes(db) {
+  const built = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='tools'").get();
+  if (!built) return;
+  db.exec(INDEXES);
+}
+var SCHEMA_SIG = fingerprint(SCHEMA);
+function fingerprint(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+function setMeta(db, key, value) {
+  db.prepare("INSERT INTO meta(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(key, value);
+}
+function getMeta(db, key) {
+  const r = db.prepare("SELECT value FROM meta WHERE key=?").get(key);
+  return r?.value ?? null;
+}
+function getMetaNumber(db, key) {
+  return Number(getMeta(db, key) ?? 0) || 0;
+}
+
+// src/metrics/buckets.ts
+var GRANULARITIES = ["5m", "hour", "day", "week", "month", "quarter", "year"];
+var MAX_COLS = 200;
+var MINUTE = 6e4;
+var HOUR_MS = 36e5;
+var DAY_MS = 864e5;
+var WEEK_MS = 7 * DAY_MS;
+function localDay(ts) {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+function localWeek(ts) {
+  const d = new Date(localDay(ts));
+  d.setDate(d.getDate() - (d.getDay() + 6) % 7);
+  return d.getTime();
+}
+function bucketStart(ts, gran) {
+  switch (gran) {
+    case "5m":
+      return Math.floor(ts / (5 * MINUTE)) * 5 * MINUTE;
+    case "hour":
+      return Math.floor(ts / HOUR_MS) * HOUR_MS;
+    case "day":
+      return localDay(ts);
+    case "week":
+      return localWeek(ts);
+    case "month": {
+      const d = new Date(ts);
+      return new Date(d.getFullYear(), d.getMonth(), 1).getTime();
+    }
+    case "quarter": {
+      const d = new Date(ts);
+      return new Date(d.getFullYear(), Math.floor(d.getMonth() / 3) * 3, 1).getTime();
+    }
+    case "year": {
+      const d = new Date(ts);
+      return new Date(d.getFullYear(), 0, 1).getTime();
+    }
+  }
+}
+function nextBucket(ts, gran) {
+  switch (gran) {
+    case "5m":
+      return ts + 5 * MINUTE;
+    case "hour":
+      return ts + HOUR_MS;
+    case "day":
+      return ts + DAY_MS;
+    case "week":
+      return ts + WEEK_MS;
+    case "month": {
+      const d = new Date(ts);
+      return new Date(d.getFullYear(), d.getMonth() + 1, 1).getTime();
+    }
+    case "quarter": {
+      const d = new Date(ts);
+      return new Date(d.getFullYear(), d.getMonth() + 3, 1).getTime();
+    }
+    case "year": {
+      const d = new Date(ts);
+      return new Date(d.getFullYear() + 1, 0, 1).getTime();
+    }
+  }
+}
+var monthsBetween = (a, b) => {
+  const da = new Date(a);
+  const db = new Date(b);
+  return (db.getFullYear() - da.getFullYear()) * 12 + (db.getMonth() - da.getMonth());
+};
+function bucketCount(from, to, gran) {
+  if (!(to >= from)) return 1;
+  const first = bucketStart(from, gran);
+  switch (gran) {
+    case "5m":
+      return Math.floor((to - first) / (5 * MINUTE)) + 1;
+    case "hour":
+      return Math.floor((to - first) / HOUR_MS) + 1;
+    case "day":
+      return Math.floor((to - first) / DAY_MS) + 1;
+    case "week":
+      return Math.round((localWeek(to) - first) / WEEK_MS) + 1;
+    case "month":
+      return monthsBetween(first, to) + 1;
+    case "quarter":
+      return Math.floor(monthsBetween(first, to) / 3) + 1;
+    case "year":
+      return new Date(to).getFullYear() - new Date(first).getFullYear() + 1;
+  }
+}
+function bucketStarts(from, to, gran) {
+  const count = Math.min(bucketCount(from, to, gran), MAX_COLS * 4);
+  const out = [];
+  let ts = bucketStart(from, gran);
+  for (let i = 0; i < count; i++) {
+    out.push(ts);
+    ts = nextBucket(ts, gran);
+  }
+  return out;
+}
+function bucketKeySql(gran) {
+  switch (gran) {
+    case "5m":
+      return "t.bucket";
+    case "hour":
+      return "(t.bucket - (t.bucket % 3600000))";
+    case "day":
+      return "t.day";
+    // `t.day` is a local midnight, so its weekday has to be read in local time too —
+    // reading it as UTC gives the previous day's weekday west of Greenwich and lands the
+    // whole week a day early.
+    case "week":
+      return "(t.day - ((CAST(strftime('%w', t.day / 1000, 'unixepoch', 'localtime') AS INTEGER) + 6) % 7) * 86400000)";
+    case "month":
+      return "strftime('%Y-%m', t.created / 1000, 'unixepoch', 'localtime')";
+    case "quarter":
+      return "strftime('%Y', t.created / 1000, 'unixepoch', 'localtime') || '-Q' || CAST((CAST(strftime('%m', t.created / 1000, 'unixepoch', 'localtime') AS INTEGER) - 1) / 3 AS INTEGER)";
+    case "year":
+      return "strftime('%Y', t.created / 1000, 'unixepoch', 'localtime')";
+  }
+}
+function calendarKey(ts, gran) {
+  const d = new Date(ts);
+  const year = String(d.getFullYear()).padStart(4, "0");
+  if (gran === "year") return year;
+  if (gran === "quarter") return `${year}-Q${Math.floor(d.getMonth() / 3)}`;
+  return `${year}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+}
+function bucketIndexer(gran, starts) {
+  const last = Math.max(0, starts.length - 1);
+  if (gran === "month" || gran === "quarter" || gran === "year") {
+    const table = /* @__PURE__ */ new Map();
+    starts.forEach((ts, i) => table.set(calendarKey(ts, gran), i));
+    return (key) => table.get(String(key)) ?? -1;
+  }
+  const step = gran === "5m" ? 5 * MINUTE : gran === "hour" ? HOUR_MS : gran === "day" ? DAY_MS : WEEK_MS;
+  const first = starts[0] ?? 0;
+  return (key) => {
+    const i = Math.floor((Number(key) - first) / step);
+    return i < 0 ? 0 : i > last ? last : i;
+  };
+}
+function pickGranularity(from, to, requested = null) {
+  const span = Math.max(0, to - from);
+  const natural = span <= 3 * DAY_MS ? "hour" : span <= 180 * DAY_MS ? "day" : "week";
+  let unit = requested ?? natural;
+  while (bucketCount(from, to, unit) > MAX_COLS) {
+    const next = GRANULARITIES[GRANULARITIES.indexOf(unit) + 1];
+    if (!next) break;
+    unit = next;
+  }
+  return unit;
+}
+function isGranularity(value) {
+  return typeof value === "string" && GRANULARITIES.includes(value);
+}
+
+// src/metrics/analytics.ts
+var ZERO = {
+  input: 0,
+  output: 0,
+  reasoning: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  total: 0,
+  cost: 0,
+  turns: 0,
+  tools: 0,
+  errors: 0,
+  sessions: 0,
+  additions: 0,
+  deletions: 0,
+  writeLines: 0
+};
+var num = (v) => {
+  const n = Number(v ?? 0);
+  return Number.isFinite(n) ? n : 0;
+};
+function turnWhere(slice) {
+  const parts = ["t.role = 'assistant'", "t.created >= ?", "t.created < ?"];
+  const args = [slice.from, slice.to];
+  if (slice.project) {
+    parts.push("COALESCE(t.project,'\u2014') = ?");
+    args.push(slice.project);
+  }
+  if (slice.model) {
+    parts.push("COALESCE(t.model,'unknown') = ?");
+    args.push(slice.model);
+  }
+  if (slice.agent) {
+    parts.push("COALESCE(t.agent,'main') = ?");
+    args.push(slice.agent);
+  }
+  return { sql: parts.join(" AND "), args };
+}
+function granularityOf(db, slice) {
+  const row = db.prepare("SELECT MIN(created) a FROM turns WHERE role='assistant'").get();
+  const dataFrom = num(row?.a) || slice.to;
+  const from = slice.from > 0 ? slice.from : dataFrom;
+  const requested = slice.gran ?? null;
+  return { gran: pickGranularity(from, slice.to, requested), from, requested };
+}
+function resolveSlice(db, slice) {
+  const { gran, from } = granularityOf(db, slice);
+  return { slice: { ...slice, from }, gran };
+}
+function totalsOf(db, slice) {
+  const span = rollSpan(db, slice);
+  const src = span ? cellSource(slice, span) : rawCellSource(slice);
+  const r = db.prepare(
+    `SELECT SUM(input) i, SUM(output) o, SUM(reasoning) r,
+              SUM(cache_read) cr, SUM(cache_write) cw, SUM(cost) cost,
+              SUM(turns) calls, SUM(tools) tools, SUM(tool_errors) errors,
+              COUNT(DISTINCT session_id) sessions,
+              SUM(additions) adds, SUM(deletions) dels, SUM(write_lines) writes
+         FROM (${src.sql})`
+  ).get(...src.args);
+  const input = num(r?.i);
+  const output = num(r?.o);
+  const cacheRead = num(r?.cr);
+  const cacheWrite = num(r?.cw);
+  return {
+    input,
+    output,
+    reasoning: num(r?.r),
+    cacheRead,
+    cacheWrite,
+    total: input + output + cacheRead + cacheWrite,
+    cost: num(r?.cost),
+    turns: num(r?.calls),
+    tools: num(r?.tools),
+    errors: num(r?.errors),
+    sessions: num(r?.sessions),
+    additions: num(r?.adds),
+    deletions: num(r?.dels),
+    writeLines: num(r?.writes)
+  };
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.round((sorted.length - 1) * p)));
+  return sorted[idx];
+}
+function efficiencyOf(db, slice, totals) {
+  const w = turnWhere(slice);
+  const rows = db.prepare(
+    `WITH x AS MATERIALIZED (
+         SELECT COALESCE(t.dur_ms,0) dur, COALESCE(t.output,0) out,
+                COALESCE(t.fill,0) fill, COALESCE(t.finish,'') finish
+         FROM turns t WHERE ${w.sql}
+       )
+       SELECT 'dur' kind, ${ladder.ms.key("dur")} bin, COUNT(*) n FROM x WHERE dur > 0 GROUP BY 2
+       UNION ALL
+       SELECT 'rate', ${ladder.rate.key("out * 1000.0 / dur")}, COUNT(*) FROM x WHERE dur > 0 AND out > 0 GROUP BY 2
+       UNION ALL
+       SELECT 'fill', ${ladder.share.key("fill")}, COUNT(*) FROM x WHERE fill > 0 GROUP BY 2
+       UNION ALL
+       SELECT 'durmax', 0, MAX(dur) FROM x
+       UNION ALL
+       SELECT 'peak', 0, MAX(fill) FROM x
+       UNION ALL
+       SELECT 'stopped', 0, SUM(CASE WHEN finish <> '' AND finish <> 'stop' THEN 1 ELSE 0 END) FROM x`
+  ).all(...w.args);
+  const channel = (kind) => histogramOf(rows.filter((r) => String(r.kind) === kind));
+  const scalar = (kind) => num(rows.find((r) => String(r.kind) === kind)?.n);
+  const durs = channel("dur");
+  const rates = channel("rate");
+  const fills = channel("fill");
+  const durMax = scalar("durmax");
+  const peak = scalar("peak");
+  return {
+    outputRate: histMedian(rates, ladder.rate),
+    turnMs: {
+      p50: quantile(durs, 0.5, ladder.ms, durMax),
+      p90: quantile(durs, 0.9, ladder.ms, durMax),
+      p99: quantile(durs, 0.99, ladder.ms, durMax)
+    },
+    cacheHit: totals.cacheRead + totals.input > 0 ? totals.cacheRead / (totals.cacheRead + totals.input) : 0,
+    fill: {
+      p50: quantile(fills, 0.5, ladder.share, peak),
+      p90: quantile(fills, 0.9, ladder.share, peak),
+      max: peak
+    },
+    stopped: scalar("stopped")
+  };
+}
+var MODEL_STACK = 8;
+function seriesOf(db, slice, gran) {
+  const span = gran === "5m" || gran === "hour" ? null : rollSpan(db, slice);
+  const src = span ? cellSource(slice, span) : rawCellSource(slice);
+  const hours = span ? hourSource(slice, span) : rawHourSource(slice);
+  const starts = bucketStarts(slice.from, slice.to, gran);
+  const indexOf = bucketIndexer(gran, starts);
+  const key = bucketKeySql(gran);
+  const count = starts.length;
+  const cells = db.prepare(
+    `SELECT ${key} k, model,
+              SUM(input) i, SUM(output) o, SUM(reasoning) r,
+              SUM(cache_read) cr, SUM(cache_write) cw, SUM(cost) cost,
+              SUM(turns) calls, SUM(tools) tools, SUM(tool_errors) errors,
+              SUM(additions) adds, SUM(deletions) dels, SUM(write_lines) writes
+       FROM (${src.sql}) t
+       GROUP BY k, model`
+  ).all(...src.args);
+  const sessionRows = db.prepare(`SELECT ${key} k, COUNT(DISTINCT session_id) n FROM (${src.sql}) t GROUP BY k`).all(...src.args);
+  const heatRows = db.prepare(hours.sql).all(...hours.args);
+  const buckets = starts.map((ts) => ({ ts, ...ZERO }));
+  const modelTotals = /* @__PURE__ */ new Map();
+  const perModel = /* @__PURE__ */ new Map();
+  for (const c of cells) {
+    const i = indexOf(c.k);
+    if (i < 0) continue;
+    const b = buckets[i];
+    const input = num(c.i);
+    const output = num(c.o);
+    const cacheRead = num(c.cr);
+    const cacheWrite = num(c.cw);
+    const total = input + output + cacheRead + cacheWrite;
+    b.input += input;
+    b.output += output;
+    b.reasoning += num(c.r);
+    b.cacheRead += cacheRead;
+    b.cacheWrite += cacheWrite;
+    b.total += total;
+    b.cost += num(c.cost);
+    b.turns += num(c.calls);
+    b.tools += num(c.tools);
+    b.errors += num(c.errors);
+    b.additions += num(c.adds);
+    b.deletions += num(c.dels);
+    b.writeLines += num(c.writes);
+    const row = perModel.get(c.model) ?? new Array(count).fill(0);
+    row[i] += total;
+    perModel.set(c.model, row);
+    modelTotals.set(c.model, (modelTotals.get(c.model) ?? 0) + total);
+  }
+  for (const s of sessionRows) {
+    const i = indexOf(s.k);
+    if (i >= 0) buckets[i].sessions = num(s.n);
+  }
+  const heat = Array.from({ length: 7 }, () => new Array(24).fill(0));
+  const hourly = new Array(24).fill(0);
+  for (const r of heatRows) {
+    const hour = Math.max(0, Math.min(23, num(r.hour)));
+    const weekday = (new Date(num(r.day)).getDay() + 6) % 7;
+    heat[weekday][hour] += num(r.n);
+    hourly[hour] += num(r.n);
+  }
+  const ranked = [...modelTotals.entries()].sort((a, b) => b[1] - a[1]).map(([m]) => m);
+  const models = ranked.slice(0, MODEL_STACK);
+  const rest = ranked.slice(MODEL_STACK);
+  const modelTokens = models.map((m) => perModel.get(m) ?? new Array(count).fill(0));
+  if (rest.length) {
+    const other = new Array(count).fill(0);
+    for (const m of rest) {
+      const row = perModel.get(m);
+      for (let i = 0; i < count; i++) other[i] += row[i];
+    }
+    models.push("other");
+    modelTokens.push(other);
+  }
+  return { gran, buckets, models, modelTokens, heat, hourly };
+}
+function modelsOf(db, slice) {
+  const span = rollSpan(db, slice);
+  const src = span ? cellSource(slice, span) : rawCellSource(slice);
+  const rows = db.prepare(
+    `SELECT model id, SUM(turns) calls,
+              SUM(input+output+cache_read+cache_write) tokens,
+              SUM(input) input, SUM(output) output, SUM(cost) cost,
+              COUNT(DISTINCT session_id) sessions
+       FROM (${src.sql}) t GROUP BY model ORDER BY tokens DESC`
+  ).all(...src.args);
+  return rows.map((r) => ({
+    id: String(r.id),
+    calls: num(r.calls),
+    tokens: num(r.tokens),
+    input: num(r.input),
+    output: num(r.output),
+    cost: num(r.cost),
+    sessions: num(r.sessions)
+  }));
+}
+function projectsOf(db, slice) {
+  const span = rollSpan(db, slice);
+  const src = span ? cellSource(slice, span) : rawCellSource(slice);
+  const rows = db.prepare(
+    `SELECT project, COUNT(DISTINCT session_id) sessions, SUM(turns) turns,
+              SUM(input+output+cache_read+cache_write) tokens, SUM(cost) cost,
+              SUM(tools) tools, SUM(tool_errors) errors
+       FROM (${src.sql}) t GROUP BY project ORDER BY tokens DESC`
+  ).all(...src.args);
+  return rows.map((r) => ({
+    project: String(r.project),
+    sessions: num(r.sessions),
+    turns: num(r.turns),
+    tokens: num(r.tokens),
+    cost: num(r.cost),
+    tools: num(r.tools),
+    errors: num(r.errors)
+  }));
+}
+function agentsOf(db, slice) {
+  const span = rollSpan(db, slice);
+  const src = span ? cellSource(slice, span) : rawCellSource(slice);
+  const rows = db.prepare(
+    `SELECT agent, SUM(turns) turns,
+              SUM(input+output+cache_read+cache_write) tokens, SUM(cost) cost,
+              COUNT(DISTINCT session_id) sessions,
+              SUM(tools) tools, SUM(tool_errors) errors
+       FROM (${src.sql}) t GROUP BY agent ORDER BY tokens DESC`
+  ).all(...src.args);
+  return rows.map((r) => ({
+    agent: String(r.agent),
+    turns: num(r.turns),
+    tokens: num(r.tokens),
+    cost: num(r.cost),
+    sessions: num(r.sessions),
+    tools: num(r.tools),
+    errors: num(r.errors)
+  }));
+}
+function toolsOf(db, slice) {
+  const span = rollSpan(db, slice);
+  const sums = span ? toolSource(slice, span) : rawToolSource(slice);
+  const bins = span ? toolBins(slice, span) : rawToolBins(slice);
+  const people = db.prepare(
+    `SELECT name, SUM(calls) calls, SUM(errors) errors, SUM(ms) ms, MAX(mx) maxMs,
+              COUNT(DISTINCT session_id) sessions, COUNT(DISTINCT agent) agents
+       FROM (${sums.sql}) GROUP BY name`
+  ).all(...sums.args);
+  const hist = db.prepare(bins.sql).all(...bins.args);
+  const acc = /* @__PURE__ */ new Map();
+  for (const r of people) {
+    const name = String(r.name);
+    acc.set(name, {
+      name,
+      calls: num(r.calls),
+      errors: num(r.errors),
+      totalMs: num(r.ms),
+      maxMs: num(r.maxMs),
+      sessions: num(r.sessions),
+      agents: num(r.agents),
+      hist: /* @__PURE__ */ new Map()
+    });
+  }
+  for (const r of hist) {
+    const a = acc.get(String(r.name));
+    if (!a) continue;
+    const bin = Number(r.bin) || 0;
+    a.hist.set(bin, (a.hist.get(bin) ?? 0) + num(r.n));
+  }
+  return [...acc.values()].map((a) => ({
+    name: a.name,
+    calls: a.calls,
+    errors: a.errors,
+    totalMs: a.totalMs,
+    avgMs: a.calls > 0 ? a.totalMs / a.calls : 0,
+    p50Ms: quantile(a.hist, 0.5, ladder.ms, a.maxMs),
+    p95Ms: quantile(a.hist, 0.95, ladder.ms, a.maxMs),
+    maxMs: a.maxMs,
+    sessions: a.sessions,
+    agents: a.agents
+  })).sort((x, y) => y.calls - x.calls);
+}
+function sessionAgg(db, slice) {
+  const span = rollSpan(db, slice);
+  const meta = `SELECT s.id id, s.parent_id parent, COALESCE(s.title,'') title, COALESCE(s.project,'\u2014') project,
+                       COALESCE(s.agent,'main') agent, COALESCE(s.model,'') model,
+                       COALESCE(s.created,0) created, COALESCE(s.updated,0) updated,
+                       COALESCE(s.first_prompt,'') prompt, COALESCE(s.peak_fill,0) peak,
+                       a.i i, a.o o, a.cr cr, a.cw cw, a.tokens tokens, a.cost cost, a.turns turns,
+                       a.tools tools, a.errors errors, a.span span, a.win win, a.ctx ctx
+                  FROM (`;
+  if (span) {
+    const src = cellSource(slice, span);
+    return {
+      args: src.args,
+      sql: `${meta}SELECT session_id id, SUM(input) i, SUM(output) o, SUM(cache_read) cr, SUM(cache_write) cw,
+                   SUM(input+output+cache_read+cache_write) tokens, SUM(cost) cost, SUM(turns) turns,
+                   SUM(tools) tools, SUM(tool_errors) errors,
+                   MAX(ended) - MIN(created) span, MAX(win) win,
+                   SUM(input+cache_read+cache_write) * 1.0 /
+                     MAX(CASE WHEN win > 0 THEN win ELSE 128000 END) ctx
+              FROM (${src.sql}) GROUP BY session_id) a
+             JOIN sessions s ON s.id = a.id`
+    };
+  }
+  const w = turnWhere(slice);
+  return {
+    args: w.args,
+    sql: `${meta}SELECT t.session_id id, SUM(t.input) i, SUM(t.output) o,
+                   SUM(t.cache_read) cr, SUM(t.cache_write) cw,
+                   SUM(t.input+t.output+t.cache_read+t.cache_write) tokens,
+                   SUM(t.cost) cost, COUNT(*) turns,
+                   SUM(COALESCE(t.tool_calls,0)) tools, SUM(COALESCE(t.tool_errors,0)) errors,
+                   MAX(COALESCE(t.completed,t.created)) - MIN(t.created) span,
+                   MAX(COALESCE(t.context_window,0)) win,
+                   SUM(t.input+t.cache_read+t.cache_write) * 1.0 /
+                     MAX(CASE WHEN COALESCE(t.context_window,0) > 0 THEN t.context_window ELSE 128000 END) ctx
+              FROM turns t WHERE ${w.sql} GROUP BY t.session_id) a
+             JOIN sessions s ON s.id = a.id`
+  };
+}
+function toSessionRows(rows) {
+  const ids = new Set(rows.map((r) => String(r.id)));
+  const childCount = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const p = r.parent == null ? "" : String(r.parent);
+    if (p && ids.has(p)) childCount.set(p, (childCount.get(p) ?? 0) + 1);
+  }
+  return rows.map((r) => {
+    const id = String(r.id);
+    const spanMs = num(r.span);
+    const out = num(r.o);
+    const input = num(r.i);
+    const cacheRead = num(r.cr);
+    const cacheWrite = num(r.cw);
+    const window = num(r.win) || 128e3;
+    const model = r.model == null || String(r.model) === "" ? null : String(r.model);
+    return {
+      id,
+      title: String(r.title) || null,
+      project: String(r.project),
+      agent: r.agent == null ? null : String(r.agent),
+      model,
+      parentId: r.parent == null ? null : String(r.parent),
+      created: num(r.created),
+      updated: num(r.updated),
+      tokens: num(r.tokens),
+      input,
+      output: out,
+      cacheRead,
+      cacheWrite,
+      cost: num(r.cost),
+      turns: num(r.turns),
+      tools: num(r.tools),
+      errors: num(r.errors),
+      spanMs,
+      outputRate: spanMs > 0 && out > 0 ? out / spanMs * 1e3 : 0,
+      // Same context convention as the rest of the project: what the provider had to
+      // re-read plus what it wrote, over the model's window.
+      contextPct: (input + cacheRead + cacheWrite) / window,
+      peakFill: num(r.peak),
+      firstPrompt: String(r.prompt) || null,
+      childCount: childCount.get(id) ?? 0
+    };
+  });
+}
+var SESSION_SAMPLE = 200;
+var MAX_PAGE_ROOTS = 500;
+function sessionsOf(db, slice) {
+  const a = sessionAgg(db, slice);
+  const rows = db.prepare(`${a.sql} ORDER BY tokens DESC, id DESC LIMIT ${SESSION_SAMPLE}`).all(...a.args);
+  return toSessionRows(rows);
+}
+var SESSION_ORDER_COLUMN = {
+  updated: "updated",
+  created: "created",
+  tokens: "tokens",
+  cost: "cost",
+  turns: "turns",
+  tools: "tools",
+  errors: "errors",
+  span: "span",
+  ctx: "ctx",
+  title: "title",
+  project: "project",
+  model: "model",
+  agent: "agent"
+};
+var SESSION_ORDERS = Object.keys(SESSION_ORDER_COLUMN);
+var likePattern = (q) => `%${q.replace(/[\%_]/g, (c) => `\${c}`)}%`;
+var encodeCursor = (value) => Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+var decodeCursor = (raw) => {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+    if (parsed.id == null) return null;
+    return { v: parsed.v ?? 0, id: String(parsed.id) };
+  } catch {
+    return null;
+  }
+};
+function sessionsPage(db, slice, opts = {}) {
+  const agg = sessionAgg(db, slice);
+  const q = (opts.q ?? "").trim();
+  const order = SESSION_ORDER_COLUMN[opts.order ?? "updated"] ?? "updated";
+  const asc = opts.dir === "asc";
+  const limit = Math.min(MAX_PAGE_ROOTS, Math.max(1, Math.round(opts.limit ?? MAX_PAGE_ROOTS)));
+  const hit = q ? `SELECT * FROM agg WHERE title LIKE ? ESCAPE '\\' OR project LIKE ? ESCAPE '\\'
+              OR model LIKE ? ESCAPE '\\' OR agent LIKE ? ESCAPE '\\' OR prompt LIKE ? ESCAPE '\\'` : "SELECT * FROM agg";
+  const hitArgs = q ? Array(5).fill(likePattern(q)) : [];
+  const args = [...agg.args, ...hitArgs];
+  const cursor = decodeCursor(opts.cursor);
+  const cursorSql = cursor ? `WHERE (${order}, id) ${asc ? ">" : "<"} (?, ?)` : "";
+  const cursorArgs = cursor ? [cursor.v, cursor.id] : [];
+  const direction = asc ? "ASC" : "DESC";
+  const prefix = `WITH RECURSIVE
+      agg AS MATERIALIZED (${agg.sql}),
+      hit AS (${hit}),
+      keep(id) AS (
+        SELECT id FROM hit
+        UNION
+        SELECT a.parent FROM agg a JOIN keep k ON a.id = k.id
+         WHERE a.parent IS NOT NULL AND a.parent IN (SELECT id FROM agg)
+      ),
+      roots AS (
+        SELECT * FROM agg WHERE id IN (SELECT id FROM keep)
+          AND (parent IS NULL OR parent NOT IN (SELECT id FROM keep))
+      ),
+      page AS (
+        SELECT * FROM roots ${cursorSql} ORDER BY ${order} ${direction}, id ${direction} LIMIT ?
+      ),
+      down(id) AS (
+        SELECT id FROM page
+        UNION
+        SELECT a.id FROM agg a JOIN down d ON a.parent = d.id WHERE a.id IN (SELECT id FROM keep)
+      ),
+      matched AS (SELECT * FROM agg WHERE id IN (SELECT id FROM keep))`;
+  const rows = db.prepare(
+    `${prefix}
+       SELECT a.*, (a.id IN (SELECT id FROM page)) inpage,
+              (SELECT COUNT(*) FROM matched) matching,
+              (SELECT COUNT(*) FROM roots) roots,
+              (SELECT SUM(tokens) FROM matched) m_tokens,
+              (SELECT SUM(cost) FROM matched) m_cost,
+              (SELECT SUM(turns) FROM matched) m_turns,
+              (SELECT SUM(tools) FROM matched) m_tools,
+              (SELECT SUM(errors) FROM matched) m_errors,
+              (SELECT COUNT(*) FROM matched) m_sessions
+         FROM agg a JOIN down d ON d.id = a.id
+         ORDER BY ${order} ${direction}, a.id ${direction}`
+  ).all(...args, ...cursorArgs, limit + 1);
+  const meta = rows[0];
+  const pageRoots = rows.filter((r) => num(r.inpage) === 1);
+  const cut = pageRoots.length > limit ? String(pageRoots[limit].id) : null;
+  let shipped = rows;
+  if (cut) {
+    const drop = /* @__PURE__ */ new Set([cut]);
+    for (let grew = true; grew; ) {
+      grew = false;
+      for (const r of rows) {
+        const id = String(r.id);
+        const parent = r.parent == null ? null : String(r.parent);
+        if (!drop.has(id) && parent !== null && drop.has(parent)) {
+          drop.add(id);
+          grew = true;
+        }
+      }
+    }
+    shipped = rows.filter((r) => !drop.has(String(r.id)));
+  }
+  const kept = pageRoots.slice(0, limit);
+  const last = kept[kept.length - 1];
+  const next = cut && last ? encodeCursor({ v: last[order] ?? 0, id: String(last.id) }) : null;
+  return {
+    rows: toSessionRows(shipped),
+    matching: num(meta?.matching),
+    roots: num(meta?.roots),
+    next,
+    totals: {
+      sessions: num(meta?.m_sessions),
+      tokens: num(meta?.m_tokens),
+      cost: num(meta?.m_cost),
+      turns: num(meta?.m_turns),
+      tools: num(meta?.m_tools),
+      errors: num(meta?.m_errors)
+    }
+  };
+}
+function sessionContext(db, slice, id) {
+  const agg = sessionAgg(db, slice);
+  const rows = db.prepare(
+    `WITH RECURSIVE
+       agg AS (${agg.sql}),
+       focus AS (SELECT parent FROM agg WHERE id = ?),
+       up(id) AS (
+         SELECT parent FROM focus WHERE parent IS NOT NULL
+         UNION
+         SELECT a.parent FROM agg a JOIN up ON a.id = up.id WHERE a.parent IS NOT NULL
+       )
+       SELECT a.* FROM agg a
+        WHERE a.id = ? OR a.id IN (SELECT id FROM up)
+           OR a.parent = ? OR a.parent = (SELECT parent FROM focus)
+        ORDER BY updated DESC`
+  ).all(...agg.args, id, id, id);
+  return toSessionRows(rows);
+}
+var kpi = (value, prev, comparable) => ({
+  value,
+  prev,
+  delta: !comparable || prev <= 0 ? comparable && value === 0 ? 0 : null : (value - prev) / prev
+});
+function dashboard(db, raw) {
+  const { slice, gran } = resolveSlice(db, raw);
+  const span = slice.to - slice.from;
+  const totals = totalsOf(db, slice);
+  const hasPrev = raw.from > 0 && span > 0;
+  const prev = hasPrev ? totalsOf(db, { ...slice, from: slice.from - span, to: slice.from }) : ZERO;
+  return {
+    generatedAt: Date.now(),
+    slice: { ...slice, gran, granRequested: raw.gran ?? null, resolvedFrom: slice.from, spanMs: span },
+    totals,
+    kpis: {
+      tokens: kpi(totals.total, prev.total, hasPrev),
+      cost: kpi(totals.cost, prev.cost, hasPrev),
+      turns: kpi(totals.turns, prev.turns, hasPrev),
+      tools: kpi(totals.tools, prev.tools, hasPrev),
+      errors: kpi(totals.errors, prev.errors, hasPrev),
+      sessions: kpi(totals.sessions, prev.sessions, hasPrev),
+      output: kpi(totals.output, prev.output, hasPrev),
+      additions: kpi(totals.additions, prev.additions, hasPrev),
+      deletions: kpi(totals.deletions, prev.deletions, hasPrev)
+    },
+    efficiency: efficiencyOf(db, slice, totals),
+    series: seriesOf(db, slice, gran),
+    models: modelsOf(db, slice),
+    projects: projectsOf(db, slice),
+    agents: agentsOf(db, slice),
+    tools: toolsOf(db, slice),
+    sessions: sessionsOf(db, slice)
+  };
+}
+function errorKey(message) {
+  return message.split("\n")[0].trim().replace(/https?:\/\/\S+/g, "<url>").replace(/(?<![\w.])\/(?:[\w.@+-]+\/)*[\w.@+-]*/g, "<path>").replace(/\b[0-9a-f]{7,}\b/gi, "<hash>").replace(/\d+(?:[.,:]\d+)*/g, "<n>").slice(0, 160);
+}
+var LAT_BINS = [
+  ["0\u201310ms", 0, 10],
+  ["10\u201350ms", 10, 50],
+  ["50\u2013200ms", 50, 200],
+  ["200ms\u20131s", 200, 1e3],
+  ["1\u20135s", 1e3, 5e3],
+  ["5\u201330s", 5e3, 3e4],
+  ["30s+", 3e4, Infinity]
+];
+function toolDetail(db, raw, name) {
+  const { slice, gran } = resolveSlice(db, raw);
+  const w = turnWhere(slice);
+  const args = [...w.args, name];
+  const rows = db.prepare(
+    `SELECT tl.name name, COALESCE(tl.dur_ms,0) ms, tl.status status,
+              COALESCE(tl.started,0) started,
+              COALESCE(tl.error,'') error, COALESCE(tl.session_id,'') session,
+              COALESCE(t.agent,'main') agent, COALESCE(t.project,'\u2014') project,
+              COALESCE(tl.additions,0) adds, COALESCE(tl.deletions,0) dels,
+              COALESCE(tl.files,0) files, COALESCE(tl.output_chars,0) chars
+       FROM tools tl JOIN turns t ON t.id = tl.turn_id
+       WHERE ${w.sql} AND tl.name = ?`
+  ).all(...args);
+  const starts = bucketStarts(slice.from, slice.to, gran);
+  const buckets = starts.map((ts) => ({ ts, calls: 0, errors: 0, avgMs: 0, totalMs: 0 }));
+  const place = bucketIndexer(gran, starts);
+  const idx = (ts) => {
+    const start = bucketStart(ts, gran);
+    const i = place(gran === "month" || gran === "quarter" || gran === "year" ? calendarKey(start, gran) : start);
+    return i < 0 ? 0 : i;
+  };
+  const latency = LAT_BINS.map(([label, lo, hi]) => ({ label, count: 0, upperMs: hi }));
+  const agents = /* @__PURE__ */ new Map();
+  const projects = /* @__PURE__ */ new Map();
+  const signatures = /* @__PURE__ */ new Map();
+  const recentErrors = [];
+  let additions = 0;
+  let deletions = 0;
+  let files = 0;
+  let chars = 0;
+  let failures = 0;
+  for (const r of rows) {
+    const ms2 = num(r.ms);
+    const isError = r.status === "error";
+    const b = buckets[idx(num(r.started) || slice.to - 1)];
+    b.calls++;
+    if (isError) b.errors++;
+    b.totalMs += ms2;
+    if (isError) failures++;
+    additions += num(r.adds);
+    deletions += num(r.dels);
+    files += num(r.files);
+    chars += num(r.chars);
+    for (let k = 0; k < LAT_BINS.length; k++) {
+      if (ms2 >= LAT_BINS[k][1] && ms2 < LAT_BINS[k][2]) {
+        latency[k].count++;
+        break;
+      }
+    }
+    const agent = String(r.agent);
+    const a = agents.get(agent) ?? { agent, calls: 0, errors: 0 };
+    a.calls++;
+    if (isError) a.errors++;
+    agents.set(agent, a);
+    const project = String(r.project);
+    const p = projects.get(project) ?? { project, calls: 0, errors: 0 };
+    p.calls++;
+    if (isError) p.errors++;
+    projects.set(project, p);
+    if (isError) {
+      const body = String(r.error ?? "").trim() || "tool error";
+      const key = errorKey(body);
+      const s = signatures.get(key);
+      if (s) s.count++;
+      else signatures.set(key, { message: body.split("\n")[0].slice(0, 160), count: 1, sample: body.slice(0, 400) });
+    }
+    if (isError && String(r.error) && recentErrors.length < 12) {
+      recentErrors.push({ at: num(r.started), session: String(r.session), error: String(r.error).slice(0, 400) });
+    }
+  }
+  for (const b of buckets) b.avgMs = b.calls > 0 ? b.totalMs / b.calls : 0;
+  const calls = rows.length;
+  const totalMs = rows.reduce((a, r) => a + num(r.ms), 0);
+  const durs = rows.map((r) => num(r.ms)).sort((a, b) => a - b);
+  const sessions = new Set(rows.map((r) => String(r.session))).size;
+  return {
+    name,
+    gran,
+    totals: {
+      name,
+      calls,
+      errors: failures,
+      totalMs,
+      avgMs: calls > 0 ? totalMs / calls : 0,
+      p50Ms: percentile(durs, 0.5),
+      p95Ms: percentile(durs, 0.95),
+      maxMs: durs.length ? durs[durs.length - 1] : 0,
+      sessions,
+      agents: agents.size
+    },
+    buckets,
+    latency,
+    agents: [...agents.values()].sort((a, b) => b.calls - a.calls),
+    projects: [...projects.values()].sort((a, b) => b.calls - a.calls).slice(0, 12),
+    signatures: [...signatures.values()].sort((a, b) => b.count - a.count).slice(0, 8),
+    recentErrors,
+    edited: { additions, deletions, files, chars }
+  };
+}
+function facets(db) {
+  const projects = db.prepare(
+    `SELECT COALESCE(s.project,'\u2014') project, COUNT(*) sessions,
+              SUM(COALESCE(s.t_input,0)+COALESCE(s.t_output,0)+COALESCE(s.t_cache_read,0)+COALESCE(s.t_cache_write,0)) tokens,
+              SUM(COALESCE(s.cost,0)) cost, MAX(COALESCE(s.updated,0)) updated
+       FROM sessions s GROUP BY COALESCE(s.project,'\u2014') ORDER BY sessions DESC`
+  ).all();
+  const models = db.prepare(
+    `SELECT COALESCE(t.model,'unknown') id, COUNT(*) calls
+       FROM turns t WHERE t.role='assistant'
+       GROUP BY COALESCE(t.model,'unknown') ORDER BY calls DESC`
+  ).all();
+  const catalogue = /* @__PURE__ */ new Map();
+  for (const m of db.prepare("SELECT id, label FROM models").all()) {
+    const full = String(m.id);
+    const bare = full.includes("/") ? full.slice(full.lastIndexOf("/") + 1) : full;
+    const label = m.label == null ? null : String(m.label);
+    if (!label || label === full) {
+      if (!catalogue.has(bare)) catalogue.set(bare, bare);
+      continue;
+    }
+    catalogue.set(bare, label);
+  }
+  const agents = db.prepare(
+    `SELECT COALESCE(agent,'main') agent, COUNT(*) calls FROM turns WHERE role='assistant'
+       GROUP BY COALESCE(agent,'main') ORDER BY calls DESC`
+  ).all();
+  const extent = db.prepare("SELECT MIN(created) a, MAX(created) b FROM turns WHERE role='assistant'").get();
+  const tools = db.prepare("SELECT name, COUNT(*) calls FROM tools GROUP BY name ORDER BY calls DESC").all();
+  return {
+    projects: projects.map((p) => ({
+      project: String(p.project),
+      sessions: num(p.sessions),
+      tokens: num(p.tokens),
+      cost: num(p.cost),
+      updated: num(p.updated)
+    })),
+    models: models.map((m) => ({
+      id: String(m.id),
+      label: catalogue.get(String(m.id)) ?? String(m.id),
+      calls: num(m.calls)
+    })),
+    agents: agents.map((a) => ({ agent: String(a.agent), calls: num(a.calls) })),
+    tools: tools.map((t) => ({ name: String(t.name), calls: num(t.calls) })),
+    extent: { from: num(extent?.a), to: num(extent?.b) || Date.now() },
+    counts: {
+      sessions: num(db.prepare("SELECT COUNT(*) c FROM sessions").get()?.c),
+      turns: num(db.prepare("SELECT COUNT(*) c FROM turns WHERE role='assistant'").get()?.c),
+      tools: num(db.prepare("SELECT COUNT(*) c FROM tools").get()?.c),
+      parts: num(db.prepare("SELECT COUNT(*) c FROM parts").get()?.c)
+    }
+  };
+}
+
+// src/api.ts
+function createApp(deps) {
+  const app2 = express();
+  app2.use(cors({ exposedHeaders: ["x-osm-source"] }));
+  app2.use(express.json());
+  const kindOf = (req) => {
+    const raw = String(req.get("x-osm-source") ?? req.query.src ?? "").trim().toLowerCase();
+    return raw === "qoder" || raw === "opencode" ? raw : SOURCE_KIND;
+  };
+  const storeOf = (req, res) => {
+    const kind = kindOf(req);
+    if (deps.hasStore(kind)) return deps.db(kind);
+    res.status(503).json({ error: "source not materialized", source: kind });
+    return null;
+  };
+  const q = (db, sql, ...args) => db.prepare(sql).all(...args);
+  const one = (db, sql, ...args) => db.prepare(sql).get(...args);
+  const cutoffOf = (req) => {
+    const raw = Number(req.query.from ?? 0);
+    return Number.isFinite(raw) && raw > 0 ? raw : 0;
+  };
+  const projectOf = (req) => typeof req.query.project === "string" && req.query.project ? req.query.project : null;
+  const str = (req, key) => {
+    const raw = req.query[key];
+    return typeof raw === "string" && raw ? raw : null;
+  };
+  const sliceOf = (req) => {
+    const rawTo = Number(req.query.to ?? 0);
+    const gran = str(req, "gran");
+    return {
+      from: cutoffOf(req),
+      to: Number.isFinite(rawTo) && rawTo > 0 ? rawTo : Date.now() + 1,
+      project: projectOf(req),
+      model: str(req, "model"),
+      agent: str(req, "agent"),
+      // An unknown unit is ignored rather than rejected: the axis then picks for the span.
+      gran: isGranularity(gran) ? gran : null
+    };
+  };
+  app2.get("/api/status", (req, res) => {
+    const kind = kindOf(req);
+    if (!deps.hasStore(kind)) {
+      return res.json({
+        ready: false,
+        sourceDb: sourceProbe(kind),
+        sourceSchema: null,
+        sourceKind: kind,
+        unit: null,
+        tokenClasses: false,
+        sourceMaxTime: 0,
+        materializedAt: 0,
+        mode: null,
+        bucketMs: BUCKET_MS,
+        extent: { from: 0, to: Date.now() },
+        counts: { sessions: 0, turns: 0, tools: 0, parts: 0, events: 0, models: 0 }
+      });
+    }
+    const db = deps.db(kind);
+    const count = (t) => one(db, `SELECT COUNT(*) c FROM ${t}`)?.c ?? 0;
+    const extent = one(
+      db,
+      `SELECT MIN(created) AS from_ts, MAX(COALESCE(updated, created)) AS to_ts FROM sessions`
+    ) ?? { from_ts: null, to_ts: null };
+    const tokenClasses = !!one(
+      db,
+      `SELECT 1 AS hit FROM turns
+       WHERE role = 'assistant'
+         AND (output > 0 OR cache_read > 0 OR cache_write > 0 OR reasoning > 0)
+       LIMIT 1`
+    );
+    res.json({
+      ready: true,
+      sourceDb: getMeta(db, "sourceDb"),
+      sourceSchema: getMeta(db, "sourceSchema"),
+      sourceKind: getMeta(db, "sourceKind") ?? kind,
+      unit: getMeta(db, "unit") ?? "usd",
+      tokenClasses,
+      sourceMaxTime: getMetaNumber(db, "sourceMaxTime"),
+      materializedAt: getMetaNumber(db, "materializedAt"),
+      mode: getMeta(db, "mode"),
+      bucketMs: BUCKET_MS,
+      extent: { from: Number(extent.from_ts ?? 0), to: Number(extent.to_ts ?? Date.now()) },
+      counts: {
+        sessions: count("sessions"),
+        turns: count("turns"),
+        tools: count("tools"),
+        parts: count("parts"),
+        events: count("events"),
+        models: count("models")
+      }
+    });
+  });
+  app2.get("/api/sources", (_req, res) => {
+    const describe = (kind) => {
+      const available = sourceAvailable(kind);
+      const ready2 = deps.hasStore(kind);
+      const base = {
+        kind,
+        label: kind,
+        available,
+        ready: ready2,
+        path: sourceProbe(kind),
+        store: metricsDbPath(kind)
+      };
+      if (!ready2) return { ...base, unit: null, tokenClasses: null, sourceSchema: null, materializedAt: 0, counts: null };
+      const db = deps.db(kind);
+      const count = (t) => one(db, `SELECT COUNT(*) c FROM ${t}`)?.c ?? 0;
+      return {
+        ...base,
+        unit: getMeta(db, "unit") ?? "usd",
+        // Same probe as `/api/status`, answered here as well so the shell knows the
+        // store's shape before it draws: the Overview's default stack depends on it,
+        // and the source list is resolved before the first frame.
+        tokenClasses: !!one(
+          db,
+          `SELECT 1 AS hit FROM turns
+           WHERE role = 'assistant'
+             AND (output > 0 OR cache_read > 0 OR cache_write > 0 OR reasoning > 0)
+           LIMIT 1`
+        ),
+        sourceSchema: getMeta(db, "sourceSchema"),
+        materializedAt: getMetaNumber(db, "materializedAt"),
+        counts: { sessions: count("sessions"), turns: count("turns"), tools: count("tools") }
+      };
+    };
+    res.json({ default: SOURCE_KIND, sources: SOURCE_KINDS.map(describe) });
+  });
+  app2.post("/api/refresh", async (req, res) => {
+    try {
+      const full = req.body?.full === true;
+      const kind = kindOf(req);
+      const report = await deps.refresh(kind, full);
+      res.json({ ok: true, full, source: kind, report });
+    } catch (e) {
+      res.status(500).json({ ok: false, error: e.message });
+    }
+  });
+  app2.get("/api/top/session/:id/messages", (req, res) => {
+    const db = storeOf(req, res);
+    if (!db) return;
+    const id = req.params.id;
+    const session = one(
+      db,
+      `SELECT id, parent_id, project, title, agent, model, provider, created, updated,
+              t_input, t_output, t_reasoning, t_cache_read, t_cache_write, cost, turns, first_prompt
+       FROM sessions WHERE id = ?`,
+      id
+    );
+    if (!session) return res.status(404).json({ error: "unknown session" });
+    const turns = q(
+      db,
+      `SELECT id, seq, model, provider, agent, created, completed, input, output, reasoning,
+              cache_read, cache_write, cost, dur_ms, finish, tool_calls, tool_errors,
+              project, occupancy, context_window, fill, fill_after, additions, deletions, write_lines, has_error
+       FROM turns WHERE session_id = ? AND role = 'assistant'
+       ORDER BY created ASC, seq ASC`,
+      id
+    );
+    const prompts = q(
+      db,
+      `SELECT id, created, text FROM turns
+       WHERE session_id = ? AND role = 'user' AND length(trim(coalesce(text, ''))) > 0
+       ORDER BY created ASC, seq ASC`,
+      id
+    );
+    const parts = q(
+      db,
+      `SELECT turn_id, ordinal, kind, text, name, call_id, status, title, input, output,
+              exit_code, truncated, started, ended, chars
+       FROM parts WHERE session_id = ? ORDER BY turn_id, ordinal, id`,
+      id
+    );
+    const byTurn = /* @__PURE__ */ new Map();
+    for (const p of parts) {
+      const list = byTurn.get(p.turn_id) ?? [];
+      list.push({
+        kind: p.kind,
+        ordinal: Number(p.ordinal ?? 0),
+        text: p.text ?? "",
+        name: p.name ?? "",
+        callId: p.call_id ?? "",
+        status: p.status ?? "",
+        title: p.title ?? null,
+        input: p.input ?? "",
+        output: p.output ?? "",
+        exitCode: p.exit_code ?? null,
+        truncated: Number(p.truncated ?? 0) === 1,
+        started: p.started ?? null,
+        ended: p.ended ?? null,
+        chars: Number(p.chars ?? 0)
+      });
+      byTurn.set(p.turn_id, list);
+    }
+    res.json({
+      session: {
+        id: session.id,
+        parentId: session.parent_id ?? null,
+        project: session.project ?? "\u2014",
+        title: session.title ?? null,
+        agent: session.agent ?? null,
+        model: session.model ?? null,
+        provider: session.provider ?? null,
+        created: Number(session.created ?? 0),
+        updated: Number(session.updated ?? 0),
+        cost: Number(session.cost ?? 0),
+        firstPrompt: session.first_prompt ?? null
+      },
+      turns: turns.map((t) => ({
+        id: t.id,
+        model: t.model ?? "",
+        provider: t.provider ?? null,
+        agent: t.agent ?? null,
+        created: Number(t.created ?? 0),
+        completed: t.completed == null ? null : Number(t.completed),
+        tokens: {
+          input: Number(t.input ?? 0),
+          output: Number(t.output ?? 0),
+          reasoning: Number(t.reasoning ?? 0),
+          cacheRead: Number(t.cache_read ?? 0),
+          cacheWrite: Number(t.cache_write ?? 0)
+        },
+        cost: Number(t.cost ?? 0),
+        durMs: Number(t.dur_ms ?? 0),
+        finish: t.finish ?? null,
+        tools: Number(t.tool_calls ?? 0),
+        errors: Number(t.tool_errors ?? 0),
+        // Turn-level context readings: the transcript timeline plots these, and the
+        // Stats panel needs the model window the fill ratio was measured against.
+        project: t.project ?? "\u2014",
+        occupancy: Number(t.occupancy ?? 0),
+        contextWindow: Number(t.context_window ?? 0),
+        fill: Number(t.fill ?? 0),
+        fillAfter: Number(t.fill_after ?? 0),
+        additions: Number(t.additions ?? 0),
+        deletions: Number(t.deletions ?? 0),
+        writeLines: Number(t.write_lines ?? 0),
+        hasError: Number(t.has_error ?? 0) === 1,
+        parts: byTurn.get(t.id) ?? []
+      })),
+      prompts: prompts.map((p) => ({ id: p.id, created: Number(p.created ?? 0), text: p.text ?? "" }))
+    });
+  });
+  app2.get("/api/top/facets", (req, res) => {
+    const db = storeOf(req, res);
+    if (!db) return;
+    res.json(facets(db));
+  });
+  app2.get("/api/top/analytics", (req, res) => {
+    const db = storeOf(req, res);
+    if (!db) return;
+    res.json(dashboard(db, sliceOf(req)));
+  });
+  app2.get("/api/top/sessions", (req, res) => {
+    const db = storeOf(req, res);
+    if (!db) return;
+    const focus = str(req, "focus");
+    const slice = sliceOf(req);
+    if (focus) {
+      const rows = sessionContext(db, slice, focus);
+      if (!rows.length) return res.status(404).json({ error: "session not in this window" });
+      return res.json({ rows, matching: rows.length, roots: 0, next: null, totals: null });
+    }
+    const order = str(req, "order");
+    const limit = Number(req.query.limit ?? MAX_PAGE_ROOTS);
+    res.json(
+      sessionsPage(db, slice, {
+        q: str(req, "q"),
+        order: SESSION_ORDERS.includes(order ?? "") ? order : "updated",
+        dir: req.query.dir === "asc" ? "asc" : "desc",
+        limit: Number.isFinite(limit) ? limit : MAX_PAGE_ROOTS,
+        cursor: str(req, "cursor")
+      })
+    );
+  });
+  app2.get("/api/top/tool", (req, res) => {
+    const db = storeOf(req, res);
+    if (!db) return;
+    const name = str(req, "name");
+    if (!name) return res.status(400).json({ error: "name is required" });
+    const detail = toolDetail(db, sliceOf(req), name);
+    if (!detail.totals || detail.totals.calls === 0) return res.status(404).json({ error: "no calls for that tool in this window" });
+    res.json(detail);
+  });
+  app2.get("/api/top/search", (req, res) => {
+    const db = storeOf(req, res);
+    if (!db) return;
+    const raw = typeof req.query.q === "string" ? req.query.q.trim() : "";
+    if (raw.length < 2) return res.json({ query: raw, hits: [] });
+    const like = `%${raw.replace(/[\\%_]/g, (c) => `\\${c}`)}%`;
+    const rows = q(
+      db,
+      `SELECT s.id, s.title, s.project, s.updated,
+              (SELECT COUNT(*) FROM parts p WHERE p.session_id = s.id
+                 AND (p.text LIKE ? ESCAPE '\\' OR p.name LIKE ? ESCAPE '\\'
+                      OR p.title LIKE ? ESCAPE '\\' OR p.input LIKE ? ESCAPE '\\'
+                      OR p.output LIKE ? ESCAPE '\\')) hits
+       FROM sessions s
+       WHERE s.id IN (SELECT session_id FROM parts WHERE text LIKE ? ESCAPE '\\' OR name LIKE ? ESCAPE '\\'
+                        OR title LIKE ? ESCAPE '\\' OR input LIKE ? ESCAPE '\\' OR output LIKE ? ESCAPE '\\')
+       ORDER BY s.updated DESC LIMIT 40`,
+      like,
+      like,
+      like,
+      like,
+      like,
+      like,
+      like,
+      like,
+      like,
+      like
+    );
+    res.json({
+      query: raw,
+      hits: rows.map((r) => ({
+        id: r.id,
+        title: r.title ?? null,
+        project: r.project ?? "\u2014",
+        updated: Number(r.updated ?? 0),
+        hits: Number(r.hits ?? 0)
+      }))
+    });
+  });
+  return app2;
+}
+
+// src/metrics/store.ts
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, renameSync, rmSync, statSync as statSync2 } from "node:fs";
+
+// src/source.ts
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+var num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var PART_CAP = { text: 2e3, reasoning: 2e3, input: 1500, output: 3e3 };
+function bodyPart(kind, body) {
+  const trimmed = body.trim();
+  return {
+    kind,
+    text: trimmed.slice(0, kind === "reasoning" ? PART_CAP.reasoning : PART_CAP.text),
+    name: "",
+    callId: "",
+    status: "",
+    title: null,
+    input: "",
+    output: "",
+    exitCode: null,
+    truncated: trimmed.length > (kind === "reasoning" ? PART_CAP.reasoning : PART_CAP.text),
+    started: null,
+    ended: null,
+    chars: trimmed.length
+  };
+}
+function parse(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+function projectName(directory) {
+  if (!directory) return "unknown";
+  const trimmed = directory.replace(/[\\/]+$/, "");
+  if (!trimmed || trimmed === "/") return "/";
+  const parts = trimmed.split(/[\\/]/);
+  return parts[parts.length - 1] || trimmed;
+}
+function pathsOf(input, files) {
+  const out = [];
+  const push = (v) => {
+    if (typeof v === "string" && v.startsWith("/") && v.length > 1) out.push(v);
+  };
+  push(input?.path);
+  push(input?.filePath);
+  push(input?.file_path);
+  push(input?.notebookPath);
+  push(input?.notebook_path);
+  if (Array.isArray(input?.paths)) input.paths.forEach(push);
+  if (Array.isArray(files)) for (const f of files) push(typeof f === "string" ? f : f?.file ?? f?.path);
+  const cmd = input?.command;
+  if (typeof cmd === "string") {
+    for (const m of cmd.matchAll(/\/(?:home|Users|mnt|srv|opt|root|var|workspace)\/[\w.+\-@/]{2,}/g)) out.push(m[0]);
+  }
+  return out;
+}
+function fileStats(files) {
+  if (!Array.isArray(files)) return { additions: 0, deletions: 0, files: 0 };
+  let a = 0;
+  let d = 0;
+  for (const f of files) {
+    a += num2(f?.additions);
+    d += num2(f?.deletions);
+  }
+  return { additions: a, deletions: d, files: files.length };
+}
+function diffStats(patch) {
+  if (typeof patch !== "string" || !patch) return { additions: 0, deletions: 0 };
+  let additions = 0;
+  let deletions = 0;
+  let inHunk = false;
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("@@")) {
+      inHunk = true;
+      continue;
+    }
+    if (!inHunk) continue;
+    if (line.startsWith("+")) additions++;
+    else if (line.startsWith("-")) deletions++;
+  }
+  return { additions, deletions };
+}
+function contentLines(content) {
+  if (typeof content !== "string" || !content) return 0;
+  return content.split("\n").length;
+}
+function patchOf(metadata) {
+  return metadata?.filediff?.patch ?? metadata?.diff ?? null;
+}
+function touchedFile(metadata, input) {
+  const f = metadata?.filediff?.file;
+  if (typeof f === "string" && f) return f;
+  const g = input?.filePath ?? input?.file_path ?? input?.path;
+  return typeof g === "string" && g ? g : null;
+}
+function hashSig(name, input) {
+  const raw = JSON.stringify(input ?? {});
+  let h = 2166136261;
+  const key = name + "|" + raw.slice(0, 400);
+  for (let i = 0; i < key.length; i++) {
+    h ^= key.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `${name}:${(h >>> 0).toString(36)}`;
+}
+var SESSION_ID_RE = /ses_[A-Za-z0-9]{4,}/;
+var SourceReader = class {
+  kind = "opencode";
+  unit = "usd";
+  path;
+  db;
+  schema;
+  constructor(dbPath) {
+    this.path = dbPath;
+    this.db = new DatabaseSync2(dbPath, { readOnly: true });
+    const hasV2 = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_v2'").get();
+    const rows = hasV2 ? this.db.prepare("SELECT COUNT(*) AS c FROM session_v2").get().c : 0;
+    this.schema = rows > 0 ? "v2" : "v1";
+  }
+  close() {
+    this.db.close();
+  }
+  /**
+   * Watermark: the newest source timestamp, covering both message writes and
+   * session-row updates. Only when *both* are below it is the metrics db fresh —
+   * otherwise a session whose row was touched without a new message would be
+   * re-materialized on every tick, forever.
+   */
+  maxMessageTime() {
+    const msgTable = this.schema === "v2" ? "session_message" : "message";
+    const msgCol = this.schema === "v2" ? "time_updated" : "time_created";
+    const msgMax = this.db.prepare(`SELECT MAX(${msgCol}) AS m FROM ${msgTable}`).get()?.m ?? 0;
+    let sessMax = 0;
+    try {
+      sessMax = this.db.prepare("SELECT MAX(time_updated) AS m FROM session_v2").get()?.m ?? 0;
+    } catch {
+    }
+    return Math.max(msgMax, sessMax);
+  }
+  /**
+   * Sessions touched after `since` (message writes + session row updates).
+   * Used to re-materialize only what changed instead of reparsing 500 MB.
+   */
+  changedSessions(since) {
+    const out = /* @__PURE__ */ new Set();
+    if (since <= 0) return out;
+    const msgTable = this.schema === "v2" ? "session_message" : "message";
+    const msgCol = this.schema === "v2" ? "time_updated" : "time_created";
+    for (const r of this.db.prepare(`SELECT DISTINCT session_id FROM ${msgTable} WHERE ${msgCol} > ?`).all(since)) {
+      if (r.session_id) out.add(String(r.session_id));
+    }
+    const sessTable = this.schema === "v2" ? "session_v2" : "session";
+    try {
+      for (const r of this.db.prepare(`SELECT id FROM ${sessTable} WHERE time_updated > ?`).all(since)) {
+        if (r.id) out.add(String(r.id));
+      }
+    } catch {
+    }
+    return out;
+  }
+  sessions() {
+    const table = this.schema === "v2" ? "session_v2" : "session";
+    const rows = this.db.prepare(
+      `SELECT s.id, s.parent_id, s.project_id, s.title, s.directory, s.agent, s.model,
+                s.time_created, s.time_updated, s.cost,
+                p.name AS project_name, p.worktree AS project_worktree
+         FROM ${table} s LEFT JOIN project p ON p.id = s.project_id`
+    ).all();
+    const agg = /* @__PURE__ */ new Map();
+    if (this.schema === "v2") {
+      for (const r of this.db.prepare(
+        `SELECT id AS sid, tokens_input AS i, tokens_output AS o, tokens_reasoning AS r,
+                  tokens_cache_read AS cr, tokens_cache_write AS cw,
+                  summary_additions AS a, summary_deletions AS d
+           FROM session_v2`
+      ).all()) {
+        agg.set(r.sid, { input: num2(r.i), output: num2(r.o), reasoning: num2(r.r), cr: num2(r.cr), cw: num2(r.cw), a: num2(r.a), d: num2(r.d) });
+      }
+    }
+    return rows.map((r) => {
+      const model = this.schema === "v2" ? parse(r.model) : null;
+      const a = agg.get(r.id);
+      const directory = r.directory ?? r.project_worktree ?? "/";
+      return {
+        id: r.id,
+        parentId: r.parent_id ?? null,
+        project: r.project_name?.trim() || projectName(directory),
+        directory,
+        title: r.title ?? null,
+        agent: r.agent ?? null,
+        provider: model?.providerID ?? null,
+        model: model?.id ?? (typeof r.model === "string" ? r.model : null),
+        variant: model?.variant ?? null,
+        created: num2(r.time_created),
+        updated: num2(r.time_updated),
+        cost: num2(r.cost),
+        tInput: a?.input ?? 0,
+        tOutput: a?.output ?? 0,
+        tReasoning: a?.reasoning ?? 0,
+        tCacheRead: a?.cr ?? 0,
+        tCacheWrite: a?.cw ?? 0,
+        additions: a?.a ?? 0,
+        deletions: a?.d ?? 0,
+        files: 0
+      };
+    });
+  }
+  turns(sessionIds) {
+    return this.schema === "v2" ? this.turnsV2(sessionIds) : this.turnsV1(sessionIds);
+  }
+  /**
+   * Files touched per session, recovered from v1 `part` patch records.
+   * The v2 message stream has no patch parts, but the legacy table is still
+   * populated for sessions that started life on v1 — worth reading because it is
+   * the only diff signal for ~46 sessions.
+   */
+  patchFileCounts(sessionIds) {
+    const out = /* @__PURE__ */ new Map();
+    const has = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='part'").get();
+    if (!has) return out;
+    let rows = [];
+    try {
+      const where = sessionIds ? `WHERE session_id IN (${[...sessionIds].map(() => "?").join(",")}) AND ` : "WHERE ";
+      const args = sessionIds ? [...sessionIds] : [];
+      rows = this.db.prepare(`${where}data LIKE '%"patch"%'`).all(...args);
+    } catch {
+      return out;
+    }
+    for (const row of rows) {
+      const d = parse(row.data);
+      if (!d || d.type !== "patch") continue;
+      const files = Array.isArray(d.files) ? d.files.map((f) => String(f)) : [];
+      if (!files.length) continue;
+      const cur = out.get(row.session_id) ?? { files: 0, paths: [] };
+      for (const f of files) if (!cur.paths.includes(f)) cur.paths.push(f);
+      cur.files = cur.paths.length;
+      out.set(row.session_id, cur);
+    }
+    return out;
+  }
+  turnsV2(sessionIds) {
+    const where = sessionIds ? `WHERE session_id IN (${[...sessionIds].map(() => "?").join(",")})` : "";
+    const args = sessionIds ? [...sessionIds] : [];
+    const rows = this.db.prepare(`SELECT id, session_id, seq, type, time_created, time_updated, data FROM session_message ${where} ORDER BY time_created ASC, seq ASC`).all(...args);
+    const out = [];
+    for (const row of rows) {
+      const d = parse(row.data);
+      if (!d) continue;
+      const type = row.type;
+      if (type === "compaction" || type === "idle" || type === "model-switched" || type === "agent-switched") continue;
+      const isUser = type === "user";
+      const content = Array.isArray(d.content) ? d.content : [];
+      const tools = [];
+      const parts = [];
+      let text = "";
+      let additions = 0;
+      let deletions = 0;
+      let files = 0;
+      let writeLines = 0;
+      for (const item of content) {
+        if (item?.type === "text") {
+          const body = item.text ?? "";
+          text += body;
+          if (!isUser && body.trim()) parts.push(bodyPart("text", body));
+          continue;
+        }
+        if (item?.type === "reasoning") {
+          const body = item.text ?? "";
+          if (!isUser && body.trim()) parts.push(bodyPart("reasoning", body));
+          continue;
+        }
+        if (item?.type === "tool") {
+          const st = item.state ?? {};
+          const name = item.name ?? "unknown";
+          const legacy = fileStats(st.metadata?.files);
+          const diff = diffStats(patchOf(st.metadata));
+          const touched = touchedFile(st.metadata, st.input);
+          const toolAdd = Math.max(diff.additions, legacy.additions);
+          const toolDel = Math.max(diff.deletions, legacy.deletions);
+          const toolFiles = Math.max(legacy.files, touched ? 1 : 0);
+          const toolWrite = name === "write" ? contentLines(st.input?.content) : 0;
+          additions += toolAdd;
+          deletions += toolDel;
+          files += toolFiles;
+          writeLines += toolWrite;
+          const outputText = st.error?.message ?? st.metadata?.output ?? st.output ?? (st.content ?? []).map((c) => c?.text ?? "").join("\n");
+          const started = item.time?.created ?? st.time?.start ?? st.time?.created ?? null;
+          const ended = item.time?.completed ?? st.time?.end ?? st.time?.completed ?? null;
+          const inputPreview = st.input ? JSON.stringify(st.input).slice(0, 400) : null;
+          tools.push({
+            turnId: row.id,
+            sessionId: row.session_id,
+            callId: item.id ?? "",
+            name,
+            status: st.status ?? "pending",
+            started,
+            ended,
+            title: st.title ?? null,
+            outputChars: typeof outputText === "string" ? outputText.length : 0,
+            additions: toolAdd,
+            deletions: toolDel,
+            files: toolFiles,
+            writeLines: toolWrite,
+            error: st.status === "error" ? st.error?.message ?? "tool error" : null,
+            sig: hashSig(name, st.input),
+            inputPreview,
+            paths: pathsOf(st.input, st.metadata?.files),
+            targetSession: inputPreview ? SESSION_ID_RE.exec(inputPreview)?.[0] ?? null : null
+          });
+          if (!isUser) {
+            parts.push({
+              kind: "tool",
+              text: "",
+              name,
+              callId: item.id ?? "",
+              status: st.status ?? "pending",
+              title: st.title ?? null,
+              input: (st.input ? JSON.stringify(st.input) : "").slice(0, PART_CAP.input),
+              output: (typeof outputText === "string" ? outputText : "").slice(0, PART_CAP.output),
+              exitCode: st.metadata?.exit ?? st.metadata?.exitCode ?? null,
+              truncated: st.metadata?.truncated ?? false,
+              started,
+              ended,
+              chars: typeof outputText === "string" ? outputText.length : 0
+            });
+          }
+        }
+      }
+      const tk = d.tokens ?? {};
+      const created = d.time?.created ?? row.time_created;
+      const completed = d.time?.completed ?? d.time?.streamed ?? (type === "assistant" ? null : created);
+      if (isUser) {
+        out.push({
+          id: row.id,
+          sessionId: row.session_id,
+          seq: num2(row.seq),
+          created,
+          completed,
+          role: "user",
+          provider: null,
+          model: d.model?.id ?? null,
+          variant: null,
+          agent: d.agent ?? null,
+          input: 0,
+          output: 0,
+          reasoning: 0,
+          cacheRead: 0,
+          cacheWrite: 0,
+          cost: 0,
+          finish: null,
+          text: d.text ?? text,
+          tools: [],
+          parts: [],
+          prompt: (d.text ?? text).slice(0, 400)
+        });
+        continue;
+      }
+      if (type !== "assistant") continue;
+      out.push({
+        id: row.id,
+        sessionId: row.session_id,
+        seq: num2(row.seq),
+        created,
+        completed,
+        role: "assistant",
+        provider: d.model?.providerID ?? null,
+        model: d.model?.id ?? null,
+        variant: d.model?.variant ?? null,
+        agent: d.agent ?? null,
+        input: num2(tk.input),
+        output: num2(tk.output),
+        reasoning: num2(tk.reasoning),
+        cacheRead: num2(tk.cache?.read),
+        cacheWrite: num2(tk.cache?.write),
+        cost: num2(d.cost),
+        finish: d.finish ?? d.rawFinish ?? null,
+        text,
+        tools,
+        parts,
+        prompt: null,
+        _add: additions,
+        _del: deletions,
+        _files: files,
+        _write: writeLines
+      });
+    }
+    return out;
+  }
+  turnsV1(sessionIds) {
+    const where = sessionIds ? `WHERE m.session_id IN (${[...sessionIds].map(() => "?").join(",")})` : "";
+    const args = sessionIds ? [...sessionIds] : [];
+    const msgs = this.db.prepare(`SELECT m.id, m.session_id, m.data, m.time_created FROM message m ${where} ORDER BY m.time_created ASC`).all(...args);
+    const partsByMsg = /* @__PURE__ */ new Map();
+    if (msgs.length) {
+      const ids = msgs.map((m) => m.id);
+      const ph = ids.map(() => "?").join(",");
+      for (const p of this.db.prepare(`SELECT message_id, data FROM part WHERE message_id IN (${ph}) ORDER BY rowid ASC`).all(...ids)) {
+        const d = parse(p.data);
+        if (!d) continue;
+        if (!partsByMsg.has(p.message_id)) partsByMsg.set(p.message_id, []);
+        partsByMsg.get(p.message_id).push(d);
+      }
+    }
+    const out = [];
+    for (const row of msgs) {
+      const d = parse(row.data);
+      if (!d) continue;
+      const rawParts = partsByMsg.get(row.id) ?? [];
+      const role = d.role ?? "assistant";
+      const isAssistant = role === "assistant";
+      const tools = [];
+      const parts = [];
+      let text = "";
+      let files = 0;
+      let writeLines = 0;
+      for (const p of rawParts) {
+        if (p.type === "text") {
+          const body = p.text ?? "";
+          text += body;
+          if (isAssistant && body.trim()) parts.push(bodyPart("text", body));
+          continue;
+        }
+        if (p.type === "reasoning") {
+          const body = p.text ?? "";
+          if (isAssistant && body.trim()) parts.push(bodyPart("reasoning", body));
+          continue;
+        }
+        if (p.type === "tool") {
+          const st = p.state ?? {};
+          const name = p.tool ?? "unknown";
+          const diff = diffStats(patchOf(st.metadata));
+          const touched = touchedFile(st.metadata, st.input);
+          const started = st.time?.start ?? p.time?.start ?? null;
+          const ended = st.time?.end ?? p.time?.end ?? null;
+          const inputPreview = st.input ? JSON.stringify(st.input).slice(0, 400) : null;
+          const toolFiles = Math.max(Array.isArray(p.files) ? p.files.length : 0, touched ? 1 : 0);
+          const toolWrite = name === "write" ? contentLines(st.input?.content) : 0;
+          files += toolFiles;
+          writeLines += toolWrite;
+          tools.push({
+            turnId: row.id,
+            sessionId: row.session_id,
+            callId: p.callID ?? "",
+            name,
+            status: st.status ?? "pending",
+            started,
+            ended,
+            title: st.title ?? null,
+            outputChars: (st.output ?? "").length,
+            additions: diff.additions,
+            deletions: diff.deletions,
+            files: toolFiles,
+            writeLines: toolWrite,
+            error: st.status === "error" ? st.error ?? st.output ?? "tool error" : null,
+            sig: hashSig(name, st.input),
+            inputPreview,
+            paths: pathsOf(st.input, p.files),
+            targetSession: inputPreview ? SESSION_ID_RE.exec(inputPreview)?.[0] ?? null : null
+          });
+          if (isAssistant) {
+            const outText = typeof st.output === "string" ? st.output : "";
+            parts.push({
+              kind: "tool",
+              text: "",
+              name,
+              callId: p.callID ?? "",
+              status: st.status ?? "pending",
+              title: st.title ?? null,
+              input: (st.input ? JSON.stringify(st.input) : "").slice(0, PART_CAP.input),
+              output: outText.slice(0, PART_CAP.output),
+              exitCode: st.metadata?.exit ?? st.metadata?.exitCode ?? null,
+              truncated: st.metadata?.truncated ?? false,
+              started,
+              ended,
+              chars: outText.length
+            });
+          }
+        }
+      }
+      const tk = d.tokens ?? {};
+      out.push({
+        id: row.id,
+        sessionId: row.session_id,
+        seq: out.length,
+        created: d.time?.created ?? row.time_created,
+        completed: d.time?.completed ?? null,
+        role: role === "user" ? "user" : role === "assistant" ? "assistant" : "other",
+        provider: d.providerID ?? null,
+        model: d.modelID ?? d.model ?? null,
+        variant: null,
+        agent: d.agent ?? null,
+        input: tk.input ?? d.usage?.input_tokens ?? 0,
+        output: tk.output ?? d.usage?.output_tokens ?? 0,
+        reasoning: tk.reasoning ?? 0,
+        cacheRead: tk.cache?.read ?? d.usage?.cache_read_input_tokens ?? 0,
+        cacheWrite: tk.cache?.write ?? d.usage?.cache_write_input_tokens ?? 0,
+        cost: num2(d.cost),
+        finish: d.finish ?? d.stop_reason ?? null,
+        text,
+        tools,
+        parts: isAssistant ? parts : [],
+        prompt: role === "user" ? text.slice(0, 400) : null,
+        _add: tools.reduce((a, t) => a + t.additions, 0),
+        _del: tools.reduce((a, t) => a + t.deletions, 0),
+        _files: files,
+        _write: writeLines
+      });
+    }
+    return out;
+  }
+  events(sessionIds) {
+    const out = [];
+    if (this.schema === "v2") {
+      const where = sessionIds ? `WHERE session_id IN (${[...sessionIds].map(() => "?").join(",")}) AND` : "WHERE";
+      const args = sessionIds ? [...sessionIds] : [];
+      const rows = this.db.prepare(
+        `SELECT id, session_id, seq, type, time_created, data FROM session_message
+           ${where} type IN ('compaction','idle','model-switched','agent-switched') ORDER BY time_created ASC`
+      ).all(...args);
+      for (const r of rows) {
+        const d = parse(r.data) ?? {};
+        const type = r.type === "compaction" ? "compaction" : r.type === "idle" ? d.outcome === "failed" ? "error" : "idle" : "switch";
+        out.push({
+          sessionId: r.session_id,
+          turnId: null,
+          type,
+          at: d.time?.created ?? r.time_created,
+          reason: d.reason ?? d.outcome ?? d.error?.type ?? null,
+          detail: r.type === "compaction" ? (d.summary ?? "").slice(0, 600) : d.error?.message ?? d.outcome ?? null,
+          tokensBefore: num2(d.tokens?.input) || num2(d.tokens?.cache?.read) || null,
+          model: d.model?.id ?? null
+        });
+      }
+    } else {
+      const rows = this.db.prepare(`SELECT session_id, message_id, data FROM part WHERE data LIKE '%"compaction"%' LIMIT 20000`).all();
+      for (const r of rows) {
+        const d = parse(r.data);
+        if (d?.type !== "compaction") continue;
+        if (sessionIds && !sessionIds.has(r.session_id)) continue;
+        out.push({ sessionId: r.session_id, turnId: r.message_id, type: "compaction", at: d.time?.created ?? 0, reason: d.reason ?? null, detail: (d.text ?? "").slice(0, 600) });
+      }
+    }
+    return out;
+  }
+};
+
+// src/source-qoder.ts
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync } from "node:fs";
+import path2 from "node:path";
+var QODER_MODEL_WINDOW = {
+  qfmodel: 18e4,
+  dfmodel: 1e6
+};
+var QODER_DEFAULT_WINDOW = 2e5;
+var COMPACTION_DROP_TOKENS = 5e4;
+var INTERNAL_PATH = /(^|\/)\.(qoder|opencode|osm)\//;
+var NOT_A_MODEL = /* @__PURE__ */ new Set(["", "<synthetic>", "unknown"]);
+var QODER_MODELS = {
+  qfmodel: "Qwen3.8-Flash",
+  dfmodel: "DeepSeek-Flash"
+};
+function modelWindow(model) {
+  if (!model) return QODER_DEFAULT_WINDOW;
+  const alias = QODER_MODEL_WINDOW[model] !== void 0 ? model : Object.keys(QODER_MODELS).find((a) => QODER_MODELS[a] === model);
+  return QODER_MODEL_WINDOW[alias ?? model] ?? QODER_DEFAULT_WINDOW;
+}
+var num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+function ms(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const t = Date.parse(value);
+    return Number.isFinite(t) ? t : 0;
+  }
+  return 0;
+}
+var micro = (credits) => Math.round(credits * 1e6);
+function lineCount(body) {
+  if (typeof body !== "string" || !body) return 0;
+  return body.split("\n").length;
+}
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => typeof c === "string" ? c : c?.type === "text" ? String(c.text ?? "") : "").join("\n");
+  }
+  return "";
+}
+function toolTitle(name, input) {
+  if (!input || typeof input !== "object") return null;
+  const raw = input.description ?? input.file_path ?? input.path ?? input.toolName ?? (typeof input.command === "string" ? input.command.split("\n")[0] : null) ?? (typeof input.query === "string" ? input.query : null) ?? (typeof input.subject === "string" ? input.subject : null);
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  return raw.trim().slice(0, 160);
+}
+var QoderSource = class {
+  kind = "qoder";
+  unit = "credit";
+  schema = "qoder-jsonl";
+  path;
+  cache = /* @__PURE__ */ new Map();
+  evidence = /* @__PURE__ */ new Map();
+  logDirs = null;
+  constructor(root = QODER_PROJECTS) {
+    this.path = root;
+  }
+  close() {
+    this.cache.clear();
+    this.evidence.clear();
+  }
+  /**
+   * Session id → its transcript files.
+   *
+   * A session owns `<root>/<encoded-cwd>/<sessionId>.jsonl` and, when it spawned
+   * subagents, `<root>/<encoded-cwd>/<sessionId>/subagents/agent-*.jsonl`. Those
+   * subagent rows carry the parent id in `sessionId` and bill to it, so they are
+   * merged into the parent session rather than counted as sessions of their own.
+   * In the corpus at hand that is 8 extra files, 131 turns and 8.7 credits — 1.3%
+   * of the total, which silently missing would understate every session that
+   * ever delegated work.
+   */
+  index() {
+    const out = /* @__PURE__ */ new Map();
+    if (!existsSync2(this.path)) return out;
+    const add = (id, file) => {
+      const list = out.get(id);
+      if (list) list.push(file);
+      else out.set(id, [file]);
+    };
+    for (const dir of readdirSync(this.path, { withFileTypes: true })) {
+      if (!dir.isDirectory()) continue;
+      const abs = path2.join(this.path, dir.name);
+      for (const entry of readdirSync(abs, { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          add(entry.name.slice(0, -".jsonl".length), path2.join(abs, entry.name));
+          continue;
+        }
+        if (!entry.isDirectory()) continue;
+        const subs = path2.join(abs, entry.name, "subagents");
+        if (!existsSync2(subs)) continue;
+        for (const sub of readdirSync(subs)) if (sub.endsWith(".jsonl")) add(entry.name, path2.join(subs, sub));
+      }
+    }
+    return out;
+  }
+  stamp(file) {
+    try {
+      const st = statSync(file);
+      return { mtime: st.mtimeMs, size: st.size };
+    } catch {
+      return null;
+    }
+  }
+  maxMessageTime() {
+    let max = 0;
+    for (const files of this.index().values())
+      for (const f of files) max = Math.max(max, this.stamp(f)?.mtime ?? 0);
+    return max;
+  }
+  changedSessions(since) {
+    const out = /* @__PURE__ */ new Set();
+    if (since <= 0) return out;
+    for (const [id, files] of this.index()) {
+      for (const f of files) {
+        const st = this.stamp(f);
+        if (st && st.mtime > since) {
+          out.add(id);
+          break;
+        }
+      }
+    }
+    return out;
+  }
+  all(sessionIds) {
+    const out = [];
+    for (const [id, files] of this.index()) {
+      if (sessionIds && !sessionIds.has(id)) continue;
+      const p = this.load(id, files);
+      if (p) out.push(p);
+    }
+    return out;
+  }
+  sessions() {
+    return this.all().map((p) => this.sessionOf(p));
+  }
+  turns(sessionIds) {
+    return this.all(sessionIds).flatMap((p) => p.turns);
+  }
+  events(sessionIds) {
+    return this.all(sessionIds).flatMap((p) => p.compactions);
+  }
+  /** Files touched by edit/write calls; `build` uses these to infer the project lane. */
+  patchFileCounts(sessionIds) {
+    const out = /* @__PURE__ */ new Map();
+    for (const p of this.all(sessionIds)) {
+      if (p.paths.length) out.set(p.id, { files: p.paths.length, paths: p.paths });
+    }
+    return out;
+  }
+  sessionOf(p) {
+    const model = this.displayModel(p.id, p.models);
+    return {
+      id: p.id,
+      parentId: null,
+      project: projectName(p.directory),
+      directory: p.directory,
+      title: p.title,
+      agent: null,
+      provider: "qoder",
+      model,
+      variant: null,
+      created: p.created,
+      updated: p.updated,
+      cost: p.credits,
+      tInput: p.tInput,
+      tOutput: 0,
+      tReasoning: 0,
+      tCacheRead: 0,
+      tCacheWrite: 0,
+      additions: p.additions,
+      deletions: p.deletions,
+      files: p.files,
+      creditsMicro: p.creditsMicro
+    };
+  }
+  /**
+   * Session-level model naming. The alias and the shipped name never appear in the
+   * same telemetry event, so this is inference:
+   *   - one alias + one real name → the real name;
+   *   - one alias + no evidence → the global map;
+   *   - several aliases (a mixed session) → all aliases, never a guess.
+   */
+  displayModel(id, models) {
+    const aliases = [...new Set(models.filter((m) => !!m && !NOT_A_MODEL.has(m)))];
+    if (aliases.length === 0) return "unknown";
+    if (aliases.length > 1) return aliases.sort().join(" + ");
+    const alias = aliases[0];
+    const real = this.realModels(id);
+    if (real.size === 1) return [...real][0];
+    if (real.size === 0 && QODER_MODELS[alias]) return QODER_MODELS[alias];
+    return alias;
+  }
+  /** Shipped names reported by hooks for this session (`hook_input.model`). */
+  realModels(sessionId) {
+    const hit = this.evidence.get(sessionId);
+    if (hit) return hit;
+    const out = /* @__PURE__ */ new Set();
+    for (const enc of this.telemetryDirs()) {
+      const dir = path2.join(QODER_LOGS, enc, sessionId, "segments");
+      if (!existsSync2(dir)) continue;
+      for (const f of readdirSync(dir)) {
+        if (!f.endsWith(".jsonl")) continue;
+        let body = "";
+        try {
+          body = readFileSync(path2.join(dir, f), "utf8");
+        } catch {
+          continue;
+        }
+        for (const line of body.split("\n")) {
+          if (!line.includes("hook_input")) continue;
+          try {
+            const e = JSON.parse(line);
+            const name = e?.data?.hook_input?.model;
+            if (typeof name === "string" && name && name !== "unknown") out.add(name);
+          } catch {
+          }
+        }
+      }
+    }
+    this.evidence.set(sessionId, out);
+    return out;
+  }
+  telemetryDirs() {
+    if (this.logDirs) return this.logDirs;
+    this.logDirs = existsSync2(QODER_LOGS) ? readdirSync(QODER_LOGS, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+    return this.logDirs;
+  }
+  /** Parse every file of a session and merge them; cached by the files' stamps. */
+  load(id, files) {
+    const stamped = files.map((f) => ({ f, st: this.stamp(f) })).filter((x) => !!x.st).sort((a, b) => a.f.localeCompare(b.f));
+    if (!stamped.length) return null;
+    const sig = stamped.map((x) => `${x.f}:${x.st.mtime}:${x.st.size}`).join("|");
+    const hit = this.cache.get(id);
+    if (hit && hit.sig === sig) return hit.parsed;
+    const parts = [];
+    for (const { f, st } of stamped) {
+      let body = "";
+      try {
+        body = readFileSync(f, "utf8");
+      } catch {
+        continue;
+      }
+      parts.push(this.parse(id, f, st.mtime, body));
+    }
+    if (!parts.length) return null;
+    const parsed = parts.length === 1 ? parts[0] : this.merge(id, parts);
+    const name = this.displayModel(id, parsed.models);
+    if (name !== "unknown" && !name.includes(" + ")) {
+      for (const t of parsed.turns) if (t.role === "assistant" && t.model) t.model = name;
+    }
+    if (this.cache.size > 64) this.cache.clear();
+    this.cache.set(id, { sig, parsed });
+    return parsed;
+  }
+  /** A parent transcript plus its subagent transcripts, as one session. */
+  merge(id, parts) {
+    const seen = /* @__PURE__ */ new Set();
+    const turns = parts.flatMap((p) => p.turns).sort((a, b) => a.created - b.created).filter((t) => seen.has(t.id) ? false : (seen.add(t.id), true)).map((t, i) => ({ ...t, seq: i }));
+    const paths = new Set(parts.flatMap((p) => p.paths));
+    const sum = (pick) => parts.reduce((a, p) => a + pick(p), 0);
+    const created = parts.map((p) => p.created).filter((t) => t > 0);
+    return {
+      id,
+      file: parts[0].file,
+      mtime: Math.max(...parts.map((p) => p.mtime)),
+      directory: parts.find((p) => p.directory !== "/")?.directory ?? "/",
+      title: parts.find((p) => p.title)?.title ?? null,
+      created: created.length ? Math.min(...created) : 0,
+      updated: Math.max(...parts.map((p) => p.updated)),
+      turns,
+      compactions: parts.flatMap((p) => p.compactions).sort((a, b) => a.at - b.at),
+      paths: [...paths],
+      models: parts.flatMap((p) => p.models),
+      credits: sum((p) => p.credits),
+      creditsMicro: sum((p) => p.creditsMicro),
+      tInput: sum((p) => p.tInput),
+      additions: sum((p) => p.additions),
+      deletions: sum((p) => p.deletions),
+      files: sum((p) => p.files)
+    };
+  }
+  parse(id, file, mtime, body) {
+    const order = [];
+    const byId = /* @__PURE__ */ new Map();
+    const prompts = [];
+    const results = /* @__PURE__ */ new Map();
+    const paths = /* @__PURE__ */ new Set();
+    let title = null;
+    let lastPrompt = null;
+    let directory = "";
+    let explicit = 0;
+    let created = 0;
+    let updated = 0;
+    const touch = (ts) => {
+      if (!ts) return;
+      if (!created || ts < created) created = ts;
+      if (ts > updated) updated = ts;
+    };
+    for (const line of body.split("\n")) {
+      if (!line.trim()) continue;
+      let e;
+      try {
+        e = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const type = e?.type;
+      if (typeof e?.cwd === "string" && e.cwd) directory = e.cwd;
+      touch(ms(e?.timestamp));
+      if (type === "assistant") {
+        const m = e.message ?? {};
+        const mid = typeof m.id === "string" && m.id ? m.id : e.uuid;
+        if (!mid) continue;
+        let entry = byId.get(mid);
+        if (!entry) {
+          entry = {
+            id: mid,
+            ts: ms(e.timestamp),
+            model: m.model ?? null,
+            stop: m.stop_reason ?? null,
+            window: explicit,
+            blocks: [],
+            usage: null
+          };
+          byId.set(mid, entry);
+          order.push(entry);
+        }
+        if (m.stop_reason) entry.stop = m.stop_reason;
+        if (m.model) entry.model = m.model;
+        if (Array.isArray(m.content)) {
+          for (const b of m.content) if (b && typeof b === "object" && b.type) entry.blocks.push(b);
+        }
+        if (m.usage && typeof m.usage === "object") {
+          entry.usage = {
+            credits: num3(m.usage.credits),
+            original: num3(m.usage.original_credits ?? m.usage.credits),
+            ratio: typeof m.usage.context_usage_ratio === "number" ? m.usage.context_usage_ratio : null,
+            request: typeof m.usage.request_id === "string" ? m.usage.request_id : null
+          };
+        }
+        continue;
+      }
+      if (type === "user") {
+        const m = e.message ?? {};
+        const content = m.content;
+        const ts = ms(e.timestamp);
+        if (typeof content === "string") {
+          if (content.trim()) prompts.push({ id: String(e.uuid ?? `u${prompts.length}`), ts, text: content });
+          continue;
+        }
+        if (!Array.isArray(content)) continue;
+        let text = "";
+        for (const b of content) {
+          if (!b || typeof b !== "object") continue;
+          if (b.type === "text" && typeof b.text === "string") text += b.text;
+          if (b.type === "tool_result" && typeof b.tool_use_id === "string") {
+            results.set(b.tool_use_id, {
+              text: resultText(b.content),
+              error: b.is_error === true,
+              ts
+            });
+          }
+        }
+        if (text.trim()) prompts.push({ id: String(e.uuid ?? `u${prompts.length}`), ts, text });
+        continue;
+      }
+      if (type === "runtime-config") {
+        explicit = typeof e.contextWindow === "number" && e.contextWindow > 0 ? e.contextWindow : 0;
+        continue;
+      }
+      if (type === "ai-title" && typeof e.aiTitle === "string") {
+        title = e.aiTitle;
+        continue;
+      }
+      if (type === "workspace-directories" && Array.isArray(e.directories) && e.directories[0]) {
+        directory = String(e.directories[0]);
+        continue;
+      }
+      if (type === "last-prompt" && typeof e.lastPrompt === "string") lastPrompt = e.lastPrompt;
+    }
+    const items = [];
+    const models = [];
+    let credits = 0;
+    let tInput = 0;
+    let additions = 0;
+    let deletions = 0;
+    let files = 0;
+    const ratios = [];
+    for (const entry of order) {
+      const usage = entry.usage;
+      const ratio = usage?.ratio ?? null;
+      const contextWindow = entry.window || modelWindow(entry.model);
+      const input = ratio == null ? 0 : Math.round(ratio * contextWindow);
+      const toolCalls = [];
+      const parts = [];
+      const seenCalls = /* @__PURE__ */ new Set();
+      let text = "";
+      let add = 0;
+      let del = 0;
+      let fileCount = 0;
+      let writeLines = 0;
+      for (const b of entry.blocks) {
+        if (b.type === "text") {
+          const value = String(b.text ?? "");
+          text += value;
+          if (value.trim()) parts.push(bodyPart("text", value));
+          continue;
+        }
+        if (b.type === "thinking") {
+          const value = String(b.thinking ?? b.text ?? "");
+          if (value.trim()) parts.push(bodyPart("reasoning", value));
+          continue;
+        }
+        if (b.type !== "tool_use") continue;
+        const callId = String(b.id ?? `${entry.id}:${toolCalls.length}`);
+        if (seenCalls.has(callId)) continue;
+        seenCalls.add(callId);
+        const name = String(b.name ?? "unknown");
+        const inputJson = b.input ?? {};
+        const result = results.get(callId);
+        const status = result ? result.error ? "error" : "completed" : "pending";
+        const filePath = typeof inputJson?.file_path === "string" ? inputJson.file_path : null;
+        const touched = pathsOf(inputJson, null);
+        for (const p of touched) if (!INTERNAL_PATH.test(p)) paths.add(p);
+        const toolAdd = name === "Edit" ? lineCount(inputJson?.new_string) : 0;
+        const toolDel = name === "Edit" ? lineCount(inputJson?.old_string) : 0;
+        const write = name === "Write" ? lineCount(inputJson?.content) : 0;
+        add += toolAdd;
+        del += toolDel;
+        writeLines += write;
+        if (filePath) fileCount += 1;
+        toolCalls.push({
+          turnId: entry.id,
+          sessionId: id,
+          callId,
+          name,
+          status,
+          started: entry.ts,
+          ended: result?.ts ?? null,
+          title: toolTitle(name, inputJson),
+          outputChars: result?.text.length ?? 0,
+          additions: toolAdd,
+          deletions: toolDel,
+          files: filePath ? 1 : 0,
+          writeLines: write,
+          error: result?.error ? result.text.slice(0, 500) || "tool error" : null,
+          sig: hashSig(name, inputJson),
+          inputPreview: inputJson ? JSON.stringify(inputJson).slice(0, 400) : null,
+          targetSession: null,
+          paths: touched.filter((p) => !INTERNAL_PATH.test(p))
+        });
+        parts.push({
+          kind: "tool",
+          text: "",
+          name,
+          callId,
+          status,
+          title: toolTitle(name, inputJson),
+          input: (inputJson ? JSON.stringify(inputJson) : "").slice(0, PART_CAP.input),
+          output: (result?.text ?? "").slice(0, PART_CAP.output),
+          exitCode: null,
+          truncated: (result?.text.length ?? 0) > PART_CAP.output,
+          started: entry.ts,
+          ended: result?.ts ?? null,
+          chars: result?.text.length ?? 0
+        });
+      }
+      const turnCredits = usage?.credits ?? 0;
+      const synthetic = entry.model === "<synthetic>";
+      const turn = {
+        id: entry.id,
+        sessionId: id,
+        seq: 0,
+        created: entry.ts,
+        completed: entry.ts,
+        role: synthetic ? "system" : "assistant",
+        provider: "qoder",
+        model: entry.model && !NOT_A_MODEL.has(entry.model) ? entry.model : null,
+        variant: null,
+        agent: null,
+        input,
+        output: 0,
+        reasoning: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: turnCredits,
+        finish: entry.stop,
+        text,
+        tools: toolCalls,
+        parts,
+        prompt: null,
+        creditsMicro: micro(turnCredits),
+        contextWindow,
+        _add: add,
+        _del: del,
+        _files: fileCount,
+        _write: writeLines
+      };
+      items.push({ ts: entry.ts, turn });
+      if (entry.model) models.push(entry.model);
+      credits += turnCredits;
+      tInput += input;
+      additions += add;
+      deletions += del;
+      files += fileCount;
+      if (ratio != null) ratios.push({ ts: entry.ts, tokens: input });
+    }
+    for (const p of prompts) {
+      if (!p.ts) continue;
+      items.push({
+        ts: p.ts,
+        turn: {
+          id: p.id,
+          sessionId: id,
+          seq: 0,
+          created: p.ts,
+          completed: p.ts,
+          role: "user",
+          provider: null,
+          model: null,
+          variant: null,
+          agent: null,
+          input: 0,
+          output: 0,
+          reasoning: 0,
+          cacheRead: 0,
+          cacheWrite: 0,
+          cost: 0,
+          finish: null,
+          text: p.text,
+          tools: [],
+          parts: [],
+          prompt: p.text.slice(0, 400),
+          creditsMicro: 0
+        }
+      });
+    }
+    items.sort((a, b) => a.ts - b.ts);
+    const turns = items.map((it, i) => ({ ...it.turn, seq: i }));
+    const compactions = [];
+    let prev = null;
+    for (const r of ratios.sort((a, b) => a.ts - b.ts)) {
+      if (prev && r.tokens < prev.tokens - COMPACTION_DROP_TOKENS) {
+        compactions.push({
+          sessionId: id,
+          turnId: null,
+          type: "compaction",
+          // Sit between the two turns: `build` derives before/after from the turns
+          // around the event, and the drop itself happened in that gap.
+          at: Math.round((prev.ts + r.ts) / 2),
+          reason: "auto",
+          detail: "context reset (context drop)",
+          tokensBefore: prev.tokens,
+          tokensAfter: r.tokens,
+          model: null
+        });
+      }
+      prev = r;
+    }
+    return {
+      id,
+      file,
+      mtime,
+      directory: directory || "/",
+      title: title ?? (lastPrompt ? lastPrompt.split("\n")[0].slice(0, 120) : null),
+      created,
+      updated,
+      turns,
+      compactions,
+      paths: [...paths],
+      models,
+      credits,
+      creditsMicro: micro(credits),
+      tInput,
+      additions,
+      deletions,
+      files
+    };
+  }
+};
+
+// src/source-select.ts
+function openSource(kind = SOURCE_KIND) {
+  return kind === "qoder" ? new QoderSource(QODER_PROJECTS) : new SourceReader(SOURCE_DB);
+}
+
+// src/metrics/catalog.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } from "node:fs";
+var FALLBACK_CONTEXT = 128e3;
+var CATALOG_TTL_MS = 7 * 864e5;
+var catalogKey = (provider, model) => `${provider ?? "unknown"}/${model ?? "unknown"}`;
+function fromModelsDev(api, wanted) {
+  const out = {};
+  for (const [providerID, provider] of Object.entries(api ?? {})) {
+    for (const [modelID, m] of Object.entries(provider?.models ?? {})) {
+      const key = `${providerID}/${modelID}`;
+      if (!wanted.has(key)) continue;
+      out[key] = { ...normalize(modelID, providerID, m), source: "models.dev" };
+    }
+  }
+  return out;
+}
+function normalize(modelID, providerID, m) {
+  const cost = m?.cost ?? {};
+  const cache = cost.cache ?? {};
+  return {
+    id: modelID,
+    provider: providerID,
+    label: m?.name ?? modelID,
+    context: Number(m?.limit?.context) || FALLBACK_CONTEXT,
+    costInput: Number(cost.input) || 0,
+    costOutput: Number(cost.output) || 0,
+    costCacheRead: Number(cache.read) || 0,
+    costCacheWrite: Number(cache.write) || 0,
+    source: "cache"
+  };
+}
+function readCache() {
+  if (!existsSync3(MODEL_CATALOG)) return { fetchedAt: 0, models: {} };
+  try {
+    const parsed = JSON.parse(readFileSync2(MODEL_CATALOG, "utf8"));
+    if (parsed && typeof parsed === "object" && "models" in parsed && parsed.models) {
+      return { fetchedAt: Number(parsed.fetchedAt ?? 0), models: parsed.models };
+    }
+    return { fetchedAt: 0, models: parsed };
+  } catch {
+    return { fetchedAt: 0, models: {} };
+  }
+}
+function readOverrides() {
+  if (!existsSync3(MODEL_OVERRIDES)) return {};
+  try {
+    return JSON.parse(readFileSync2(MODEL_OVERRIDES, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function fallbackEntry(key) {
+  const provider = key.split("/")[0] ?? "unknown";
+  const model = key.split("/")[1] ?? key;
+  return { ...normalize(model, provider, null), source: "fallback" };
+}
+async function loadCatalog(wanted) {
+  const cache = readCache();
+  const overrides = readOverrides();
+  const stale = Date.now() - cache.fetchedAt > CATALOG_TTL_MS;
+  const missing = [...wanted].filter((k) => !cache.models[k]);
+  let fresh = {};
+  const offline = process.env.OSM_OFFLINE === "1";
+  if ((missing.length > 0 || stale) && !offline) {
+    try {
+      const res = await fetch("https://models.dev/api.json", { signal: AbortSignal.timeout(2e4) });
+      if (!res.ok) throw new Error(`models.dev HTTP ${res.status}`);
+      fresh = fromModelsDev(await res.json(), wanted);
+      writeFileSync(MODEL_CATALOG, JSON.stringify({ fetchedAt: Date.now(), models: { ...cache.models, ...fresh } }));
+    } catch (err) {
+      if (!cache.fetchedAt) {
+        writeFileSync(MODEL_CATALOG, JSON.stringify({ fetchedAt: Date.now(), models: cache.models }));
+      }
+      console.warn(`[catalog] models.dev unavailable (${err.message}); using cache/fallback`);
+    }
+  }
+  const merged = {};
+  for (const key of wanted) {
+    const cached = cache.models[key];
+    merged[key] = fresh[key] ?? (cached ? { ...fallbackEntry(key), ...cached, source: cached.source ?? "cache" } : fallbackEntry(key));
+  }
+  for (const [key, patch] of Object.entries(overrides)) {
+    if (!wanted.has(key)) continue;
+    merged[key] = { ...merged[key], ...patch, source: "override" };
+  }
+  return merged;
+}
+
+// src/metrics/build.ts
+var RETRY_WINDOW_MS = 15 * 60 * 1e3;
+var LOOP_MIN_REPEATS = 3;
+var localBucket = (ts) => Math.floor(ts / BUCKET_MS) * BUCKET_MS;
+var localHour = (ts) => new Date(ts).getHours();
+var localDayStart = (ts) => {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+};
+var CONTAINERS = /\/(?:projects|repos|plugins|workspace|Code)\/([^/.][^/]*)\//;
+var HOME_LEVEL = /^\/(?:home|Users)\/([^/]+)\/([^/.][^/]*)\//;
+var ROOT_LEVEL = /^\/(?:tmp|srv|opt|data|work)\/([^/.][^/]*)\//;
+var IGNORED = /* @__PURE__ */ new Set([
+  "home",
+  "root",
+  "users",
+  "usr",
+  "tmp",
+  "var",
+  "srv",
+  "opt",
+  "bin",
+  "lib",
+  "src",
+  "dist",
+  "data",
+  "log",
+  "logs",
+  "cache",
+  "config",
+  "appdata",
+  "desktop",
+  "documents",
+  "downloads",
+  "program",
+  "programs",
+  "programdata",
+  "node_modules",
+  "versions",
+  "share",
+  "code"
+]);
+var isJunkLane = (project, accounts) => !project || project === "/" || project === "unknown" || accounts.has(project);
+function inferProject(paths, fallback, accounts) {
+  const votes = /* @__PURE__ */ new Map();
+  const vote = (label, weight) => {
+    if (!label) return;
+    const l = label.toLowerCase();
+    if (l.startsWith(".") || l.length < 3 || IGNORED.has(l)) return;
+    votes.set(label, (votes.get(label) ?? 0) + weight);
+  };
+  for (const raw of paths) {
+    const p = raw.replace(/^\/mnt\/[a-zA-Z]\//, "/");
+    const container = p.match(CONTAINERS);
+    if (container) vote(container[1], 4);
+    else {
+      const home = p.match(HOME_LEVEL);
+      if (home) vote(home[2], 2);
+      else vote(p.match(ROOT_LEVEL)?.[1], 1);
+    }
+  }
+  const junk = isJunkLane(fallback, accounts);
+  let bestV = junk ? 0 : 2;
+  let best = junk ? "unknown" : fallback;
+  for (const [label, v] of votes) if (v > bestV) bestV = v, best = label;
+  return best;
+}
+function accountOf(path4) {
+  return (path4 ?? "").replace(/^\/mnt\/[a-zA-Z]\//, "/").match(/^\/(?:home|Users)\/([^/]+)$/)?.[1] ?? null;
+}
+async function build(db, opts = {}) {
+  const t0 = Date.now();
+  const mode = opts.mode ?? "full";
+  const src = openSource(opts.kind);
+  try {
+    initSchema(db, { drop: mode === "full" });
+    ensureRollups(db);
+    const allSessions = src.sessions();
+    const allById = new Map(allSessions.map((s) => [s.id, s]));
+    const targetIds = opts.sessionIds ?? new Set(allSessions.map((s) => s.id));
+    const sessionById = new Map(
+      allSessions.filter((s) => targetIds.has(s.id)).map((s) => [s.id, s])
+    );
+    const wanted = /* @__PURE__ */ new Set();
+    for (const s of sessionById.values()) if (s.model) wanted.add(catalogKey(s.provider, s.model));
+    const turnsRaw = src.turns(targetIds);
+    for (const t of turnsRaw) if (t.role === "assistant" && t.model) wanted.add(catalogKey(t.provider, t.model));
+    const catalog = await loadCatalog(wanted);
+    const patchFiles = src.patchFileCounts(targetIds);
+    const pathsBySession = /* @__PURE__ */ new Map();
+    for (const t of turnsRaw) {
+      if (!t.tools.length) continue;
+      const arr = pathsBySession.get(t.sessionId) ?? [];
+      for (const tl of t.tools) arr.push(...tl.paths);
+      pathsBySession.set(t.sessionId, arr);
+    }
+    for (const [sid, info2] of patchFiles) {
+      const arr = pathsBySession.get(sid) ?? [];
+      arr.push(...info2.paths);
+      pathsBySession.set(sid, arr);
+    }
+    const accounts = new Set(
+      allSessions.map((s) => accountOf(s.directory)).filter((a) => !!a)
+    );
+    for (const s of sessionById.values()) {
+      s.project = inferProject(pathsBySession.get(s.id) ?? [], s.project, accounts);
+    }
+    for (let pass = 0; pass < 3; pass++) {
+      let changed = false;
+      for (const s of sessionById.values()) {
+        if (!isJunkLane(s.project, accounts)) continue;
+        const parent = s.parentId ? allById.get(s.parentId) : null;
+        if (parent && !isJunkLane(parent.project, accounts)) s.project = parent.project, changed = true;
+      }
+      if (!changed) break;
+    }
+    for (const s of sessionById.values()) if (isJunkLane(s.project, accounts)) s.project = "scratch";
+    const info = (provider, model) => catalog[catalogKey(provider, model)] ?? catalog[catalogKey("opencode", model)] ?? null;
+    const turns = turnsRaw.map((t) => {
+      const bucket = localBucket(t.created);
+      const day = localDayStart(t.created);
+      const hour = localHour(t.created);
+      if (t.role !== "assistant") {
+        return { ...t, promptTotal: 0, occupancy: 0, contextWindow: 0, fill: 0, fillAfter: 0, costComputed: 0, bucket, day, hour };
+      }
+      const m = info(t.provider, t.model);
+      const promptTotal = t.input + t.cacheRead + t.cacheWrite;
+      const occupancy = promptTotal + t.output + t.reasoning;
+      const contextWindow = t.contextWindow ?? m?.context ?? 128e3;
+      const costComputed = m ? (t.input * m.costInput + t.output * m.costOutput + t.reasoning * m.costOutput + t.cacheRead * m.costCacheRead + t.cacheWrite * m.costCacheWrite) / 1e6 : 0;
+      return {
+        ...t,
+        promptTotal,
+        occupancy,
+        contextWindow,
+        fill: contextWindow > 0 ? Math.min(1, promptTotal / contextWindow) : 0,
+        fillAfter: contextWindow > 0 ? Math.min(1, occupancy / contextWindow) : 0,
+        costComputed: Math.max(t.cost, costComputed),
+        bucket,
+        day,
+        hour
+      };
+    });
+    const assistantBySession = /* @__PURE__ */ new Map();
+    for (const t of turns) {
+      if (t.role !== "assistant") continue;
+      if (t.occupancy <= 0 && t.tools.length === 0) continue;
+      const list = assistantBySession.get(t.sessionId) ?? [];
+      list.push(t);
+      assistantBySession.set(t.sessionId, list);
+    }
+    for (const list of assistantBySession.values()) list.sort((a, b) => a.created - b.created || a.seq - b.seq);
+    const firstPromptBySession = /* @__PURE__ */ new Map();
+    for (const t of turns) {
+      if (t.role !== "user" || !t.text || firstPromptBySession.has(t.sessionId)) continue;
+      firstPromptBySession.set(t.sessionId, t.text.replace(/\s+/g, " ").trim().slice(0, 300));
+    }
+    const eventsBySession = buildEventProbes(src.events(targetIds), assistantBySession);
+    const affectedBuckets = /* @__PURE__ */ new Set();
+    const affectedDays = /* @__PURE__ */ new Set();
+    const idList = [...targetIds];
+    if (idList.length) {
+      const ph = idList.map(() => "?").join(",");
+      const oldCells = db.prepare(`SELECT DISTINCT bucket, day FROM turns WHERE session_id IN (${ph})`).all(...idList);
+      for (const r of oldCells) {
+        if (r.bucket != null) affectedBuckets.add(Number(r.bucket));
+        if (r.day != null) affectedDays.add(Number(r.day));
+      }
+    }
+    let turnCount = 0;
+    let toolCount = 0;
+    let partCount = 0;
+    let eventCount = 0;
+    let sessionCount = 0;
+    db.exec("BEGIN");
+    try {
+      if (idList.length) {
+        const ph = idList.map(() => "?").join(",");
+        db.prepare(`DELETE FROM tools WHERE session_id IN (${ph})`).run(...idList);
+        db.prepare(`DELETE FROM parts WHERE session_id IN (${ph})`).run(...idList);
+        db.prepare(`DELETE FROM events WHERE session_id IN (${ph})`).run(...idList);
+        db.prepare(`DELETE FROM turns WHERE session_id IN (${ph})`).run(...idList);
+        db.prepare(`DELETE FROM sessions WHERE id IN (${ph})`).run(...idList);
+      }
+      const turnCols = [
+        "id",
+        "session_id",
+        "project",
+        "seq",
+        "created",
+        "completed",
+        "dur_ms",
+        "role",
+        "provider",
+        "model",
+        "variant",
+        "agent",
+        "input",
+        "output",
+        "reasoning",
+        "cache_read",
+        "cache_write",
+        "cost",
+        "credits_micro",
+        "prompt_total",
+        "occupancy",
+        "context_window",
+        "fill",
+        "fill_after",
+        "bucket",
+        "day",
+        "hour",
+        "finish",
+        "has_error",
+        "tool_calls",
+        "tool_errors",
+        "additions",
+        "deletions",
+        "write_lines",
+        "text"
+      ];
+      const insTurn = db.prepare(`INSERT INTO turns(${turnCols.join(",")}) VALUES(${turnCols.map(() => "?").join(",")})`);
+      const insTool = db.prepare(
+        `INSERT INTO tools(session_id,turn_id,call_id,name,status,started,ended,dur_ms,title,output_chars,additions,deletions,files,write_lines,error,sig,input_preview,target_session)
+         VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+      );
+      const insPart = db.prepare(
+        `INSERT INTO parts(session_id,turn_id,ordinal,kind,text,name,call_id,status,title,input,output,exit_code,truncated,started,ended,chars)
+         VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+      );
+      for (const t of turns) {
+        const s = sessionById.get(t.sessionId);
+        if (!s) continue;
+        insTurn.run(
+          t.id,
+          t.sessionId,
+          s.project,
+          t.seq,
+          t.created,
+          t.completed,
+          t.created && t.completed ? Math.max(0, t.completed - t.created) : null,
+          t.role,
+          t.provider,
+          t.model,
+          t.variant,
+          t.agent,
+          t.input,
+          t.output,
+          t.reasoning,
+          t.cacheRead,
+          t.cacheWrite,
+          t.costComputed,
+          t.creditsMicro ?? 0,
+          t.promptTotal,
+          t.occupancy,
+          t.contextWindow,
+          t.fill,
+          t.fillAfter,
+          t.bucket,
+          t.day,
+          t.hour,
+          t.finish,
+          t.tools.some((x) => x.status === "error") ? 1 : 0,
+          t.tools.length,
+          t.tools.filter((x) => x.status === "error").length,
+          t._add ?? 0,
+          t._del ?? 0,
+          t._write ?? 0,
+          (t.text ?? "").slice(0, 2e3)
+        );
+        turnCount++;
+        affectedBuckets.add(t.bucket);
+        affectedDays.add(t.day);
+        for (const tool of t.tools) {
+          insTool.run(
+            tool.sessionId,
+            t.id,
+            tool.callId,
+            tool.name,
+            tool.status,
+            tool.started,
+            tool.ended,
+            tool.started && tool.ended ? Math.max(0, tool.ended - tool.started) : null,
+            tool.title,
+            tool.outputChars,
+            tool.additions,
+            tool.deletions,
+            tool.files,
+            tool.writeLines,
+            tool.error ? tool.error.slice(0, 2e3) : null,
+            tool.sig,
+            tool.inputPreview,
+            tool.targetSession
+          );
+          toolCount++;
+          if (tool.status === "error") {
+            insertEvent(db, {
+              sessionId: tool.sessionId,
+              turnId: t.id,
+              type: "failure",
+              at: tool.started ?? t.created,
+              endAt: tool.ended ?? tool.started ?? t.created,
+              count: 1,
+              fill: t.fill,
+              detail: { tool: tool.name, error: (tool.error ?? "").slice(0, 300), title: tool.title }
+            });
+            eventCount++;
+          }
+        }
+        for (let i = 0; i < t.parts.length; i++) {
+          const p = t.parts[i];
+          insPart.run(
+            t.sessionId,
+            t.id,
+            i,
+            p.kind,
+            p.text || null,
+            p.name || null,
+            p.callId || null,
+            p.status || null,
+            p.title,
+            p.input || null,
+            p.output || null,
+            p.exitCode,
+            p.truncated ? 1 : 0,
+            p.started,
+            p.ended,
+            p.chars
+          );
+          partCount++;
+        }
+      }
+      for (const [sid, list] of eventsBySession) {
+        const ts = assistantBySession.get(sid) ?? [];
+        for (const e of list) {
+          let fill = 0;
+          for (const t of ts) {
+            if (t.created <= e.at) fill = t.fill;
+            else break;
+          }
+          insertEvent(db, { sessionId: sid, turnId: e.turnId, type: e.type, at: e.at, endAt: e.endAt, count: e.count, fill, detail: e.detail });
+          eventCount++;
+        }
+      }
+      const sessionCols = [
+        "id",
+        "project",
+        "directory",
+        "title",
+        "agent",
+        "provider",
+        "model",
+        "variant",
+        "parent_id",
+        "depth",
+        "created",
+        "updated",
+        "t_input",
+        "t_output",
+        "t_reasoning",
+        "t_cache_read",
+        "t_cache_write",
+        "cost",
+        "credits_micro",
+        "turns",
+        "tool_calls",
+        "tool_errors",
+        "compactions",
+        "retries",
+        "loops",
+        "additions",
+        "deletions",
+        "files_changed",
+        "peak_fill",
+        "avg_fill",
+        "eff_score",
+        "tokens_per_line",
+        "first_prompt",
+        "duration_ms",
+        "dominant_model",
+        "output_rate"
+      ];
+      const insSession = db.prepare(`INSERT INTO sessions(${sessionCols.join(",")}) VALUES(${sessionCols.map(() => "?").join(",")})`);
+      for (const s of sessionById.values()) {
+        const ts = assistantBySession.get(s.id) ?? [];
+        const sum = (f) => ts.reduce((a, t) => f(t) + a, 0);
+        const tInput = s.tInput || sum((t) => t.input);
+        const tOutput = s.tOutput || sum((t) => t.output);
+        const tReasoning = s.tReasoning || sum((t) => t.reasoning);
+        const tCacheRead = s.tCacheRead || sum((t) => t.cacheRead);
+        const tCacheWrite = s.tCacheWrite || sum((t) => t.cacheWrite);
+        const promptTotal = tInput + tCacheRead + tCacheWrite;
+        const turnAdd = sum((t) => t._add ?? 0);
+        const turnDel = sum((t) => t._del ?? 0);
+        const additions = turnAdd || s.additions;
+        const deletions = turnDel || s.deletions;
+        const toolCalls = ts.reduce((a, t) => a + t.tools.length, 0);
+        const toolErrors = ts.reduce((a, t) => a + t.tools.filter((x) => x.status === "error").length, 0);
+        const patches = patchFiles.get(s.id);
+        const filesChanged = Math.max(sum((t) => t._files ?? 0), patches?.files ?? 0);
+        const peak = ts.reduce((a, t) => Math.max(a, t.fill), 0);
+        const avg = ts.length ? ts.reduce((a, t) => a + t.fill, 0) / ts.length : 0;
+        const eff = promptTotal > 0 ? (tOutput + tReasoning) / promptTotal * 100 : 0;
+        const lines = additions + deletions;
+        const totalTokens = tInput + tOutput + tReasoning + tCacheRead + tCacheWrite;
+        const byModel = /* @__PURE__ */ new Map();
+        for (const t of ts) {
+          const k = t.model ?? "unknown";
+          byModel.set(k, (byModel.get(k) ?? 0) + t.occupancy);
+        }
+        let dominant = s.model ?? "unknown";
+        let bestV = -1;
+        for (const [k, v] of byModel) if (v > bestV) bestV = v, dominant = k;
+        const rates = ts.map((t) => t.output > 0 && t.completed && t.created && t.completed > t.created ? t.output / ((t.completed - t.created) / 1e3) : 0).filter((r) => r > 0).sort((a, b) => a - b);
+        const mid = Math.floor(rates.length / 2);
+        const outputRate = rates.length === 0 ? 0 : rates.length % 2 !== 0 ? rates[mid] : (rates[mid - 1] + rates[mid]) / 2;
+        const sessionEvents = eventsBySession.get(s.id) ?? [];
+        const compactions = sessionEvents.filter((e) => e.type === "compaction").length;
+        const retries = sessionEvents.filter((e) => e.type === "retry").length;
+        const loops = sessionEvents.filter((e) => e.type === "loop").length;
+        const creditsMicro = s.creditsMicro || ts.reduce((a, t) => a + (t.creditsMicro ?? 0), 0);
+        insSession.run(
+          s.id,
+          s.project,
+          s.directory,
+          s.title,
+          s.agent,
+          s.provider,
+          s.model,
+          s.variant,
+          s.parentId,
+          depthOf(s, allById),
+          s.created,
+          s.updated,
+          tInput,
+          tOutput,
+          tReasoning,
+          tCacheRead,
+          tCacheWrite,
+          Math.max(s.cost, ts.reduce((a, t) => a + t.costComputed, 0)),
+          creditsMicro,
+          ts.length,
+          toolCalls,
+          toolErrors,
+          compactions,
+          retries,
+          loops,
+          additions,
+          deletions,
+          filesChanged,
+          peak,
+          avg,
+          eff,
+          lines > 0 ? totalTokens / lines : null,
+          firstPromptBySession.get(s.id) ?? null,
+          s.updated - s.created,
+          dominant,
+          outputRate
+        );
+        sessionCount++;
+      }
+      const upModel = db.prepare(
+        `INSERT INTO models(id,provider,label,context,cost_input,cost_output,cost_cache_read,cost_cache_write,source)
+         VALUES(?,?,?,?,?,?,?,?,?)
+         ON CONFLICT(id) DO UPDATE SET label=excluded.label, context=excluded.context,
+           cost_input=excluded.cost_input, cost_output=excluded.cost_output,
+           cost_cache_read=excluded.cost_cache_read, cost_cache_write=excluded.cost_cache_write, source=excluded.source`
+      );
+      for (const [key, m] of Object.entries(catalog)) {
+        upModel.run(key, m.provider, m.label, m.context, m.costInput, m.costOutput, m.costCacheRead, m.costCacheWrite, m.source);
+      }
+      refreshRollups(db, idList, [...affectedDays], mode === "full");
+      setMeta(db, "sourceDb", src.path);
+      setMeta(db, "sourceSchema", src.schema);
+      setMeta(db, "sourceKind", src.kind);
+      setMeta(db, "unit", src.unit);
+      setMeta(db, "sourceMaxTime", String(src.maxMessageTime()));
+      setMeta(db, "materializedAt", String(Date.now()));
+      setMeta(db, "bucketMs", String(BUCKET_MS));
+      setMeta(db, "mode", mode);
+      db.exec("COMMIT");
+    } catch (e) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {
+      }
+      throw e;
+    }
+    const flowRows = recomputeFlow(db, affectedBuckets);
+    const heatRows = recomputeHeat(db, affectedDays);
+    return {
+      mode,
+      schema: src.schema,
+      sessions: sessionCount,
+      turns: turnCount,
+      tools: toolCount,
+      parts: partCount,
+      events: eventCount,
+      flow: flowRows,
+      heat: heatRows,
+      models: Object.keys(catalog).length,
+      ms: Date.now() - t0
+    };
+  } finally {
+    src.close();
+  }
+}
+function depthOf(s, byId) {
+  let d = 0;
+  let cur = s.parentId ? byId.get(s.parentId) : null;
+  while (cur && d < 10) {
+    d++;
+    cur = cur.parentId ? byId.get(cur.parentId) : null;
+  }
+  return d;
+}
+var insEventStmt = /* @__PURE__ */ new WeakMap();
+function insertEvent(db, e) {
+  let st = insEventStmt.get(db);
+  if (!st) {
+    st = db.prepare("INSERT INTO events(session_id,turn_id,type,at,end_at,count,fill,detail) VALUES(?,?,?,?,?,?,?,?)");
+    insEventStmt.set(db, st);
+  }
+  st.run(e.sessionId, e.turnId, e.type, Math.round(e.at), Math.round(e.endAt), e.count, e.fill, JSON.stringify(e.detail));
+}
+function buildEventProbes(sourceEvents, assistantBySession, opts = {}) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of sourceEvents) {
+    const list = out.get(e.sessionId) ?? [];
+    const detail = { reason: e.reason };
+    if (e.detail) detail.summary = e.detail;
+    if (e.tokensBefore != null) detail.sourceTokens = e.tokensBefore;
+    if (e.model) detail.model = e.model;
+    list.push({ type: e.type, at: e.at, endAt: e.at, count: 1, turnId: e.turnId, detail });
+    out.set(e.sessionId, list);
+  }
+  if (opts.enrichCompaction !== false) {
+    for (const [sid, list] of out) {
+      const ts = assistantBySession.get(sid);
+      if (!ts) continue;
+      for (const e of list) {
+        if (e.type !== "compaction") continue;
+        let idx = -1;
+        for (let i = 0; i < ts.length; i++) {
+          if (ts[i].created <= e.at) idx = i;
+          else break;
+        }
+        const before = idx >= 0 ? ts[idx] : null;
+        const after = idx + 1 < ts.length ? ts[idx + 1] : null;
+        if (before) {
+          e.detail.before = before.promptTotal;
+          e.detail.model = e.detail.model ?? before.model;
+        }
+        if (after) e.detail.after = after.promptTotal;
+        if (before && after) e.detail.delta = after.promptTotal - before.promptTotal;
+      }
+    }
+  }
+  for (const [sid, ts] of assistantBySession) {
+    const lastSeen = /* @__PURE__ */ new Map();
+    const chains = /* @__PURE__ */ new Map();
+    const probes = [];
+    for (const t of ts) {
+      for (const tool of t.tools) {
+        const at = tool.started ?? t.created;
+        const ok = tool.status !== "error";
+        const prev = lastSeen.get(tool.sig);
+        const dt = prev ? at - prev.at : null;
+        const within = dt != null && dt >= 0 && dt <= RETRY_WINDOW_MS;
+        if (prev && within && (!prev.ok || !ok)) {
+          probes.push({
+            type: "retry",
+            at: prev.at,
+            endAt: at,
+            count: 1,
+            turnId: t.id,
+            detail: { tool: tool.name, title: tool.title, sig: tool.sig, first_failed: !prev.ok, span_ms: at - prev.at }
+          });
+        }
+        let chain = chains.get(tool.sig);
+        if (within && chain) {
+          chain.count++;
+          chain.to = at;
+        } else {
+          chain = { count: 1, from: at, to: at };
+          chains.set(tool.sig, chain);
+        }
+        lastSeen.set(tool.sig, { at, ok });
+      }
+    }
+    for (const [sig, chain] of chains) {
+      if (chain.count >= LOOP_MIN_REPEATS) {
+        probes.push({
+          type: "loop",
+          at: chain.from,
+          endAt: chain.to,
+          count: chain.count,
+          turnId: null,
+          detail: { sig, repeats: chain.count, span_ms: chain.to - chain.from }
+        });
+      }
+    }
+    if (probes.length) {
+      const list = out.get(sid) ?? [];
+      out.set(sid, [...list, ...probes]);
+    }
+  }
+  for (const list of out.values()) list.sort((a, b) => a.at - b.at);
+  return out;
+}
+function recomputeFlow(db, buckets) {
+  if (!buckets.size) return 0;
+  const list = [...buckets];
+  const ph = list.map(() => "?").join(",");
+  const rows = db.prepare(
+    `SELECT project, bucket, session_id, model, input, output, reasoning, cache_read, cost, fill
+       FROM turns WHERE role='assistant' AND bucket IN (${ph})`
+  ).all(...list);
+  const cells = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const key = `${r.project}|${r.bucket}`;
+    let cell = cells.get(key);
+    if (!cell) {
+      cell = { project: r.project, bucket: Number(r.bucket), gen: 0, cacheRead: 0, cost: 0, sessions: /* @__PURE__ */ new Set(), models: /* @__PURE__ */ new Map(), peak: 0 };
+      cells.set(key, cell);
+    }
+    const gen = Number(r.input) + Number(r.output) + Number(r.reasoning);
+    cell.gen += gen;
+    cell.cacheRead += Number(r.cache_read ?? 0);
+    cell.cost += Number(r.cost ?? 0);
+    cell.sessions.add(String(r.session_id));
+    cell.peak = Math.max(cell.peak, Number(r.fill ?? 0));
+    const m = r.model ?? "unknown";
+    cell.models.set(m, (cell.models.get(m) ?? 0) + gen);
+  }
+  db.exec("BEGIN");
+  try {
+    db.prepare(`DELETE FROM flow WHERE bucket IN (${ph})`).run(...list);
+    const ins = db.prepare(
+      "INSERT INTO flow(project,bucket,tokens_gen,tokens_cache_read,cost,sessions,dominant_model,peak_fill) VALUES(?,?,?,?,?,?,?,?)"
+    );
+    for (const c of cells.values()) {
+      let dominant = "unknown";
+      let best = -1;
+      for (const [k, v] of c.models) if (v > best) best = v, dominant = k;
+      ins.run(c.project, c.bucket, Math.round(c.gen), Math.round(c.cacheRead), c.cost, c.sessions.size, dominant, c.peak);
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+  return cells.size;
+}
+function recomputeHeat(db, days) {
+  if (!days.size) return 0;
+  const list = [...days];
+  const ph = list.map(() => "?").join(",");
+  const rows = db.prepare(
+    `SELECT project, day, hour, input, output, reasoning, cache_read, cost
+       FROM turns WHERE role='assistant' AND day IN (${ph})`
+  ).all(...list);
+  const cells = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const key = `${r.project}|${r.day}|${r.hour}`;
+    let c = cells.get(key);
+    if (!c) {
+      c = { project: r.project, day: Number(r.day), hour: Number(r.hour), gen: 0, cacheRead: 0, cost: 0, turns: 0 };
+      cells.set(key, c);
+    }
+    c.gen += Number(r.input) + Number(r.output) + Number(r.reasoning);
+    c.cacheRead += Number(r.cache_read ?? 0);
+    c.cost += Number(r.cost ?? 0);
+    c.turns++;
+  }
+  db.exec("BEGIN");
+  try {
+    db.prepare(`DELETE FROM heat WHERE day IN (${ph})`).run(...list);
+    const ins = db.prepare("INSERT INTO heat(project,day,hour,tokens_gen,tokens_cache_read,cost,turns) VALUES(?,?,?,?,?,?,?)");
+    for (const c of cells.values()) ins.run(c.project, c.day, c.hour, Math.round(c.gen), Math.round(c.cacheRead), c.cost, c.turns);
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+  return cells.size;
+}
+
+// src/metrics/store.ts
+var slots = /* @__PURE__ */ new Map();
+function slotOf(kind) {
+  let slot = slots.get(kind);
+  if (!slot) {
+    slot = { handle: null, stat: null };
+    slots.set(kind, slot);
+  }
+  return slot;
+}
+function fileIdentity(kind) {
+  try {
+    const st = statSync2(metricsDbPath(kind));
+    return `${st.dev}:${st.ino}`;
+  } catch {
+    return "missing";
+  }
+}
+var hasStore = (kind = SOURCE_KIND) => existsSync4(metricsDbPath(kind));
+function current(kind = SOURCE_KIND) {
+  mkdirSync2(DATA_DIR, { recursive: true });
+  const slot = slotOf(kind);
+  const id = fileIdentity(kind);
+  if (slot.handle && slot.stat !== id) {
+    closeReader(kind);
+  }
+  if (!slot.handle) {
+    slot.handle = openMetrics(metricsDbPath(kind));
+    slot.stat = id;
+  }
+  return slot.handle;
+}
+function closeReader(kind) {
+  const kinds = kind ? [kind] : [...slots.keys()];
+  for (const k of kinds) {
+    const slot = slotOf(k);
+    try {
+      slot.handle?.close();
+    } catch {
+    }
+    slot.handle = null;
+    slot.stat = null;
+  }
+}
+function sourceChanged(kind = SOURCE_KIND) {
+  if (!hasStore(kind)) return true;
+  const prev = getMetaNumber(current(kind), "sourceMaxTime");
+  if (prev <= 0) return true;
+  const src = openSource(kind);
+  try {
+    return src.maxMessageTime() > prev;
+  } catch {
+    return false;
+  } finally {
+    src.close();
+  }
+}
+async function rebuild(kind = SOURCE_KIND, opts = {}) {
+  mkdirSync2(DATA_DIR, { recursive: true });
+  if (opts.full === true || !hasStore(kind) || schemaStale(kind)) return fullRebuild(kind);
+  return incrementalRebuild(kind);
+}
+function schemaStale(kind) {
+  try {
+    return getMeta(current(kind), "schemaSig") !== SCHEMA_SIG;
+  } catch {
+    return true;
+  }
+}
+var nextFile = (kind) => `${metricsDbPath(kind)}.next`;
+async function fullRebuild(kind) {
+  const next = nextFile(kind);
+  for (const suffix of ["", "-wal", "-shm"]) if (existsSync4(next + suffix)) rmSync(next + suffix, { force: true });
+  const writer = new DatabaseSync3(next);
+  writer.exec("PRAGMA journal_mode = WAL");
+  let report;
+  try {
+    report = await build(writer, { mode: "full", kind });
+  } finally {
+    writer.close();
+  }
+  closeReader(kind);
+  const target = metricsDbPath(kind);
+  for (const suffix of ["", "-wal", "-shm"]) rmSync(target + suffix, { force: true });
+  renameSync(next, target);
+  return report;
+}
+async function incrementalRebuild(kind) {
+  const db = current(kind);
+  const prevWatermark = getMetaNumber(db, "sourceMaxTime");
+  const src = openSource(kind);
+  let changed;
+  try {
+    changed = prevWatermark > 0 ? src.changedSessions(prevWatermark) : /* @__PURE__ */ new Set();
+  } finally {
+    src.close();
+  }
+  if (changed.size === 0) {
+    setMeta(db, "materializedAt", String(Date.now()));
+    return {
+      mode: "incremental",
+      schema: getMeta(db, "sourceSchema") ?? "v2",
+      sessions: 0,
+      turns: 0,
+      tools: 0,
+      parts: 0,
+      events: 0,
+      flow: 0,
+      heat: 0,
+      models: 0,
+      ms: 0
+    };
+  }
+  return build(db, { mode: "incremental", sessionIds: changed, kind });
+}
+
+// src/index.ts
+var REFRESH_MS = 12e4;
+var queue = Promise.resolve();
+function materialize(kind, opts = {}) {
+  const run = queue.then(() => doMaterialize(kind, opts), () => doMaterialize(kind, opts));
+  queue = run.catch(() => void 0);
+  return run;
+}
+async function doMaterialize(kind, { force = false, full = false }) {
+  if (!hasStore(kind) || full) {
+    console.log(`[osm] ${kind}: ${full ? "full rebuild requested" : "no store yet"} \u2014 materializing\u2026`);
+    const r2 = await rebuild(kind, { full: true });
+    console.log(
+      `[osm] ${kind}: built ${r2.sessions} sessions / ${r2.turns} turns / ${r2.tools} tools / ${r2.parts} parts in ${r2.ms}ms`
+    );
+    return r2;
+  }
+  if (!force && !sourceChanged(kind)) return void 0;
+  const r = await rebuild(kind);
+  console.log(
+    `[osm] ${kind}: ${r.mode} sync ${r.sessions} sessions / ${r.turns} turns / ${r.parts} parts / ${r.events} events in ${r.ms}ms`
+  );
+  return r;
+}
+var app = createApp({
+  db: (kind) => current(kind),
+  hasStore: (kind) => hasStore(kind),
+  refresh: (kind, full) => materialize(kind, { force: true, full })
+});
+var webDist = path3.join(ROOT, "web", "dist");
+if (existsSync5(webDist)) {
+  app.use(express2.static(webDist));
+  app.get("*splat", (req, res) => {
+    if (path3.extname(req.path)) return res.status(404).type("text/plain").send("not found");
+    res.sendFile(path3.join(webDist, "index.html"));
+  });
+  console.log(`[osm] serving built web from ${webDist}`);
+}
+app.listen(PORT, HOST, async () => {
+  console.log(`[osm] api on http://${HOST}:${PORT} (default source: ${SOURCE_KIND})`);
+  await materialize(SOURCE_KIND);
+  setInterval(() => {
+    for (const kind of SOURCE_KINDS) {
+      if (!hasStore(kind)) continue;
+      void materialize(kind).catch((e) => console.error(`[osm] ${kind} refresh failed:`, e.message));
+    }
+  }, REFRESH_MS);
+});