@tekyzinc/gsd-t 4.9.14 → 4.10.10

package/bin/gsd-t-graph-store-bakeoff.cjs

@@ -0,0 +1,889 @@
+"use strict";
+
+/**
+ * gsd-t-graph-store-bakeoff — M94 D1-T2
+ *
+ * K1 store bake-off harness for the PROVE-OR-KILL spike.
+ *
+ * Loads the synthetic graph into each embedded-eligible candidate store, measures
+ * ALL FIVE K1 sub-criteria, and emits a PICK or KILL_OR_RESCOPE verdict.
+ *
+ * Sub-criteria (from graph-store-schema-contract.md):
+ *   1. Embedded-eligibility: embedded / on-disk / no-server / no-paid-license
+ *   2. Query latency: who_imports(X) AND who_calls(f) each < PRE-REGISTERED 50 ms ceiling
+ *   3. Incremental update: single-file put + one-hop edge re-validation < 1 s
+ *   4. Concurrent-update atomicity: concurrent who_imports(F) during re-index returns
+ *      fully-old OR fully-new edges (never torn/partial)
+ *   5. Footprint: peak RSS during load ≤ 4 GB AND on-disk index size ≤ 10× indexed source bytes
+ *
+ * A PICK requires ALL FIVE sub-criteria to PASS. Any failure → KILL_OR_RESCOPE.
+ * Every candidate carries a per-criterion breakdown; a bare KILL with no attribution FAILS.
+ *
+ * Candidates (the CLOSURE of embedded/no-server/no-paid-license category):
+ *   - sqlite    : SQLite via better-sqlite3 (recursive CTE for graph traversal)
+ *   - jsonl     : JSONL flat-file store (newline-delimited JSON, append+scan)
+ *   - graphology : graphology in-memory graph library (on-disk serialization)
+ *   - kuzu      : KuzuDB embedded Cypher (skipped if kuzu npm package absent)
+ *
+ * Store drivers are NEVER added to the shipped installer dependencies (zero-dep invariant).
+ * They are installed as devDependencies only for this spike and required() dynamically.
+ * If a driver is absent it fails with embedded-eligibility = false + a clear message.
+ *
+ * Envelope emitted to stdout:
+ * {
+ *   ok: true,
+ *   verdict: "PICK" | "KILL_OR_RESCOPE",
+ *   pickedStore?: string,          // only on PICK
+ *   candidateSetJustification: string,
+ *   candidates: [{
+ *     name, passed, failed, measured: { importLatencyMs, callLatencyMs, incrementalMs,
+ *                                       atomicityOk, peakRssBytes, indexSizeBytes },
+ *     embeddedEligible, notes
+ *   }],
+ *   acDescope?: object,            // only on KILL_OR_RESCOPE
+ *   k1Verdict: "PICK" | "KILL_OR_RESCOPE"
+ * }
+ *
+ * Pre-registered ceilings (from the contract — declared here BEFORE any measurement):
+ *   LATENCY_CEILING_MS   = 50      (ms per query — who_imports or who_calls)
+ *   INCREMENTAL_CEILING_S = 1.0    (seconds for single-file update + one-hop re-validation)
+ *   PEAK_RSS_CEILING_BYTES = 4 * 1024**3  (4 GB)
+ *   INDEX_SIZE_MULT_CEILING = 10   (index size ≤ 10× source bytes indexed)
+ *
+ * CLI:
+ *   node bin/gsd-t-graph-store-bakeoff.cjs [--nodes N] [--seed S] [--out FILE]
+ *
+ * Exit: 0 on PICK, 2 on KILL_OR_RESCOPE, 1 on harness error.
+ * Zero external runtime deps for the harness itself (node built-ins only).
+ * Store drivers (better-sqlite3, kuzu, graphology) required() dynamically at run time.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execFileSync, spawnSync } = require("node:child_process");
+
+// ─── Pre-registered ceilings (declared BEFORE any measurement) ────────────
+// Index-size CORRECTION (2026-06-25, user-approved): the original 10× ratio
+// ceiling was set with no reference. A full code graph stores import+call edges
+// PLUS per-node metadata (tier, content_hash, funcId) — legitimately 20–30× the
+// source-byte PROXY (sum of node-id lengths, not real source). All 4 candidates
+// failed ONLY this criterion (sqlite 28×, jsonl 19×, graphology 25×) while
+// crushing every perf ceiling ~1000×. The real constraint is ABSOLUTE on-disk
+// size, not ratio: SQLite @100K = 79 MB → ~686 MB @870K, unremarkable on a
+// laptop. New rule: index PASSES iff ratio ≤ 35× AND absolute ≤ 2 GB (both must
+// hold — passes the legitimate 28×/686 MB, still catches genuine runaway).
+const CEILINGS = {
+  LATENCY_CEILING_MS: 50,        // < 50 ms for who_imports + who_calls
+  INCREMENTAL_CEILING_S: 1.0,    // < 1 s single-file incremental update
+  PEAK_RSS_CEILING_BYTES: 4 * 1024 * 1024 * 1024, // 4 GB
+  INDEX_SIZE_MULT_CEILING: 35,   // index ≤ 35× source-byte proxy (was 10 — see note)
+  INDEX_SIZE_ABS_CEILING_BYTES: 2 * 1024 * 1024 * 1024, // AND ≤ 2 GB absolute on disk
+};
+
+// ─── Util ────────────────────────────────────────────────────────────────
+function hrMs(hrDiff) {
+  return hrDiff[0] * 1000 + hrDiff[1] / 1e6;
+}
+
+function tryRequire(pkg) {
+  try { return { mod: require(pkg), err: null }; }
+  catch (e) { return { mod: null, err: e.message }; }
+}
+
+function getRssBytes() {
+  return process.memoryUsage().rss;
+}
+
+function peakRss(fn) {
+  let peak = getRssBytes();
+  const result = fn();
+  peak = Math.max(peak, getRssBytes());
+  return { result, peakRssBytes: peak };
+}
+
+function measureMs(fn) {
+  const t = process.hrtime();
+  const result = fn();
+  return { result, ms: hrMs(process.hrtime(t)) };
+}
+
+// ─── Generator ───────────────────────────────────────────────────────────
+const { generate } = require("./gsd-t-graph-synthetic-gen.cjs");
+
+// ─── Candidate: JSONL ────────────────────────────────────────────────────
+/**
+ * JSONL flat-file store:
+ *   nodes.jsonl — one JSON record per line
+ *   edges-import.jsonl — one import edge per line
+ *   edges-call.jsonl   — one call edge per line
+ *
+ * Embedded: yes (pure file I/O). No server, no paid license.
+ * Atomicity: atomic write-to-temp + rename (single-file update).
+ * Concurrency: readers see either the old file or the new file, never torn.
+ */
+function candidateJsonl(dir, graph) {
+  const nodesPath = path.join(dir, "nodes.jsonl");
+  const edgesImportPath = path.join(dir, "edges-import.jsonl");
+  const edgesCallPath = path.join(dir, "edges-call.jsonl");
+
+  // LOAD: write the full graph
+  const { peakRssBytes } = peakRss(() => {
+    const nodeLines = graph.nodes.map((n) => JSON.stringify(n)).join("\n");
+    const importEdges = graph.edges.filter((e) => e.kind === "IMPORT");
+    const callEdges = graph.edges.filter((e) => e.kind === "CALL");
+    fs.writeFileSync(nodesPath, nodeLines, "utf8");
+    fs.writeFileSync(edgesImportPath, importEdges.map((e) => JSON.stringify(e)).join("\n"), "utf8");
+    fs.writeFileSync(edgesCallPath, callEdges.map((e) => JSON.stringify(e)).join("\n"), "utf8");
+  });
+
+  // INDEX SIZE (total of all store files)
+  const indexSizeBytes =
+    fs.statSync(nodesPath).size +
+    fs.statSync(edgesImportPath).size +
+    fs.statSync(edgesCallPath).size;
+
+  // SOURCE BYTES (synthetic: sum of node IDs as proxy for "source content")
+  const sourceBytesProxy = graph.nodes.reduce((acc, n) => acc + n.id.length, 0);
+  const indexToSourceMult = sourceBytesProxy > 0 ? indexSizeBytes / sourceBytesProxy : 0;
+
+  // QUERY: who_imports(X) — find all files that import file X
+  // We pick a file node as target
+  const fileNodes = graph.nodes.filter((n) => n.kind === "FILE");
+  const targetFile = fileNodes[Math.floor(fileNodes.length / 2)]?.id ?? fileNodes[0]?.id;
+
+  const importEdgesAll = graph.edges.filter((e) => e.kind === "IMPORT");
+  const callEdgesAll = graph.edges.filter((e) => e.kind === "CALL");
+
+  const { ms: importLatencyMs } = measureMs(() => {
+    // Scan the JSONL index
+    const raw = fs.readFileSync(edgesImportPath, "utf8");
+    const lines = raw.split("\n").filter(Boolean);
+    return lines
+      .map((l) => JSON.parse(l))
+      .filter((e) => e.dst === targetFile)
+      .map((e) => e.src);
+  });
+
+  // QUERY: who_calls(f) — find all functions that call function f
+  const entityNodes = graph.nodes.filter((n) => n.funcId);
+  const targetFunc = entityNodes[Math.floor(entityNodes.length / 2)]?.funcId ?? entityNodes[0]?.funcId;
+
+  const { ms: callLatencyMs } = measureMs(() => {
+    const raw = fs.readFileSync(edgesCallPath, "utf8");
+    const lines = raw.split("\n").filter(Boolean);
+    return lines
+      .map((l) => JSON.parse(l))
+      .filter((e) => e.dst === targetFunc)
+      .map((e) => e.src);
+  });
+
+  // INCREMENTAL UPDATE: update one file node + re-validate one-hop edges
+  const { ms: incrementalMs } = measureMs(() => {
+    // Simulate a file content change: update the target file's contentHash
+    const nodesRaw = fs.readFileSync(nodesPath, "utf8");
+    const nodeLines = nodesRaw.split("\n").filter(Boolean);
+    const updatedLines = nodeLines.map((l) => {
+      const n = JSON.parse(l);
+      if (n.id === targetFile) return JSON.stringify({ ...n, contentHash: "deadbeef" });
+      return l;
+    });
+    // Atomic write: write to temp, rename
+    const tmp = nodesPath + ".tmp";
+    fs.writeFileSync(tmp, updatedLines.join("\n"), "utf8");
+    fs.renameSync(tmp, nodesPath);
+    // Re-validate one-hop importers of targetFile
+    const imp = fs.readFileSync(edgesImportPath, "utf8")
+      .split("\n").filter(Boolean)
+      .map((l) => JSON.parse(l))
+      .filter((e) => e.dst === targetFile);
+    return imp;
+  });
+  const incrementalS = incrementalMs / 1000;
+
+  // ATOMICITY: atomic write+rename guarantees readers see either old or new file
+  // The store's mechanism: write to .tmp then rename() — POSIX atomic on same fs
+  // Test: simulate a concurrent read-during-write scenario deterministically
+  const atomicityOk = (() => {
+    // Write a test payload to a temp-then-rename path and verify the reader
+    // never sees a partial file (by checking the rename is atomic).
+    // For JSONL, we prove this structurally: Node.js fs.renameSync is atomic
+    // on POSIX (same filesystem). We verify by writing, renaming, then
+    // reading — the read must return valid JSON (whole file) or the old file.
+    const testPath = path.join(dir, "atomicity-test.jsonl");
+    const tmpPath = testPath + ".tmp";
+    const payload = JSON.stringify({ kind: "TEST", val: "new" });
+    fs.writeFileSync(tmpPath, payload, "utf8");
+    // Rename is POSIX atomic — the concurrent reader sees either old or new
+    fs.renameSync(tmpPath, testPath);
+    const read = fs.readFileSync(testPath, "utf8");
+    // Must be valid JSON (no torn read)
+    try { JSON.parse(read); return true; } catch { return false; }
+  })();
+
+  return {
+    peakRssBytes,
+    indexSizeBytes,
+    indexToSourceMult,
+    importLatencyMs,
+    callLatencyMs,
+    incrementalMs,
+    incrementalS,
+    atomicityOk,
+  };
+}
+
+// ─── Candidate: SQLite (better-sqlite3 recursive CTE) ───────────────────
+function candidateSqlite(dir, graph) {
+  const dbPath = path.join(dir, "graph.db");
+
+  const { mod: Database, err: sqliteErr } = tryRequire("better-sqlite3");
+  if (!Database) {
+    return { embeddedEligible: false, error: `better-sqlite3 not installed: ${sqliteErr}` };
+  }
+
+  let db;
+  let peakRssBytes = 0;
+  let indexSizeBytes = 0;
+
+  try {
+    const loaded = peakRss(() => {
+      db = new Database(dbPath);
+      db.pragma("journal_mode = WAL");
+      db.pragma("synchronous = NORMAL");
+
+      // Schema
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS nodes (
+          id TEXT PRIMARY KEY,
+          kind TEXT NOT NULL,
+          tier TEXT NOT NULL,
+          content_hash TEXT NOT NULL,
+          file TEXT NOT NULL,
+          name TEXT,
+          func_id TEXT
+        );
+        CREATE TABLE IF NOT EXISTS edges (
+          kind TEXT NOT NULL,
+          src TEXT NOT NULL,
+          dst TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS edges_dst ON edges(dst);
+        CREATE INDEX IF NOT EXISTS edges_src_kind ON edges(src, kind);
+      `);
+
+      // Load nodes
+      const insertNode = db.prepare(
+        `INSERT OR REPLACE INTO nodes (id, kind, tier, content_hash, file, name, func_id)
+         VALUES (@id, @kind, @tier, @contentHash, @file, @name, @funcId)`
+      );
+      const insertManyNodes = db.transaction((nodes) => {
+        for (const n of nodes) {
+          insertNode.run({
+            id: n.id, kind: n.kind, tier: n.tier, contentHash: n.contentHash,
+            file: n.file, name: n.name ?? null, funcId: n.funcId ?? null,
+          });
+        }
+      });
+      insertManyNodes(graph.nodes);
+
+      // Load edges
+      const insertEdge = db.prepare(`INSERT INTO edges (kind, src, dst) VALUES (@kind, @src, @dst)`);
+      const insertManyEdges = db.transaction((edges) => {
+        for (const e of edges) insertEdge.run(e);
+      });
+      insertManyEdges(graph.edges);
+
+      return true;
+    });
+    peakRssBytes = loaded.peakRssBytes;
+
+    // After load, get index size
+    db.close();
+    indexSizeBytes = fs.statSync(dbPath).size;
+    // Re-open for queries
+    db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+
+    const sourceBytesProxy = graph.nodes.reduce((acc, n) => acc + n.id.length, 0);
+    const indexToSourceMult = sourceBytesProxy > 0 ? indexSizeBytes / sourceBytesProxy : 0;
+
+    // QUERY: who_imports(X)
+    const fileNodes = graph.nodes.filter((n) => n.kind === "FILE");
+    const targetFile = fileNodes[Math.floor(fileNodes.length / 2)]?.id ?? fileNodes[0]?.id;
+
+    const { ms: importLatencyMs } = measureMs(() => {
+      return db.prepare("SELECT src FROM edges WHERE kind='IMPORT' AND dst=?").all(targetFile);
+    });
+
+    // QUERY: who_calls(f)
+    const entityNodes = graph.nodes.filter((n) => n.funcId);
+    const targetFunc = entityNodes[Math.floor(entityNodes.length / 2)]?.funcId ?? entityNodes[0]?.funcId;
+
+    const { ms: callLatencyMs } = measureMs(() => {
+      return db.prepare("SELECT src FROM edges WHERE kind='CALL' AND dst=?").all(targetFunc);
+    });
+
+    // INCREMENTAL UPDATE: update one file + re-validate one-hop edges
+    const { ms: incrementalMs } = measureMs(() => {
+      db.prepare("UPDATE nodes SET content_hash='deadbeef' WHERE id=?").run(targetFile);
+      // Re-validate one-hop importers
+      return db.prepare("SELECT src FROM edges WHERE kind='IMPORT' AND dst=?").all(targetFile);
+    });
+    const incrementalS = incrementalMs / 1000;
+
+    // ATOMICITY: SQLite WAL provides transaction-level atomicity.
+    // A concurrent reader during a write sees either the old committed state
+    // or blocks until commit — never torn. We verify via a quick write+read cycle.
+    const atomicityOk = (() => {
+      try {
+        const testUpdate = db.transaction(() => {
+          db.prepare("UPDATE nodes SET content_hash='atomtest' WHERE id=?").run(targetFile);
+          // Read inside same transaction — sees new value
+          const row = db.prepare("SELECT content_hash FROM nodes WHERE id=?").get(targetFile);
+          return row?.content_hash === "atomtest";
+        });
+        return testUpdate();
+      } catch { return false; }
+    })();
+
+    db.close();
+
+    return {
+      peakRssBytes,
+      indexSizeBytes,
+      indexToSourceMult,
+      importLatencyMs,
+      callLatencyMs,
+      incrementalMs,
+      incrementalS,
+      atomicityOk,
+    };
+  } catch (err) {
+    if (db) try { db.close(); } catch {}
+    return { embeddedEligible: false, error: err.message };
+  }
+}
+
+// ─── Candidate: Graphology ────────────────────────────────────────────────
+function candidateGraphology(dir, graph) {
+  const { mod: graphologyLib, err: graphologyErr } = tryRequire("graphology");
+  if (!graphologyLib) {
+    return { embeddedEligible: false, error: `graphology not installed: ${graphologyErr}` };
+  }
+
+  const graphPath = path.join(dir, "graph.json");
+  let peakRssBytes = 0;
+  let indexSizeBytes = 0;
+  let G;
+
+  try {
+    // Use the default export or Graph constructor
+    const GraphClass = graphologyLib.default ?? graphologyLib;
+
+    const loaded = peakRss(() => {
+      G = new GraphClass({ multi: true, type: "directed" });
+
+      // Add nodes
+      for (const n of graph.nodes) {
+        G.addNode(n.id, {
+          kind: n.kind,
+          tier: n.tier,
+          contentHash: n.contentHash,
+          file: n.file,
+          name: n.name ?? null,
+          funcId: n.funcId ?? null,
+        });
+      }
+
+      // Add edges
+      for (let i = 0; i < graph.edges.length; i++) {
+        const e = graph.edges[i];
+        G.addEdgeWithKey(`e${i}`, e.src, e.dst, { kind: e.kind });
+      }
+
+      // Serialize to disk
+      const serialized = JSON.stringify(G.export());
+      fs.writeFileSync(graphPath, serialized, "utf8");
+      return true;
+    });
+    peakRssBytes = loaded.peakRssBytes;
+    indexSizeBytes = fs.statSync(graphPath).size;
+
+    const sourceBytesProxy = graph.nodes.reduce((acc, n) => acc + n.id.length, 0);
+    const indexToSourceMult = sourceBytesProxy > 0 ? indexSizeBytes / sourceBytesProxy : 0;
+
+    // QUERY: who_imports(X) — in-edges of targetFile with kind=IMPORT
+    const fileNodes = graph.nodes.filter((n) => n.kind === "FILE");
+    const targetFile = fileNodes[Math.floor(fileNodes.length / 2)]?.id ?? fileNodes[0]?.id;
+
+    const { ms: importLatencyMs } = measureMs(() => {
+      const result = [];
+      G.forEachInEdge(targetFile, (edge, attrs, src) => {
+        if (attrs.kind === "IMPORT") result.push(src);
+      });
+      return result;
+    });
+
+    // QUERY: who_calls(f)
+    const entityNodes = graph.nodes.filter((n) => n.funcId);
+    const targetFunc = entityNodes[Math.floor(entityNodes.length / 2)]?.funcId ?? entityNodes[0]?.funcId;
+
+    const { ms: callLatencyMs } = measureMs(() => {
+      const result = [];
+      G.forEachInEdge(targetFunc, (edge, attrs, src) => {
+        if (attrs.kind === "CALL") result.push(src);
+      });
+      return result;
+    });
+
+    // INCREMENTAL UPDATE: update node attribute + re-serialize
+    const { ms: incrementalMs } = measureMs(() => {
+      G.setNodeAttribute(targetFile, "contentHash", "deadbeef");
+      // Re-validate one-hop importers (in-memory, no disk re-read)
+      const importers = [];
+      G.forEachInEdge(targetFile, (edge, attrs, src) => {
+        if (attrs.kind === "IMPORT") importers.push(src);
+      });
+      // Atomic write: temp+rename
+      const tmp = graphPath + ".tmp";
+      fs.writeFileSync(tmp, JSON.stringify(G.export()), "utf8");
+      fs.renameSync(tmp, graphPath);
+      return importers;
+    });
+    const incrementalS = incrementalMs / 1000;
+
+    // ATOMICITY: same atomic write+rename as JSONL
+    const atomicityOk = (() => {
+      try {
+        const testPath = path.join(dir, "atomicity-test.json");
+        const tmpPath = testPath + ".tmp";
+        fs.writeFileSync(tmpPath, JSON.stringify({ test: true }), "utf8");
+        fs.renameSync(tmpPath, testPath);
+        const read = fs.readFileSync(testPath, "utf8");
+        JSON.parse(read);
+        return true;
+      } catch { return false; }
+    })();
+
+    return {
+      peakRssBytes,
+      indexSizeBytes,
+      indexToSourceMult,
+      importLatencyMs,
+      callLatencyMs,
+      incrementalMs,
+      incrementalS,
+      atomicityOk,
+    };
+  } catch (err) {
+    return { embeddedEligible: false, error: err.message };
+  }
+}
+
+// ─── Candidate: KuzuDB (embedded Cypher) ─────────────────────────────────
+function candidateKuzu(dir, graph) {
+  const { mod: kuzu, err: kuzuErr } = tryRequire("kuzu");
+  if (!kuzu) {
+    return {
+      embeddedEligible: false,
+      error: `kuzu npm package not installed — install as devDependency for spike only: ${kuzuErr}`,
+    };
+  }
+
+  // KuzuDB API: Database → Connection → queries
+  const dbPath = path.join(dir, "kuzu-db");
+  let db, conn;
+  let peakRssBytes = 0;
+  let indexSizeBytes = 0;
+
+  try {
+    const loaded = peakRss(() => {
+      db = new kuzu.Database(dbPath);
+      conn = new kuzu.Connection(db);
+
+      // Schema
+      conn.query("CREATE NODE TABLE IF NOT EXISTS Node(id STRING, kind STRING, tier STRING, contentHash STRING, file STRING, name STRING, funcId STRING, PRIMARY KEY (id))");
+      conn.query("CREATE REL TABLE IF NOT EXISTS IMPORT(FROM Node TO Node)");
+      conn.query("CREATE REL TABLE IF NOT EXISTS CALL(FROM Node TO Node)");
+
+      // Load nodes in batches
+      const BATCH = 1000;
+      for (let i = 0; i < graph.nodes.length; i += BATCH) {
+        const batch = graph.nodes.slice(i, i + BATCH);
+        for (const n of batch) {
+          const name = (n.name ?? "").replace(/'/g, "\\'");
+          const funcId = (n.funcId ?? "").replace(/'/g, "\\'");
+          conn.query(`CREATE (:Node {id: '${n.id.replace(/'/g, "\\'")}', kind: '${n.kind}', tier: '${n.tier}', contentHash: '${n.contentHash}', file: '${n.file.replace(/'/g, "\\'")}', name: '${name}', funcId: '${funcId}'})`);
+        }
+      }
+
+      // Load edges
+      const importEdges = graph.edges.filter((e) => e.kind === "IMPORT");
+      const callEdges = graph.edges.filter((e) => e.kind === "CALL");
+      for (const e of importEdges) {
+        conn.query(`MATCH (a:Node {id: '${e.src.replace(/'/g, "\\'")}'}) MATCH (b:Node {id: '${e.dst.replace(/'/g, "\\'")}'}) CREATE (a)-[:IMPORT]->(b)`);
+      }
+      for (const e of callEdges) {
+        conn.query(`MATCH (a:Node {id: '${e.src.replace(/'/g, "\\'")}'}) MATCH (b:Node {id: '${e.dst.replace(/'/g, "\\'")}'}) CREATE (a)-[:CALL]->(b)`);
+      }
+      return true;
+    });
+    peakRssBytes = loaded.peakRssBytes;
+
+    // Index size: sum of kuzu db directory files
+    const kuzuFiles = fs.readdirSync(dbPath);
+    indexSizeBytes = kuzuFiles.reduce((acc, f) => {
+      try { return acc + fs.statSync(path.join(dbPath, f)).size; } catch { return acc; }
+    }, 0);
+
+    const sourceBytesProxy = graph.nodes.reduce((acc, n) => acc + n.id.length, 0);
+    const indexToSourceMult = sourceBytesProxy > 0 ? indexSizeBytes / sourceBytesProxy : 0;
+
+    const fileNodes = graph.nodes.filter((n) => n.kind === "FILE");
+    const targetFile = fileNodes[Math.floor(fileNodes.length / 2)]?.id ?? fileNodes[0]?.id;
+
+    const { ms: importLatencyMs } = measureMs(() => {
+      const res = conn.query(`MATCH (a:Node)-[:IMPORT]->(b:Node {id: '${targetFile.replace(/'/g, "\\'")}'}) RETURN a.id`);
+      return res.getAll();
+    });
+
+    const entityNodes = graph.nodes.filter((n) => n.funcId);
+    const targetFunc = entityNodes[Math.floor(entityNodes.length / 2)]?.funcId ?? entityNodes[0]?.funcId;
+
+    const { ms: callLatencyMs } = measureMs(() => {
+      const res = conn.query(`MATCH (a:Node)-[:CALL]->(b:Node {id: '${targetFunc.replace(/'/g, "\\'")}'}) RETURN a.id`);
+      return res.getAll();
+    });
+
+    const { ms: incrementalMs } = measureMs(() => {
+      conn.query(`MATCH (n:Node {id: '${targetFile.replace(/'/g, "\\'")}'}) SET n.contentHash = 'deadbeef'`);
+      const res = conn.query(`MATCH (a:Node)-[:IMPORT]->(b:Node {id: '${targetFile.replace(/'/g, "\\'")}'}) RETURN a.id`);
+      return res.getAll();
+    });
+    const incrementalS = incrementalMs / 1000;
+
+    // ATOMICITY: KuzuDB uses MVCC (multi-version concurrency control)
+    const atomicityOk = (() => {
+      try {
+        // KuzuDB is serializable by default — readers never see torn writes
+        // Verify by doing a write + immediate read in the same connection
+        conn.query(`MATCH (n:Node {id: '${targetFile.replace(/'/g, "\\'")}'}) SET n.contentHash = 'atomtest'`);
+        const res = conn.query(`MATCH (n:Node {id: '${targetFile.replace(/'/g, "\\'")}'}) RETURN n.contentHash`);
+        const rows = res.getAll();
+        return rows[0]?.["n.contentHash"] === "atomtest";
+      } catch { return false; }
+    })();
+
+    return {
+      peakRssBytes,
+      indexSizeBytes,
+      indexToSourceMult,
+      importLatencyMs,
+      callLatencyMs,
+      incrementalMs,
+      incrementalS,
+      atomicityOk,
+    };
+  } catch (err) {
+    if (conn) try { conn.close?.(); } catch {}
+    if (db) try { db.close?.(); } catch {}
+    return { embeddedEligible: false, error: err.message };
+  }
+}
+
+// ─── Criterion evaluation ─────────────────────────────────────────────────
+/**
+ * Evaluate a candidate's measurements against the pre-registered ceilings.
+ * Returns { passed: string[], failed: string[], measured: object }.
+ * Uses injected metrics (or the candidate's own measurement result).
+ * Supports override/injection for testing (synthetic fail scenarios).
+ */
+function evaluateCandidate(name, metrics) {
+  const passed = [];
+  const failed = [];
+  const measured = {};
+
+  // Sub-criterion 1: embedded eligibility
+  if (metrics.embeddedEligible === false) {
+    failed.push("embedded-eligibility");
+    measured.embeddedEligible = false;
+    measured.error = metrics.error ?? "unknown";
+    return { passed, failed, measured };
+  }
+  passed.push("embedded-eligibility");
+  measured.embeddedEligible = true;
+
+  // Sub-criterion 2a: who_imports latency
+  const importMs = metrics.importLatencyMs ?? Infinity;
+  measured.importLatencyMs = importMs;
+  if (importMs < CEILINGS.LATENCY_CEILING_MS) {
+    passed.push("query-latency-import");
+  } else {
+    failed.push("query-latency-import-over-50ms");
+  }
+
+  // Sub-criterion 2b: who_calls latency
+  const callMs = metrics.callLatencyMs ?? Infinity;
+  measured.callLatencyMs = callMs;
+  if (callMs < CEILINGS.LATENCY_CEILING_MS) {
+    passed.push("query-latency-call");
+  } else {
+    failed.push("query-latency-call-over-50ms");
+  }
+
+  // Sub-criterion 3: incremental update
+  const incMs = metrics.incrementalMs ?? Infinity;
+  const incS = metrics.incrementalS ?? (incMs / 1000);
+  measured.incrementalMs = incMs;
+  measured.incrementalS = incS;
+  if (incS < CEILINGS.INCREMENTAL_CEILING_S) {
+    passed.push("incremental-update");
+  } else {
+    failed.push("incremental-over-1s");
+  }
+
+  // Sub-criterion 4: atomicity
+  const atomOk = metrics.atomicityOk !== false;
+  measured.atomicityOk = atomOk;
+  if (atomOk) {
+    passed.push("concurrent-update-atomicity");
+  } else {
+    failed.push("atomicity-torn-read-risk");
+  }
+
+  // Sub-criterion 5a: peak RSS
+  const rss = metrics.peakRssBytes ?? 0;
+  measured.peakRssBytes = rss;
+  if (rss <= CEILINGS.PEAK_RSS_CEILING_BYTES) {
+    passed.push("footprint-peak-rss");
+  } else {
+    failed.push("footprint-peak-rss-over-4gb");
+  }
+
+  // Sub-criterion 5b: index size — ratio ≤ 35× source-proxy AND absolute ≤ 2 GB
+  // (BOTH must hold; the absolute cap is the real laptop constraint, the ratio
+  //  cap catches genuine structural runaway). See CEILINGS note above.
+  const mult = metrics.indexToSourceMult ?? 0;
+  const idxBytes = metrics.indexSizeBytes ?? 0;
+  measured.indexSizeBytes = idxBytes;
+  measured.indexToSourceMult = mult;
+  const ratioOk = mult <= CEILINGS.INDEX_SIZE_MULT_CEILING;
+  const absOk = idxBytes <= CEILINGS.INDEX_SIZE_ABS_CEILING_BYTES;
+  if (ratioOk && absOk) {
+    passed.push("footprint-index-size");
+  } else if (!ratioOk) {
+    failed.push("footprint-index-over-35x-source");
+  } else {
+    failed.push("footprint-index-over-2gb-absolute");
+  }
+
+  return { passed, failed, measured };
+}
+
+// ─── Main bake-off orchestrator ────────────────────────────────────────────
+/**
+ * Run the full bake-off.
+ * @param {object} opts
+ *   opts.nodes    — node count for synthetic graph (default 1500000)
+ *   opts.seed     — RNG seed (default 42)
+ *   opts.tmpDir   — base dir for store files (default os.tmpdir()/gsd-t-bakeoff-XXXXX)
+ *   opts.overrides — { candidateName: metricsObject } — inject synthetic metrics (testing only)
+ *   opts.skipCandidates — string[] — candidate names to skip (e.g. ['kuzu'])
+ * @returns {object} envelope
+ */
+function runBakeoff(opts = {}) {
+  const os = require("node:os");
+  const nodes = opts.nodes ?? 1_500_000;
+  const seed = opts.seed ?? 42;
+  const overrides = opts.overrides ?? {};
+  const skipCandidates = new Set(opts.skipCandidates ?? []);
+
+  // Generate synthetic graph
+  const graph = generate({ nodes, seed });
+  if (!graph.ok) {
+    return { ok: false, error: `graph generator failed: ${graph.error}` };
+  }
+
+  // Temp dir for store files
+  const tmpBase = opts.tmpDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "gsd-t-bakeoff-"));
+  const cleanupDirs = [];
+
+  const CANDIDATE_RUNNERS = [
+    { name: "sqlite",    fn: candidateSqlite },
+    { name: "jsonl",     fn: candidateJsonl },
+    { name: "graphology", fn: candidateGraphology },
+    { name: "kuzu",      fn: candidateKuzu },
+  ];
+
+  const candidateSetJustification =
+    "Candidate set = closure of the embedded/no-server/no-paid-license category: " +
+    "SQLite-recursive-CTE (zero-dep, ubiquitous), JSONL (simplest possible embedded store), " +
+    "graphology (in-memory graph library with disk serialization), " +
+    "KuzuDB-embedded (embedded Cypher, free). " +
+    "If all four fail, the next candidates to evaluate before declaring an architectural kill " +
+    "would be: LevelDB/RocksDB (key-value with adjacency lists), or import-graph-only " +
+    "re-scope (drop call-graph to reduce scale).";
+
+  const results = [];
+
+  for (const { name, fn } of CANDIDATE_RUNNERS) {
+    if (skipCandidates.has(name)) {
+      results.push({
+        name,
+        passed: [],
+        failed: ["skipped-by-caller"],
+        measured: {},
+        embeddedEligible: false,
+        notes: "Skipped by caller (skipCandidates option).",
+      });
+      continue;
+    }
+
+    // Use injected metrics if provided (testing/synthetic scenarios)
+    let metrics;
+    if (overrides[name]) {
+      metrics = overrides[name];
+    } else {
+      // Create a candidate-specific subdirectory
+      const cDir = path.join(tmpBase, name);
+      fs.mkdirSync(cDir, { recursive: true });
+      cleanupDirs.push(cDir);
+      try {
+        metrics = fn(cDir, graph);
+      } catch (err) {
+        metrics = { embeddedEligible: false, error: err.message };
+      }
+    }
+
+    const { passed, failed, measured } = evaluateCandidate(name, metrics);
+
+    results.push({
+      name,
+      passed,
+      failed,
+      measured,
+      embeddedEligible: metrics.embeddedEligible !== false,
+      notes: metrics.error ? `Error: ${metrics.error}` : null,
+    });
+  }
+
+  // Determine verdict
+  const winners = results.filter((r) => r.failed.length === 0);
+  let verdict;
+  let pickedStore;
+  let acDescope;
+
+  if (winners.length > 0) {
+    // PICK: use the first winner (deterministic order)
+    verdict = "PICK";
+    pickedStore = winners[0].name;
+  } else {
+    verdict = "KILL_OR_RESCOPE";
+    // [RULE] kill-outcome-records-ac-descope: record which ACs survive
+    acDescope = {
+      rule: "kill-outcome-records-ac-descope",
+      note: "K1 kill → consider import-graph-only re-scope (drop who_calls / call-graph tier = AC-2 partial + AC-6 call-graph tiers formally DESCOPED to Phase-2). AC-1 (tree-sitter throughput) unaffected. AC-3 (incremental) and AC-5 (no-stale invariant) scope depends on chosen alternative store. Record in progress.md.",
+      survivingAcs: ["AC-1-treesitter-throughput"],
+      descopedToPhase2: ["AC-2-who-calls", "AC-6-call-graph-tiers"],
+      requiredNextStep: "Re-run bake-off at reduced import-graph-only scale OR evaluate LevelDB/RocksDB as next candidate before declaring architectural kill.",
+    };
+  }
+
+  // Build the final envelope
+  const envelope = {
+    ok: true,
+    verdict,
+    k1Verdict: verdict,
+    pickedStore: pickedStore ?? null,
+    candidateSetJustification,
+    candidates: results,
+    ceilings: CEILINGS,
+    graphStats: {
+      nodeCount: graph.nodeCount,
+      edgeCount: graph.edgeCount,
+      seed,
+      scale: nodes,
+    },
+  };
+  if (acDescope) envelope.acDescope = acDescope;
+
+  // Verify: [RULE] k1-kill-attributable-per-candidate
+  // Every candidate in a KILL verdict must have per-criterion breakdown
+  if (verdict === "KILL_OR_RESCOPE") {
+    for (const r of results) {
+      if (r.failed.length === 0) continue; // this one passed, shouldn't happen but guard anyway
+      if (!r.failed || r.failed.length === 0) {
+        envelope.ok = false;
+        envelope.error = `KILL verdict: candidate '${r.name}' missing per-criterion failure attribution — violates [RULE] k1-kill-attributable-per-candidate`;
+        break;
+      }
+    }
+  }
+
+  return envelope;
+}
+
+module.exports = { runBakeoff, evaluateCandidate, CEILINGS, candidateJsonl, candidateSqlite };
+
+// ─── CLI entry point ──────────────────────────────────────────────────────
+if (require.main === module) {
+  function parseArgs(argv) {
+    const args = argv.slice(2);
+    let nodes = 1_500_000;
+    let seed = 42;
+    let out = null;
+    let i = 0;
+    while (i < args.length) {
+      const a = args[i];
+      if (a === "--nodes" && args[i + 1]) nodes = parseInt(args[++i], 10);
+      else if (a === "--seed" && args[i + 1]) seed = parseInt(args[++i], 10);
+      else if (a === "--out" && args[i + 1]) out = args[++i];
+      else if (a === "--small") nodes = 10_000;
+      else if (a === "--tiny") nodes = 500;
+      i++;
+    }
+    return { nodes, seed, out };
+  }
+
+  const { nodes, seed, out } = parseArgs(process.argv);
+
+  // Heap guard: the bake-off holds the full synthetic graph (nodes + ~3× edges)
+  // plus each candidate's in-memory copies. At ~870K-node (real Atos) scale this
+  // exceeds Node's default ~4 GB heap and OOMs (exit 134). Re-exec ONCE with a
+  // raised heap when the scale is large and we haven't already raised it.
+  const HEAP_GUARD_THRESHOLD = 300_000; // nodes above which the default heap is at risk
+  if (nodes >= HEAP_GUARD_THRESHOLD && !process.env.GSDT_BAKEOFF_HEAP_RAISED) {
+    const { spawnSync } = require("node:child_process");
+    const r = spawnSync(
+      process.execPath,
+      ["--max-old-space-size=8192", __filename, ...process.argv.slice(2)],
+      { stdio: "inherit", env: { ...process.env, GSDT_BAKEOFF_HEAP_RAISED: "1" } }
+    );
+    process.exit(r.status ?? 1);
+  }
+
+  let envelope;
+  try {
+    envelope = runBakeoff({ nodes, seed });
+  } catch (err) {
+    envelope = { ok: false, k1Verdict: null, error: err.message };
+  }
+
+  const json = JSON.stringify(envelope, null, 2);
+  if (out) {
+    fs.writeFileSync(out, json, "utf8");
+    // Summary to stdout
+    const summary = {
+      ok: envelope.ok,
+      k1Verdict: envelope.k1Verdict,
+      pickedStore: envelope.pickedStore,
+      verdict: envelope.verdict,
+    };
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+  } else {
+    process.stdout.write(json + "\n");
+  }
+
+  if (!envelope.ok) process.exit(1);
+  process.exit(envelope.verdict === "PICK" ? 0 : 2);
+}