@kitsunemori96/opencode-session-metrics 0.1.0 → 0.2.0

package/server/dist/index.js

@@ -1,11 +1,12 @@
 // src/index.ts
 import express2 from "express";
-import { existsSync as existsSync3 } from "node:fs";
-import path2 from "node:path";
+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}`;
@@ -14,8 +15,28 @@ var USER_DATA_DIR = path.join(
   "opencode-session-metrics"
 );
 var DATA_DIR = process.env.OSM_DATA_DIR ?? (ROOT.includes(INSTALLED) ? USER_DATA_DIR : path.join(ROOT, ".data"));
-var METRICS_DB = path.join(DATA_DIR, "metrics.db");
 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";
@@ -420,9 +441,9 @@ function rawHourSource(slice) {
 
 // src/metrics/schema.ts
 import { mkdirSync } from "node:fs";
-function openMetrics() {
+function openMetrics(file = METRICS_DB) {
   mkdirSync(DATA_DIR, { recursive: true });
-  const db = new DatabaseSync(METRICS_DB);
+  const db = new DatabaseSync(file);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA foreign_keys = OFF");
   ensureIndexes(db);
@@ -447,6 +468,7 @@ CREATE TABLE IF NOT EXISTS turns (
   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,
@@ -498,7 +520,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   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, turns INTEGER, tool_calls INTEGER, tool_errors 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,
@@ -1339,19 +1361,19 @@ function toolDetail(db, raw, name) {
   let chars = 0;
   let failures = 0;
   for (const r of rows) {
-    const ms = num(r.ms);
+    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 += ms;
+    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 (ms >= LAT_BINS[k][1] && ms < LAT_BINS[k][2]) {
+      if (ms2 >= LAT_BINS[k][1] && ms2 < LAT_BINS[k][2]) {
         latency[k].count++;
         break;
       }
@@ -1463,10 +1485,20 @@ function facets(db) {
 // src/api.ts
 function createApp(deps) {
   const app2 = express();
-  app2.use(cors());
+  app2.use(cors({ exposedHeaders: ["x-osm-source"] }));
   app2.use(express.json());
-  const q = (sql, ...args) => deps.db().prepare(sql).all(...args);
-  const one = (sql, ...args) => deps.db().prepare(sql).get(...args);
+  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;
@@ -1489,15 +1521,44 @@ function createApp(deps) {
       gran: isGranularity(gran) ? gran : null
     };
   };
-  app2.get("/api/status", (_req, res) => {
-    const db = deps.db();
-    const count = (t) => one(`SELECT COUNT(*) c FROM ${t}`)?.c ?? 0;
+  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"),
@@ -1513,18 +1574,57 @@ function createApp(deps) {
       }
     });
   });
+  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 report = await deps.refresh(full);
-      res.json({ ok: true, full, report });
+      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 = ?`,
@@ -1532,6 +1632,7 @@ function createApp(deps) {
     );
     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
@@ -1540,12 +1641,14 @@ function createApp(deps) {
       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`,
@@ -1621,24 +1724,30 @@ function createApp(deps) {
       prompts: prompts.map((p) => ({ id: p.id, created: Number(p.created ?? 0), text: p.text ?? "" }))
     });
   });
-  app2.get("/api/top/facets", (_req, res) => {
-    res.json(facets(deps.db()));
+  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) => {
-    res.json(dashboard(deps.db(), sliceOf(req)));
+    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(deps.db(), slice, 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(deps.db(), slice, {
+      sessionsPage(db, slice, {
         q: str(req, "q"),
         order: SESSION_ORDERS.includes(order ?? "") ? order : "updated",
         dir: req.query.dir === "asc" ? "asc" : "desc",
@@ -1648,17 +1757,22 @@ function createApp(deps) {
     );
   });
   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(deps.db(), sliceOf(req), name);
+    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 '\\'
@@ -1695,7 +1809,7 @@ function createApp(deps) {
 
 // src/metrics/store.ts
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync, rmSync, statSync } from "node:fs";
+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";
@@ -1802,9 +1916,13 @@ function hashSig(name, input) {
 }
 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;
@@ -2237,8 +2355,596 @@ var SourceReader = class {
   }
 };
 
+// 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, writeFileSync, existsSync } from "node:fs";
+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"}`;
@@ -2269,9 +2975,9 @@ function normalize(modelID, providerID, m) {
   };
 }
 function readCache() {
-  if (!existsSync(MODEL_CATALOG)) return { fetchedAt: 0, models: {} };
+  if (!existsSync3(MODEL_CATALOG)) return { fetchedAt: 0, models: {} };
   try {
-    const parsed = JSON.parse(readFileSync(MODEL_CATALOG, "utf8"));
+    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 };
     }
@@ -2281,9 +2987,9 @@ function readCache() {
   }
 }
 function readOverrides() {
-  if (!existsSync(MODEL_OVERRIDES)) return {};
+  if (!existsSync3(MODEL_OVERRIDES)) return {};
   try {
-    return JSON.parse(readFileSync(MODEL_OVERRIDES, "utf8"));
+    return JSON.parse(readFileSync2(MODEL_OVERRIDES, "utf8"));
   } catch {
     return {};
   }
@@ -2393,13 +3099,13 @@ function inferProject(paths, fallback, accounts) {
   for (const [label, v] of votes) if (v > bestV) bestV = v, best = label;
   return best;
 }
-function accountOf(path3) {
-  return (path3 ?? "").replace(/^\/mnt\/[a-zA-Z]\//, "/").match(/^\/(?:home|Users)\/([^/]+)$/)?.[1] ?? null;
+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 = new SourceReader(opts.sourceDb ?? SOURCE_DB);
+  const src = openSource(opts.kind);
   try {
     initSchema(db, { drop: mode === "full" });
     ensureRollups(db);
@@ -2454,7 +3160,7 @@ async function build(db, opts = {}) {
       const m = info(t.provider, t.model);
       const promptTotal = t.input + t.cacheRead + t.cacheWrite;
       const occupancy = promptTotal + t.output + t.reasoning;
-      const contextWindow = m?.context ?? 128e3;
+      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,
@@ -2529,6 +3235,7 @@ async function build(db, opts = {}) {
         "cache_read",
         "cache_write",
         "cost",
+        "credits_micro",
         "prompt_total",
         "occupancy",
         "context_window",
@@ -2577,6 +3284,7 @@ async function build(db, opts = {}) {
           t.cacheRead,
           t.cacheWrite,
           t.costComputed,
+          t.creditsMicro ?? 0,
           t.promptTotal,
           t.occupancy,
           t.contextWindow,
@@ -2687,6 +3395,7 @@ async function build(db, opts = {}) {
         "t_cache_read",
         "t_cache_write",
         "cost",
+        "credits_micro",
         "turns",
         "tool_calls",
         "tool_errors",
@@ -2743,6 +3452,7 @@ async function build(db, opts = {}) {
         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,
@@ -2762,6 +3472,7 @@ async function build(db, opts = {}) {
           tCacheRead,
           tCacheWrite,
           Math.max(s.cost, ts.reduce((a, t) => a + t.costComputed, 0)),
+          creditsMicro,
           ts.length,
           toolCalls,
           toolErrors,
@@ -2793,8 +3504,10 @@ async function build(db, opts = {}) {
         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", opts.sourceDb ?? SOURCE_DB);
+      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));
@@ -3014,42 +3727,54 @@ function recomputeHeat(db, days) {
 }
 
 // src/metrics/store.ts
-var NEXT = METRICS_DB + ".next";
-var handle = null;
-var handleStat = null;
-function fileIdentity() {
+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 = statSync(METRICS_DB);
+    const st = statSync2(metricsDbPath(kind));
     return `${st.dev}:${st.ino}`;
   } catch {
     return "missing";
   }
 }
-function current() {
+var hasStore = (kind = SOURCE_KIND) => existsSync4(metricsDbPath(kind));
+function current(kind = SOURCE_KIND) {
   mkdirSync2(DATA_DIR, { recursive: true });
-  const id = fileIdentity();
-  if (handle && handleStat !== id) {
-    closeReader();
+  const slot = slotOf(kind);
+  const id = fileIdentity(kind);
+  if (slot.handle && slot.stat !== id) {
+    closeReader(kind);
   }
-  if (!handle) {
-    handle = openMetrics();
-    handleStat = id;
+  if (!slot.handle) {
+    slot.handle = openMetrics(metricsDbPath(kind));
+    slot.stat = id;
   }
-  return handle;
+  return slot.handle;
 }
-function closeReader() {
-  try {
-    handle?.close();
-  } catch {
+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;
   }
-  handle = null;
-  handleStat = null;
 }
-function sourceChanged() {
-  if (!existsSync2(METRICS_DB) || !existsSync2(SOURCE_DB)) return true;
-  const prev = getMetaNumber(current(), "sourceMaxTime");
+function sourceChanged(kind = SOURCE_KIND) {
+  if (!hasStore(kind)) return true;
+  const prev = getMetaNumber(current(kind), "sourceMaxTime");
   if (prev <= 0) return true;
-  const src = new SourceReader(SOURCE_DB);
+  const src = openSource(kind);
   try {
     return src.maxMessageTime() > prev;
   } catch {
@@ -3058,37 +3783,40 @@ function sourceChanged() {
     src.close();
   }
 }
-async function rebuild(opts = {}) {
+async function rebuild(kind = SOURCE_KIND, opts = {}) {
   mkdirSync2(DATA_DIR, { recursive: true });
-  if (opts.full === true || !existsSync2(METRICS_DB) || schemaStale()) return fullRebuild();
-  return incrementalRebuild();
+  if (opts.full === true || !hasStore(kind) || schemaStale(kind)) return fullRebuild(kind);
+  return incrementalRebuild(kind);
 }
-function schemaStale() {
+function schemaStale(kind) {
   try {
-    return getMeta(current(), "schemaSig") !== SCHEMA_SIG;
+    return getMeta(current(kind), "schemaSig") !== SCHEMA_SIG;
   } catch {
     return true;
   }
 }
-async function fullRebuild() {
-  for (const suffix of ["", "-wal", "-shm"]) if (existsSync2(NEXT + suffix)) rmSync(NEXT + suffix, { force: true });
-  const writer = new DatabaseSync3(NEXT);
+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" });
+    report = await build(writer, { mode: "full", kind });
   } finally {
     writer.close();
   }
-  closeReader();
-  for (const suffix of ["", "-wal", "-shm"]) rmSync(METRICS_DB + suffix, { force: true });
-  renameSync(NEXT, METRICS_DB);
+  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() {
-  const db = current();
+async function incrementalRebuild(kind) {
+  const db = current(kind);
   const prevWatermark = getMetaNumber(db, "sourceMaxTime");
-  const src = new SourceReader(SOURCE_DB);
+  const src = openSource(kind);
   let changed;
   try {
     changed = prevWatermark > 0 ? src.changedSessions(prevWatermark) : /* @__PURE__ */ new Set();
@@ -3111,43 +3839,54 @@ async function incrementalRebuild() {
       ms: 0
     };
   }
-  return build(db, { mode: "incremental", sessionIds: changed });
+  return build(db, { mode: "incremental", sessionIds: changed, kind });
 }
 
 // src/index.ts
 var REFRESH_MS = 12e4;
 var queue = Promise.resolve();
-function materialize(opts = {}) {
-  const run = queue.then(() => doMaterialize(opts), () => doMaterialize(opts));
+function materialize(kind, opts = {}) {
+  const run = queue.then(() => doMaterialize(kind, opts), () => doMaterialize(kind, opts));
   queue = run.catch(() => void 0);
   return run;
 }
-async function doMaterialize({ force = false, full = false }) {
-  if (!existsSync3(METRICS_DB) || full) {
-    console.log(`[osm] ${full ? "full rebuild requested" : "no metrics.db yet"} \u2014 materializing\u2026`);
-    const r2 = await rebuild({ full: true });
-    console.log(`[osm] built: ${r2.sessions} sessions / ${r2.turns} turns / ${r2.tools} tools / ${r2.parts} parts in ${r2.ms}ms`);
+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()) return void 0;
-  const r = await rebuild();
+  if (!force && !sourceChanged(kind)) return void 0;
+  const r = await rebuild(kind);
   console.log(
-    `[osm] ${r.mode} sync: ${r.sessions} sessions / ${r.turns} turns / ${r.parts} parts / ${r.events} events in ${r.ms}ms`
+    `[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: current, refresh: (full) => materialize({ force: true, full }) });
-var webDist = path2.join(ROOT, "web", "dist");
-if (existsSync3(webDist)) {
+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 (path2.extname(req.path)) return res.status(404).type("text/plain").send("not found");
-    res.sendFile(path2.join(webDist, "index.html"));
+    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}`);
-  await materialize();
-  setInterval(() => void materialize().catch((e) => console.error("[osm] refresh failed:", e.message)), REFRESH_MS);
+  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);
 });