crosscheck-mcp 0.2.11 → 0.2.13

package/dist/self-check.cjs

@@ -0,0 +1,1000 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/adapters/storage/migrations/0001_init.ts
+var m0001_init;
+var init_init = __esm({
+  "src/adapters/storage/migrations/0001_init.ts"() {
+    "use strict";
+    init_cjs_shims();
+    m0001_init = {
+      id: "0001_init",
+      name: "initial schema (sessions, usage_log, claims, ...)",
+      up: [
+        // sessions — includes the totals columns that Python adds via ALTER.
+        `CREATE TABLE IF NOT EXISTS sessions (
+       session_id              TEXT PRIMARY KEY,
+       started_at              INTEGER NOT NULL,
+       last_at                 INTEGER,
+       calls                   INTEGER NOT NULL DEFAULT 0,
+       wall_ms                 INTEGER NOT NULL DEFAULT 0,
+       cache_hits              INTEGER NOT NULL DEFAULT 0,
+       total_prompt_tokens     INTEGER NOT NULL DEFAULT 0,
+       total_completion_tokens INTEGER NOT NULL DEFAULT 0,
+       total_cached_tokens     INTEGER NOT NULL DEFAULT 0,
+       total_tokens            INTEGER NOT NULL DEFAULT 0,
+       total_cost_usd          REAL    NOT NULL DEFAULT 0.0,
+       total_cpu_ms            INTEGER NOT NULL DEFAULT 0
+     )`,
+        // usage_log — per-call ledger.
+        `CREATE TABLE IF NOT EXISTS usage_log (
+       id                INTEGER PRIMARY KEY AUTOINCREMENT,
+       session_id        TEXT NOT NULL,
+       ts                INTEGER NOT NULL,
+       tool              TEXT,
+       purpose           TEXT NOT NULL,
+       provider          TEXT NOT NULL,
+       model             TEXT NOT NULL,
+       prompt_tokens     INTEGER NOT NULL DEFAULT 0,
+       completion_tokens INTEGER NOT NULL DEFAULT 0,
+       cached_tokens     INTEGER NOT NULL DEFAULT 0,
+       total_tokens      INTEGER NOT NULL DEFAULT 0,
+       cost_usd          REAL    NOT NULL DEFAULT 0.0,
+       estimated         INTEGER NOT NULL DEFAULT 0,
+       wall_ms           INTEGER NOT NULL DEFAULT 0,
+       cpu_ms            INTEGER NOT NULL DEFAULT 0
+     )`,
+        `CREATE INDEX IF NOT EXISTS idx_usage_session  ON usage_log(session_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_usage_provider ON usage_log(provider)`,
+        // claims (FK to sessions, ON DELETE CASCADE).
+        `CREATE TABLE IF NOT EXISTS claims (
+       id             INTEGER PRIMARY KEY AUTOINCREMENT,
+       session_id     TEXT NOT NULL REFERENCES sessions(session_id) ON DELETE CASCADE,
+       text           TEXT NOT NULL,
+       provider       TEXT,
+       confidence     REAL,
+       citations_json TEXT,
+       kind           TEXT,
+       created_at     INTEGER NOT NULL
+     )`,
+        `CREATE INDEX IF NOT EXISTS idx_claims_session ON claims(session_id)`,
+        // claim_links (FK to claims). Kind enum widened in Python's
+        // _migrate_claim_links_check; mirrored here as the CHECK clause.
+        `CREATE TABLE IF NOT EXISTS claim_links (
+       id         INTEGER PRIMARY KEY AUTOINCREMENT,
+       src_id     INTEGER NOT NULL REFERENCES claims(id) ON DELETE CASCADE,
+       dst_id     INTEGER NOT NULL REFERENCES claims(id) ON DELETE CASCADE,
+       kind       TEXT    NOT NULL CHECK (kind IN ('supports','attacks','derives_from','merges_with')),
+       created_at INTEGER NOT NULL,
+       UNIQUE(src_id, dst_id, kind)
+     )`,
+        `CREATE INDEX IF NOT EXISTS idx_links_src ON claim_links(src_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_links_dst ON claim_links(dst_id)`,
+        // provider_stats — ballots accumulator for the smart router.
+        `CREATE TABLE IF NOT EXISTS provider_stats (
+       provider TEXT PRIMARY KEY,
+       wins     INTEGER NOT NULL DEFAULT 0,
+       losses   INTEGER NOT NULL DEFAULT 0,
+       abstains INTEGER NOT NULL DEFAULT 0,
+       last_at  INTEGER
+     )`,
+        // delegations — cross-model handshake ledger.
+        `CREATE TABLE IF NOT EXISTS delegations (
+       id         INTEGER PRIMARY KEY AUTOINCREMENT,
+       session_id TEXT,
+       requester  TEXT,
+       tool_call  TEXT NOT NULL,
+       via        TEXT NOT NULL,
+       accepted   INTEGER NOT NULL,
+       created_at INTEGER NOT NULL
+     )`,
+        `CREATE INDEX IF NOT EXISTS idx_deleg_session ON delegations(session_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_deleg_req     ON delegations(requester)`,
+        // session_memory — facts / open_questions / decisions ledger.
+        `CREATE TABLE IF NOT EXISTS session_memory (
+       id             INTEGER PRIMARY KEY AUTOINCREMENT,
+       session_id     TEXT    NOT NULL,
+       kind           TEXT    NOT NULL CHECK (kind IN ('fact','open_question','decision')),
+       content        TEXT    NOT NULL,
+       source_tool    TEXT,
+       source_call_id TEXT,
+       confidence     REAL,
+       created_at     INTEGER NOT NULL,
+       stale_at       INTEGER,
+       stale_reason   TEXT
+     )`,
+        `CREATE INDEX IF NOT EXISTS idx_session_memory_session ON session_memory(session_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_session_memory_kind    ON session_memory(kind)`,
+        // fetch_egress — per-session per-host byte ledger.
+        `CREATE TABLE IF NOT EXISTS fetch_egress (
+       session_id  TEXT NOT NULL,
+       host        TEXT NOT NULL,
+       total_bytes INTEGER NOT NULL DEFAULT 0,
+       last_at     INTEGER NOT NULL,
+       PRIMARY KEY (session_id, host)
+     )`,
+        // transcripts_fts — FTS5 virtual table for the recall tool. Python uses
+        // `tokenize='unicode61 remove_diacritics 2'`; mirrored exactly.
+        `CREATE VIRTUAL TABLE IF NOT EXISTS transcripts_fts USING fts5(
+       session_id, tool, ts UNINDEXED, path UNINDEXED, content,
+       tokenize='unicode61 remove_diacritics 2'
+     )`
+      ]
+    };
+  }
+});
+
+// src/adapters/storage/migrations/index.ts
+var MIGRATIONS;
+var init_migrations = __esm({
+  "src/adapters/storage/migrations/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_init();
+    MIGRATIONS = [m0001_init];
+  }
+});
+
+// src/adapters/storage/schema.ts
+function canonicalSchema(reader) {
+  const tables = listTables(reader);
+  const lines = [];
+  for (const table of tables) {
+    if (isFtsShadowTable(table)) continue;
+    if (isInternal(table)) continue;
+    if (table === "schema_migrations") continue;
+    if (isFtsVirtualTable(reader, table)) {
+      lines.push(`fts:${table}:${ftsTokenize(reader, table)}`);
+      continue;
+    }
+    lines.push(`table:${table}`);
+    for (const c of tableInfo(reader, table)) {
+      lines.push(
+        `  col:${c.cid}:${c.name}:${c.type}:${c.notnull}:${formatDefault(c.dflt_value)}:${c.pk}`
+      );
+    }
+    for (const idx of listIndexes(reader, table)) {
+      lines.push(
+        `  idx:${idx.name}:${idx.unique}:${idx.origin}:${idx.partial}`
+      );
+      const cols = indexInfo(reader, idx.name);
+      lines.push(`    cols:${cols.map((c) => c.name).join(",")}`);
+    }
+    for (const fk of listFks(reader, table)) {
+      lines.push(
+        `  fk:${fk.id}:${fk.seq}:${fk.table}:${fk.from}:${fk.to}:${fk.on_update}:${fk.on_delete}:${fk.match}`
+      );
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function listTables(reader) {
+  const rows = reader.list(
+    "SELECT name FROM sqlite_master WHERE type IN ('table') AND name NOT LIKE 'sqlite_%' ORDER BY name"
+  );
+  return rows.map((r) => String(r["name"]));
+}
+function isInternal(name) {
+  return name.startsWith("sqlite_");
+}
+function isFtsShadowTable(name) {
+  return /_(data|idx|docsize|content|config)$/.test(name);
+}
+function isFtsVirtualTable(reader, name) {
+  const r = reader.list(
+    `SELECT sql FROM sqlite_master WHERE type='table' AND name='${name.replace(/'/g, "''")}'`
+  );
+  if (r.length === 0) return false;
+  const sql = String(r[0]?.["sql"] ?? "").toLowerCase();
+  return sql.includes("using fts");
+}
+function ftsTokenize(reader, name) {
+  const r = reader.list(
+    `SELECT sql FROM sqlite_master WHERE type='table' AND name='${name.replace(/'/g, "''")}'`
+  );
+  if (r.length === 0) return "";
+  const sql = String(r[0]?.["sql"] ?? "");
+  const m = sql.match(/tokenize\s*=\s*['"]([^'"]+)['"]/i);
+  return m?.[1] ?? "";
+}
+function tableInfo(reader, name) {
+  const rows = reader.pragma("table_info", name);
+  return rows.map(
+    (r) => ({
+      cid: Number(r["cid"] ?? 0),
+      name: String(r["name"] ?? ""),
+      type: String(r["type"] ?? ""),
+      notnull: Number(r["notnull"] ?? 0),
+      dflt_value: r["dflt_value"],
+      pk: Number(r["pk"] ?? 0)
+    })
+  ).sort((a, b) => a.cid - b.cid);
+}
+function formatDefault(v) {
+  if (v === null || v === void 0) return "<null>";
+  return String(v);
+}
+function listIndexes(reader, table) {
+  const rows = reader.pragma("index_list", table);
+  return rows.map(
+    (r) => ({
+      seq: Number(r["seq"] ?? 0),
+      name: String(r["name"] ?? ""),
+      unique: Number(r["unique"] ?? 0),
+      origin: String(r["origin"] ?? ""),
+      partial: Number(r["partial"] ?? 0)
+    })
+  ).filter((r) => !r.name.startsWith("sqlite_autoindex_")).sort((a, b) => a.name.localeCompare(b.name));
+}
+function indexInfo(reader, indexName) {
+  const rows = reader.pragma("index_info", indexName);
+  return rows.map(
+    (r) => ({
+      seqno: Number(r["seqno"] ?? 0),
+      name: String(r["name"] ?? "")
+    })
+  ).sort((a, b) => a.seqno - b.seqno);
+}
+function listFks(reader, table) {
+  const rows = reader.pragma("foreign_key_list", table);
+  return rows.map(
+    (r) => ({
+      id: Number(r["id"] ?? 0),
+      seq: Number(r["seq"] ?? 0),
+      table: String(r["table"] ?? ""),
+      from: String(r["from"] ?? ""),
+      to: String(r["to"] ?? ""),
+      on_update: String(r["on_update"] ?? ""),
+      on_delete: String(r["on_delete"] ?? ""),
+      match: String(r["match"] ?? "")
+    })
+  ).sort((a, b) => a.id - b.id || a.seq - b.seq);
+}
+var init_schema = __esm({
+  "src/adapters/storage/schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/adapters/storage/better-sqlite3.ts
+var better_sqlite3_exports = {};
+__export(better_sqlite3_exports, {
+  openBetterSqliteStorage: () => openBetterSqliteStorage
+});
+function openBetterSqliteStorage(opts) {
+  const db = new import_better_sqlite3.default(opts.path);
+  const wantWal = opts.wal ?? opts.path !== ":memory:";
+  if (wantWal) db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma(`busy_timeout = ${opts.busyTimeoutMs ?? 5e3}`);
+  db.pragma("foreign_keys = ON");
+  return new BetterSqliteStorage(db);
+}
+var import_better_sqlite3, ALLOWED_LINK_KINDS, ALLOWED_MEMORY_KINDS, BetterSqliteStorage;
+var init_better_sqlite3 = __esm({
+  "src/adapters/storage/better-sqlite3.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+    init_migrations();
+    init_schema();
+    ALLOWED_LINK_KINDS = /* @__PURE__ */ new Set([
+      "supports",
+      "attacks",
+      "derives_from",
+      "merges_with"
+    ]);
+    ALLOWED_MEMORY_KINDS = /* @__PURE__ */ new Set([
+      "fact",
+      "open_question",
+      "decision"
+    ]);
+    BetterSqliteStorage = class {
+      constructor(db) {
+        this.db = db;
+      }
+      db;
+      stmts = /* @__PURE__ */ new Map();
+      // ------------------------------------------------------------------
+      // Lifecycle / lifetime
+      // ------------------------------------------------------------------
+      async migrate() {
+        this.db.exec(
+          "CREATE TABLE IF NOT EXISTS schema_migrations (id TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)"
+        );
+        const existing = new Set(
+          this.db.prepare("SELECT id FROM schema_migrations").all().map((r) => r.id)
+        );
+        const applied = [];
+        const ordered = [...MIGRATIONS].sort((a, b) => a.id.localeCompare(b.id));
+        for (const m of ordered) {
+          if (existing.has(m.id)) continue;
+          this.applyMigration(m);
+          applied.push(m.id);
+        }
+        return { applied };
+      }
+      applyMigration(m) {
+        const txn = this.db.transaction(() => {
+          for (const stmt of m.up) this.db.exec(stmt);
+          this.db.prepare(
+            "INSERT INTO schema_migrations(id, applied_at) VALUES (?, ?)"
+          ).run(m.id, Date.now());
+        });
+        txn();
+      }
+      async canonicalSchema() {
+        const reader = {
+          pragma: (name, arg) => arg === void 0 ? this.db.pragma(name) : this.db.pragma(`${name}('${arg.replace(/'/g, "''")}')`),
+          list: (sql) => this.db.prepare(sql).all()
+        };
+        return canonicalSchema(reader);
+      }
+      unsafe() {
+        return {
+          exec: async (sql, params) => {
+            const stmt = this.db.prepare(sql);
+            const info = stmt.run(...params ?? []);
+            return Number(info.changes);
+          },
+          query: async (sql, params) => this.db.prepare(sql).all(...params ?? [])
+        };
+      }
+      async close() {
+        this.db.close();
+      }
+      // ------------------------------------------------------------------
+      // Transactions. better-sqlite3 supports nested transactions via
+      // SAVEPOINTs automatically when the outer caller is already inside
+      // db.transaction(). We expose a Txn that mirrors Storage's surface;
+      // every method call inside the callback runs inside the open txn.
+      // ------------------------------------------------------------------
+      async txn(fn) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+          const result = await fn(this);
+          this.db.exec("COMMIT");
+          return result;
+        } catch (e) {
+          try {
+            this.db.exec("ROLLBACK");
+          } catch {
+          }
+          throw e;
+        }
+      }
+      // ==================================================================
+      // sessions
+      // ==================================================================
+      async getSession(sessionId) {
+        const row = this.cached(
+          "session-get",
+          "SELECT * FROM sessions WHERE session_id = ?"
+        ).get(sessionId);
+        return row ?? null;
+      }
+      async listSessions(opts) {
+        const limit = opts?.limit ?? 100;
+        return this.cached(
+          "session-list",
+          "SELECT * FROM sessions ORDER BY last_at DESC LIMIT ?"
+        ).all(limit);
+      }
+      async upsertSession(row) {
+        this.cached(
+          "session-upsert",
+          `INSERT INTO sessions
+         (session_id, started_at, last_at, calls, wall_ms, cache_hits,
+          total_prompt_tokens, total_completion_tokens, total_cached_tokens,
+          total_tokens, total_cost_usd, total_cpu_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(session_id) DO UPDATE SET
+         last_at = excluded.last_at,
+         calls = excluded.calls,
+         wall_ms = excluded.wall_ms,
+         cache_hits = excluded.cache_hits,
+         total_prompt_tokens = excluded.total_prompt_tokens,
+         total_completion_tokens = excluded.total_completion_tokens,
+         total_cached_tokens = excluded.total_cached_tokens,
+         total_tokens = excluded.total_tokens,
+         total_cost_usd = excluded.total_cost_usd,
+         total_cpu_ms = excluded.total_cpu_ms`
+        ).run(
+          row.session_id,
+          row.started_at,
+          row.last_at,
+          row.calls,
+          row.wall_ms,
+          row.cache_hits,
+          row.total_prompt_tokens,
+          row.total_completion_tokens,
+          row.total_cached_tokens,
+          row.total_tokens,
+          row.total_cost_usd,
+          row.total_cpu_ms
+        );
+      }
+      async accumulateSessionTotals(sessionId, delta) {
+        this.cached(
+          "session-touch",
+          `INSERT OR IGNORE INTO sessions
+         (session_id, started_at, last_at, calls, wall_ms, cache_hits)
+       VALUES (?, ?, ?, 0, 0, 0)`
+        ).run(sessionId, delta.last_at ?? 0, delta.last_at ?? null);
+        this.cached(
+          "session-acc",
+          `UPDATE sessions SET
+         calls = calls + ?,
+         wall_ms = wall_ms + ?,
+         cache_hits = cache_hits + ?,
+         total_prompt_tokens = total_prompt_tokens + ?,
+         total_completion_tokens = total_completion_tokens + ?,
+         total_cached_tokens = total_cached_tokens + ?,
+         total_tokens = total_tokens + ?,
+         total_cost_usd = total_cost_usd + ?,
+         total_cpu_ms = total_cpu_ms + ?,
+         last_at = COALESCE(?, last_at)
+       WHERE session_id = ?`
+        ).run(
+          delta.calls ?? 0,
+          delta.wall_ms ?? 0,
+          delta.cache_hits ?? 0,
+          delta.total_prompt_tokens ?? 0,
+          delta.total_completion_tokens ?? 0,
+          delta.total_cached_tokens ?? 0,
+          delta.total_tokens ?? 0,
+          delta.total_cost_usd ?? 0,
+          delta.total_cpu_ms ?? 0,
+          delta.last_at ?? null,
+          sessionId
+        );
+      }
+      // ==================================================================
+      // usage_log
+      // ==================================================================
+      async insertUsage(rows) {
+        if (rows.length === 0) return;
+        const stmt = this.cached(
+          "usage-insert",
+          `INSERT INTO usage_log
+         (session_id, ts, tool, purpose, provider, model,
+          prompt_tokens, completion_tokens, cached_tokens, total_tokens,
+          cost_usd, estimated, wall_ms, cpu_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        );
+        const tx = this.db.transaction((items) => {
+          for (const r of items) {
+            stmt.run(
+              r.session_id,
+              r.ts,
+              r.tool,
+              r.purpose,
+              r.provider,
+              r.model,
+              r.prompt_tokens ?? 0,
+              r.completion_tokens ?? 0,
+              r.cached_tokens ?? 0,
+              r.total_tokens ?? 0,
+              r.cost_usd ?? 0,
+              r.estimated ?? 0,
+              r.wall_ms ?? 0,
+              r.cpu_ms ?? 0
+            );
+          }
+        });
+        tx(rows);
+      }
+      async listUsageForSession(sessionId, opts) {
+        const where = ["session_id = ?"];
+        const params = [sessionId];
+        if (opts?.only_purpose && opts.only_purpose.length > 0) {
+          where.push(`purpose IN (${opts.only_purpose.map(() => "?").join(",")})`);
+          params.push(...opts.only_purpose);
+        }
+        if (opts?.only_provider && opts.only_provider.length > 0) {
+          where.push(`provider IN (${opts.only_provider.map(() => "?").join(",")})`);
+          params.push(...opts.only_provider);
+        }
+        const limit = opts?.limit ?? 1e3;
+        params.push(limit);
+        const sql = `SELECT * FROM usage_log WHERE ${where.join(" AND ")} ORDER BY id ASC LIMIT ?`;
+        return this.db.prepare(sql).all(...params);
+      }
+      async listUsageGroupedByPurpose(sessionId) {
+        return this.cached(
+          "usage-grp-purpose",
+          `SELECT purpose,
+              COUNT(*) AS calls,
+              COALESCE(SUM(prompt_tokens),     0) AS prompt_tokens,
+              COALESCE(SUM(completion_tokens), 0) AS completion_tokens,
+              COALESCE(SUM(total_tokens),      0) AS total_tokens,
+              COALESCE(SUM(cost_usd),          0) AS cost_usd,
+              COALESCE(SUM(wall_ms),           0) AS wall_ms,
+              COALESCE(SUM(cpu_ms),            0) AS cpu_ms
+       FROM usage_log
+       WHERE session_id = ?
+       GROUP BY purpose
+       ORDER BY purpose`
+        ).all(sessionId);
+      }
+      async listUsageGroupedByModel(sessionId) {
+        return this.cached(
+          "usage-grp-model",
+          `SELECT provider,
+              model,
+              COUNT(*) AS calls,
+              COALESCE(SUM(prompt_tokens),     0) AS prompt_tokens,
+              COALESCE(SUM(completion_tokens), 0) AS completion_tokens,
+              COALESCE(SUM(total_tokens),      0) AS total_tokens,
+              COALESCE(SUM(cost_usd),          0) AS cost_usd
+       FROM usage_log
+       WHERE session_id = ?
+       GROUP BY provider, model
+       ORDER BY cost_usd DESC, provider, model`
+        ).all(sessionId);
+      }
+      async listUsageGroupedByProvider(purpose) {
+        if (purpose !== void 0) {
+          return this.cached(
+            "usage-grp-provider-p",
+            `SELECT provider,
+                COUNT(*) AS calls,
+                COALESCE(SUM(total_tokens), 0) AS total_tokens,
+                COALESCE(SUM(cost_usd),     0) AS cost_usd,
+                0 AS errors
+         FROM usage_log
+         WHERE purpose = ?
+         GROUP BY provider
+         ORDER BY provider`
+          ).all(purpose);
+        }
+        return this.cached(
+          "usage-grp-provider",
+          `SELECT provider,
+              COUNT(*) AS calls,
+              COALESCE(SUM(total_tokens), 0) AS total_tokens,
+              COALESCE(SUM(cost_usd),     0) AS cost_usd,
+              0 AS errors
+       FROM usage_log
+       GROUP BY provider
+       ORDER BY provider`
+        ).all();
+      }
+      async listRouterStatsByPurpose(purpose, sinceMs) {
+        if (sinceMs !== void 0) {
+          return this.cached(
+            "router-stats-purpose-since",
+            `SELECT LOWER(provider)              AS provider,
+                COUNT(*)                     AS calls,
+                COALESCE(SUM(total_tokens), 0) AS tokens_sum,
+                COALESCE(AVG(total_tokens), 0) AS avg_total_tokens,
+                COALESCE(AVG(cost_usd),     0) AS avg_cost_usd,
+                COALESCE(AVG(wall_ms),      0) AS avg_wall_ms
+         FROM usage_log
+         WHERE purpose = ? AND ts >= ? AND provider IS NOT NULL
+         GROUP BY LOWER(provider)
+         ORDER BY provider`
+          ).all(purpose, sinceMs);
+        }
+        return this.cached(
+          "router-stats-purpose",
+          `SELECT LOWER(provider)              AS provider,
+              COUNT(*)                     AS calls,
+              COALESCE(SUM(total_tokens), 0) AS tokens_sum,
+              COALESCE(AVG(total_tokens), 0) AS avg_total_tokens,
+              COALESCE(AVG(cost_usd),     0) AS avg_cost_usd,
+              COALESCE(AVG(wall_ms),      0) AS avg_wall_ms
+       FROM usage_log
+       WHERE purpose = ? AND provider IS NOT NULL
+       GROUP BY LOWER(provider)
+       ORDER BY provider`
+        ).all(purpose);
+      }
+      // ==================================================================
+      // claims
+      // ==================================================================
+      async insertClaim(claim) {
+        const info = this.cached(
+          "claim-insert",
+          `INSERT INTO claims
+         (session_id, text, provider, confidence, citations_json, kind, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          claim.session_id,
+          claim.text,
+          claim.provider ?? null,
+          claim.confidence ?? null,
+          claim.citations ? JSON.stringify(claim.citations) : null,
+          claim.kind ?? null,
+          Date.now()
+        );
+        return Number(info.lastInsertRowid);
+      }
+      async insertClaimLink(srcId, dstId, kind) {
+        if (!ALLOWED_LINK_KINDS.has(kind)) {
+          throw new RangeError(`invalid claim_link kind: ${kind}`);
+        }
+        this.cached(
+          "claim-link-insert",
+          `INSERT OR IGNORE INTO claim_links (src_id, dst_id, kind, created_at)
+       VALUES (?, ?, ?, ?)`
+        ).run(srcId, dstId, kind, Date.now());
+      }
+      async listClaimsForSession(sessionId) {
+        return this.cached(
+          "claim-list-session",
+          "SELECT * FROM claims WHERE session_id = ? ORDER BY id"
+        ).all(sessionId);
+      }
+      async getClaim(claimId) {
+        const row = this.cached(
+          "claim-get",
+          "SELECT * FROM claims WHERE id = ?"
+        ).get(claimId);
+        return row ?? null;
+      }
+      async listClaimLinksForSession(sessionId) {
+        return this.cached(
+          "claim-link-list-session",
+          `SELECT cl.*
+       FROM claim_links cl
+       JOIN claims c ON c.id = cl.src_id OR c.id = cl.dst_id
+       WHERE c.session_id = ?
+       GROUP BY cl.id
+       ORDER BY cl.id`
+        ).all(sessionId);
+      }
+      async deleteClaimsForSession(sessionId) {
+        const info = this.cached(
+          "claim-delete-session",
+          "DELETE FROM claims WHERE session_id = ?"
+        ).run(sessionId);
+        return Number(info.changes);
+      }
+      // ==================================================================
+      // provider_stats
+      // ==================================================================
+      async listProviderStats(opts) {
+        const limit = opts?.limit ?? 100;
+        return this.cached(
+          "provider-stats-list",
+          "SELECT * FROM provider_stats ORDER BY (wins + losses + abstains) DESC, provider ASC LIMIT ?"
+        ).all(limit);
+      }
+      async getProviderStats(provider) {
+        const row = this.cached(
+          "provider-stats-get",
+          "SELECT * FROM provider_stats WHERE provider = ?"
+        ).get(provider);
+        return row ?? null;
+      }
+      async bumpProviderBallot(provider, ballot, at) {
+        const column = ballot === "agree" ? "wins" : ballot === "disagree" ? "losses" : "abstains";
+        this.db.prepare(
+          `INSERT INTO provider_stats(provider, wins, losses, abstains, last_at)
+         VALUES (?, 0, 0, 0, ?)
+         ON CONFLICT(provider) DO NOTHING`
+        ).run(provider, at);
+        this.db.prepare(
+          `UPDATE provider_stats SET ${column} = ${column} + 1, last_at = ? WHERE provider = ?`
+        ).run(at, provider);
+      }
+      // ==================================================================
+      // delegations
+      // ==================================================================
+      async insertDelegation(row) {
+        this.cached(
+          "delegation-insert",
+          `INSERT INTO delegations
+         (session_id, requester, tool_call, via, accepted, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+        ).run(
+          row.session_id,
+          row.requester,
+          row.tool_call,
+          row.via,
+          row.accepted,
+          row.created_at
+        );
+      }
+      async listDelegationsForSession(sessionId) {
+        return this.cached(
+          "delegation-list-session",
+          "SELECT * FROM delegations WHERE session_id = ? ORDER BY id"
+        ).all(sessionId);
+      }
+      async countDelegationsByRequester(requester) {
+        const r = this.cached(
+          "delegation-count-req",
+          "SELECT COUNT(*) AS n FROM delegations WHERE requester = ?"
+        ).get(requester);
+        return Number(r.n);
+      }
+      async countDelegationsBySession(sessionId) {
+        const r = this.cached(
+          "delegation-count-session",
+          "SELECT COUNT(*) AS n FROM delegations WHERE session_id = ?"
+        ).get(sessionId);
+        return Number(r.n);
+      }
+      async countAcceptedDelegationsBySession(sessionId) {
+        const r = this.cached(
+          "delegation-count-accepted-session",
+          "SELECT COUNT(*) AS n FROM delegations WHERE session_id = ? AND accepted = 1"
+        ).get(sessionId);
+        return Number(r.n);
+      }
+      async countAcceptedDelegationsByRequester(requester) {
+        const r = this.cached(
+          "delegation-count-accepted-requester",
+          "SELECT COUNT(*) AS n FROM delegations WHERE requester = ? AND accepted = 1"
+        ).get(requester);
+        return Number(r.n);
+      }
+      async listDelegationAggregatesByRequester() {
+        const rows = this.cached(
+          "delegation-agg-requester",
+          "SELECT requester, accepted, COUNT(*) AS n FROM delegations WHERE requester IS NOT NULL GROUP BY requester, accepted"
+        ).all();
+        return rows.map((r) => ({
+          requester: String(r.requester),
+          accepted: r.accepted === 1 ? 1 : 0,
+          count: Number(r.n)
+        }));
+      }
+      // ==================================================================
+      // global counts (scoreboard / observability)
+      // ==================================================================
+      async countScoreboardTotals() {
+        const countOne = (table) => {
+          try {
+            const r = this.db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get();
+            return r ? Number(r.n) : 0;
+          } catch {
+            return 0;
+          }
+        };
+        return {
+          sessions: countOne("sessions"),
+          claims: countOne("claims"),
+          claim_links: countOne("claim_links"),
+          delegations: countOne("delegations")
+        };
+      }
+      // ==================================================================
+      // session_memory
+      // ==================================================================
+      async insertSessionMemory(row) {
+        if (!ALLOWED_MEMORY_KINDS.has(row.kind)) {
+          throw new RangeError(`invalid session_memory kind: ${row.kind}`);
+        }
+        const info = this.cached(
+          "memory-insert",
+          `INSERT INTO session_memory
+         (session_id, kind, content, source_tool, source_call_id, confidence, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          row.session_id,
+          row.kind,
+          row.content,
+          row.source_tool ?? null,
+          row.source_call_id ?? null,
+          row.confidence ?? null,
+          row.created_at
+        );
+        return Number(info.lastInsertRowid);
+      }
+      async listSessionMemory(sessionId, opts) {
+        const where = ["session_id = ?"];
+        const params = [sessionId];
+        if (!opts?.include_stale) where.push("stale_at IS NULL");
+        if (opts?.kinds && opts.kinds.length > 0) {
+          where.push(`kind IN (${opts.kinds.map(() => "?").join(",")})`);
+          params.push(...opts.kinds);
+        }
+        const limit = opts?.limit ?? 50;
+        params.push(limit);
+        const sql = `SELECT * FROM session_memory WHERE ${where.join(" AND ")} ORDER BY id DESC LIMIT ?`;
+        return this.db.prepare(sql).all(...params);
+      }
+      async markSessionMemoryStale(sessionId, at, opts) {
+        const where = ["session_id = ?", "stale_at IS NULL"];
+        const params = [at, opts?.reason ?? "manual", sessionId];
+        if (opts?.ids && opts.ids.length > 0) {
+          where.push(`id IN (${opts.ids.map(() => "?").join(",")})`);
+          params.push(...opts.ids);
+        }
+        if (opts?.kinds && opts.kinds.length > 0) {
+          where.push(`kind IN (${opts.kinds.map(() => "?").join(",")})`);
+          params.push(...opts.kinds);
+        }
+        const sql = `UPDATE session_memory SET stale_at = ?, stale_reason = ? WHERE ${where.join(" AND ")}`;
+        const info = this.db.prepare(sql).run(...params);
+        return Number(info.changes);
+      }
+      async clearSessionMemory(sessionId) {
+        const info = this.cached(
+          "memory-clear",
+          "DELETE FROM session_memory WHERE session_id = ?"
+        ).run(sessionId);
+        return Number(info.changes);
+      }
+      // ==================================================================
+      // fetch_egress
+      // ==================================================================
+      async recordFetchEgress(sessionId, host, bytes, at) {
+        this.cached(
+          "fetch-egress-upsert",
+          `INSERT INTO fetch_egress (session_id, host, total_bytes, last_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(session_id, host) DO UPDATE SET
+         total_bytes = total_bytes + excluded.total_bytes,
+         last_at = excluded.last_at`
+        ).run(sessionId, host, bytes, at);
+      }
+      async getFetchEgressTotals(sessionId) {
+        const r = this.cached(
+          "fetch-egress-totals",
+          "SELECT COALESCE(SUM(total_bytes), 0) AS total_bytes, COUNT(DISTINCT host) AS unique_hosts FROM fetch_egress WHERE session_id = ?"
+        ).get(sessionId);
+        return {
+          total_bytes: Number(r.total_bytes ?? 0),
+          unique_hosts: Number(r.unique_hosts ?? 0)
+        };
+      }
+      async hasFetchEgressHost(sessionId, host) {
+        const r = this.cached(
+          "fetch-egress-has-host",
+          "SELECT 1 AS one FROM fetch_egress WHERE session_id = ? AND host = ? LIMIT 1"
+        ).get(sessionId, host);
+        return r !== void 0;
+      }
+      // ==================================================================
+      // transcripts_fts — the encapsulated FTS5 surface.
+      // ==================================================================
+      async indexTranscript(row) {
+        this.cached(
+          "fts-insert",
+          `INSERT INTO transcripts_fts (session_id, tool, ts, path, content)
+       VALUES (?, ?, ?, ?, ?)`
+        ).run(row.session_id ?? "", row.tool, String(row.ts), row.path, row.content);
+      }
+      async recallSearch(query, k, opts) {
+        const where = ["transcripts_fts MATCH ?"];
+        const params = [query];
+        if (opts?.session_id) {
+          where.push("session_id = ?");
+          params.push(opts.session_id);
+        }
+        if (opts?.tool) {
+          where.push("tool = ?");
+          params.push(opts.tool);
+        }
+        if (opts?.since_ms !== void 0) {
+          where.push("CAST(ts AS INTEGER) >= ?");
+          params.push(opts.since_ms);
+        }
+        params.push(k);
+        const sql = `SELECT path, session_id, tool, ts,        snippet(transcripts_fts, -1, '[[', ']]', '...', 16) AS snippet,        bm25(transcripts_fts) AS rank FROM transcripts_fts WHERE ${where.join(" AND ")} ORDER BY rank LIMIT ?`;
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((r) => ({
+          path: r.path,
+          session_id: r.session_id ?? null,
+          tool: r.tool ?? null,
+          ts: Number(r.ts),
+          snippet: r.snippet,
+          score: 1 / (1 + Math.max(0, r.rank ?? 0))
+        }));
+      }
+      // ------------------------------------------------------------------
+      // Prepared-statement cache. better-sqlite3 prepares statements lazily
+      // and caches them internally, but the JS-side reference still costs
+      // a hashmap lookup on every call. Keeping our own map by key lets
+      // hot-path queries hit a single Map.get().
+      // ------------------------------------------------------------------
+      cached(key, sql) {
+        let s = this.stmts.get(key);
+        if (!s) {
+          s = this.db.prepare(sql);
+          this.stmts.set(key, s);
+        }
+        return s;
+      }
+    };
+  }
+});
+
+// src/self-check.ts
+var self_check_exports = {};
+__export(self_check_exports, {
+  checkLocalStorage: () => checkLocalStorage,
+  parseAbiMismatch: () => parseAbiMismatch
+});
+module.exports = __toCommonJS(self_check_exports);
+init_cjs_shims();
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+var ABI_MISMATCH_RE = /NODE_MODULE_VERSION (\d+)\..*requires\s+NODE_MODULE_VERSION (\d+)/s;
+function resolveRepoFile(rel) {
+  let dir = __dirname;
+  for (let i = 0; i < 8; i++) {
+    const candidate = import_node_path.default.join(dir, rel);
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+    const parent = import_node_path.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function parseAbiMismatch(message) {
+  const m = ABI_MISMATCH_RE.exec(message);
+  return m ? { loaded: Number(m[1]), required: Number(m[2]) } : void 0;
+}
+function defaultDbPath() {
+  const dataDir = process.env["CROSSCHECK_DATA_DIR"] || import_node_path.default.join(process.env["HOME"] ?? process.env["USERPROFILE"] ?? "", ".crosscheck");
+  return process.env["CROSSCHECK_DB_PATH"] ?? resolveRepoFile(".crosscheck/db.sqlite") ?? import_node_path.default.join(dataDir, "db.sqlite");
+}
+async function checkLocalStorage(dbPath) {
+  const resolvedPath = dbPath ?? defaultDbPath();
+  try {
+    (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(resolvedPath), { recursive: true });
+    const { openBetterSqliteStorage: openBetterSqliteStorage2 } = await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports));
+    const storage = openBetterSqliteStorage2({ path: resolvedPath });
+    await storage.migrate();
+    await storage.close();
+    return { ok: true, path: resolvedPath };
+  } catch (e) {
+    const message = e.message ?? String(e);
+    const abiMismatch = parseAbiMismatch(message);
+    return {
+      ok: false,
+      path: resolvedPath,
+      error: message,
+      ...abiMismatch ? { abiMismatch } : {}
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkLocalStorage,
+  parseAbiMismatch
+});
+//# sourceMappingURL=self-check.cjs.map