@opennodes/registry 0.1.0 → 0.1.2

package/src/stageb.js

@@ -12,7 +12,7 @@ export const FINGERPRINT_PROMPTS = [
   'ONP identity probe 3: repeat exactly: basalt-7301',
 ];
 
-async function chatOnce(safeFetch, card, offering, content, maxTokens = 64) {
+async function chatOnce(safeFetch, card, offering, content, maxTokens = 64, timeoutMs = 60_000) {
   const t0 = performance.now();
   const { status, body } = await fetchJsonCapped(safeFetch, `${card.endpoints.openai}/chat/completions`, {
     method: 'POST',
@@ -27,7 +27,7 @@ async function chatOnce(safeFetch, card, offering, content, maxTokens = 64) {
       temperature: 0,
       max_tokens: maxTokens,
     }),
-  }, 60_000);
+  }, timeoutMs);
   return {
     status,
     text: body?.choices?.[0]?.message?.content ?? null,
@@ -61,6 +61,14 @@ async function probeIdentity(safeFetch, card, offering, refs) {
   return { ok: matches === refs.length, matches, total: refs.length };
 }
 
+/** A needle counts as retrieved if the reply carries the full token or just its digits (small models drop the prefix). */
+export function needleFound(text, needle) {
+  if (typeof text !== 'string') return false;
+  if (text.includes(needle)) return true;
+  const digits = needle.split(':')[1];
+  return new RegExp(`(^|[^0-9])${digits}([^0-9]|$)`).test(text);
+}
+
 /** DS-ADM-03: needle retrieval at 25/50/90% of the claimed window; returns the verified cap. */
 async function probeContext(safeFetch, card, offering) {
   const claimed = offering.serving?.context_window ?? 4096;
@@ -76,12 +84,14 @@ async function probeContext(safeFetch, card, offering) {
       + ` ${needle} `
       + fillerUnit.repeat(Math.ceil(afterNeedle / fillerUnit.length)).slice(0, afterNeedle)
       + ' Return the NEEDLE token from this text.';
-    let found = false;
+    let found = false, why = null;
     try {
-      const { status, text } = await chatOnce(safeFetch, card, offering, prompt, 64);
-      found = status === 200 && typeof text === 'string' && text.includes(needle);
-    } catch { found = false; }
-    results.push({ fraction, tokens, found });
+      // Prefill on modest hardware is slow: allow ~30 ms per claimed token on top of the base timeout.
+      const { status, text } = await chatOnce(safeFetch, card, offering, prompt, 64, 60_000 + tokens * 30);
+      found = status === 200 && needleFound(text, needle);
+      if (!found) why = status !== 200 ? `status ${status}` : 'needle not in reply';
+    } catch (err) { found = false; why = /abort|timeout/i.test(String(err?.message)) ? 'timeout' : String(err?.message ?? err).slice(0, 80); }
+    results.push({ fraction, tokens, found, ...(why ? { why } : {}) });
     if (found) cap = Math.max(cap, tokens);
   }
   const allPassed = results.every((r) => r.found);
@@ -145,7 +155,8 @@ export async function runStageB(store, nodeId, card, { safeFetch, capacity = {}
     await store.recordProbe(nodeId, offering.offering_id, 'B', 'context', verdict.context.ok,
       `claimed ${verdict.context.claimed}, verified ${verdict.context.verified_cap}`,
       verdict.context);
-    if (!verdict.context.ok && verdict.context.verified_cap > 0) {
+    if (!verdict.context.ok) {
+      // 0 = nothing verified: search projects the window as unverified rather than trusting the claim.
       await store.setObservation(nodeId, offering.offering_id, 'context_cap', verdict.context.verified_cap);
     }
 

package/src/store-pg.js

@@ -1,127 +1,127 @@
-// Postgres storage driver (production). Same async contract as the sqlite driver.
-// Accepts a connection string, or an injected pg-compatible Pool (DI for tests: pg-mem).
-import pg from 'pg';
-
-const SCHEMA = `
-  CREATE TABLE IF NOT EXISTS nodes (
-    id TEXT PRIMARY KEY, origin TEXT NOT NULL, card_url TEXT NOT NULL,
-    state TEXT NOT NULL, institutional INTEGER DEFAULT 0,
-    source TEXT NOT NULL DEFAULT 'registration',
-    created_at TEXT NOT NULL, updated_at TEXT NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS card_revisions (
-    node_id TEXT NOT NULL, revision TEXT NOT NULL, raw TEXT NOT NULL,
-    sig_ok INTEGER NOT NULL, fetched_at TEXT NOT NULL,
-    PRIMARY KEY (node_id, revision)
-  );
-  CREATE TABLE IF NOT EXISTS challenges (
-    node_id TEXT PRIMARY KEY, token TEXT NOT NULL, expires_at TEXT NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS probes (
-    id SERIAL PRIMARY KEY, node_id TEXT NOT NULL, offering_id TEXT,
-    stage TEXT NOT NULL, kind TEXT NOT NULL, ok INTEGER NOT NULL,
-    detail TEXT, measured TEXT, at TEXT NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS transitions (
-    id SERIAL PRIMARY KEY, node_id TEXT NOT NULL,
-    from_state TEXT, to_state TEXT NOT NULL, reason TEXT, at TEXT NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS fingerprints (
-    artifact TEXT NOT NULL, prompt TEXT NOT NULL, expected_hash TEXT NOT NULL,
-    PRIMARY KEY (artifact, prompt)
-  );
-  CREATE TABLE IF NOT EXISTS observations (
-    node_id TEXT NOT NULL, offering_id TEXT NOT NULL, key TEXT NOT NULL,
-    value TEXT NOT NULL, at TEXT NOT NULL,
-    PRIMARY KEY (node_id, offering_id, key)
-  );
-`;
-
-export async function createPgStore({ connectionString, pool } = {}) {
-  const p = pool ?? new pg.Pool({ connectionString, max: 10 });
-  for (const stmt of SCHEMA.split(';').map((s) => s.trim()).filter(Boolean)) {
-    await p.query(stmt);
-  }
-  const now = () => new Date().toISOString();
-  const q = async (text, params = []) => (await p.query(text, params)).rows;
-
-  return {
-    driver: 'postgres',
-    async upsertNode(id, origin, cardUrl, state, source = 'registration') {
-      await q(`INSERT INTO nodes (id, origin, card_url, state, source, created_at, updated_at)
-        VALUES ($1, $2, $3, $4, $5, $6, $7)
-        ON CONFLICT (id) DO UPDATE SET origin=excluded.origin, card_url=excluded.card_url,
-          source=excluded.source, updated_at=excluded.updated_at`,
-        [id, origin, cardUrl, state, source, now(), now()]);
-    },
-    async getNode(id) {
-      return (await q('SELECT * FROM nodes WHERE id = $1', [id]))[0];
-    },
-    async setState(id, toState, reason = null) {
-      const cur = await this.getNode(id);
-      await q('UPDATE nodes SET state = $1, updated_at = $2 WHERE id = $3', [toState, now(), id]);
-      await q('INSERT INTO transitions (node_id, from_state, to_state, reason, at) VALUES ($1, $2, $3, $4, $5)',
-        [id, cur?.state ?? null, toState, reason, now()]);
-    },
-    async saveRevision(nodeId, revision, card, sigOk) {
-      await q(`INSERT INTO card_revisions (node_id, revision, raw, sig_ok, fetched_at)
-        VALUES ($1, $2, $3, $4, $5)
-        ON CONFLICT (node_id, revision) DO UPDATE SET raw=excluded.raw,
-          sig_ok=excluded.sig_ok, fetched_at=excluded.fetched_at`,
-        [nodeId, revision, JSON.stringify(card), sigOk ? 1 : 0, now()]);
-    },
-    async latestCard(nodeId) {
-      const rows = await q('SELECT raw FROM card_revisions WHERE node_id = $1 ORDER BY revision DESC LIMIT 1', [nodeId]);
-      return rows[0] ? JSON.parse(rows[0].raw) : null;
-    },
-    async setChallenge(nodeId, token, ttlMs = 72 * 3600 * 1000) {
-      await q(`INSERT INTO challenges (node_id, token, expires_at) VALUES ($1, $2, $3)
-        ON CONFLICT (node_id) DO UPDATE SET token=excluded.token, expires_at=excluded.expires_at`,
-        [nodeId, token, new Date(Date.now() + ttlMs).toISOString()]);
-    },
-    async getChallenge(nodeId) {
-      const row = (await q('SELECT * FROM challenges WHERE node_id = $1', [nodeId]))[0];
-      if (!row || row.expires_at < now()) return null;
-      return row;
-    },
-    async recordProbe(nodeId, offeringId, stage, kind, ok, detail = null, measured = null) {
-      await q('INSERT INTO probes (node_id, offering_id, stage, kind, ok, detail, measured, at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)',
-        [nodeId, offeringId, stage, kind, ok ? 1 : 0, detail, measured ? JSON.stringify(measured) : null, now()]);
-    },
-    async probesFor(nodeId) {
-      return q('SELECT * FROM probes WHERE node_id = $1 ORDER BY id DESC LIMIT 100', [nodeId]);
-    },
-    async transitionsFor(nodeId) {
-      return q('SELECT * FROM transitions WHERE node_id = $1 ORDER BY id ASC', [nodeId]);
-    },
-    async allNodes() { return q('SELECT * FROM nodes'); },
-    async recentTransitions(limit = 50) {
-      return q(`SELECT t.*, n.source FROM transitions t
-        LEFT JOIN nodes n ON n.id = t.node_id ORDER BY t.id DESC LIMIT $1`, [limit]);
-    },
-    async addFingerprints(artifact, refs) {
-      for (const ref of refs) {
-        await q(`INSERT INTO fingerprints (artifact, prompt, expected_hash) VALUES ($1, $2, $3)
-          ON CONFLICT (artifact, prompt) DO UPDATE SET expected_hash=excluded.expected_hash`,
-          [artifact, ref.prompt, ref.expected_hash]);
-      }
-    },
-    async getFingerprints(artifact) {
-      return q('SELECT prompt, expected_hash FROM fingerprints WHERE artifact = $1', [artifact]);
-    },
-    async setObservation(nodeId, offeringId, key, value) {
-      await q(`INSERT INTO observations (node_id, offering_id, key, value, at) VALUES ($1, $2, $3, $4, $5)
-        ON CONFLICT (node_id, offering_id, key) DO UPDATE SET value=excluded.value, at=excluded.at`,
-        [nodeId, offeringId, key, JSON.stringify(value), now()]);
-    },
-    async getObservations(nodeId, offeringId) {
-      const rows = await q('SELECT key, value FROM observations WHERE node_id = $1 AND offering_id = $2', [nodeId, offeringId]);
-      return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
-    },
-    async observationsForNode(nodeId) {
-      const rows = await q('SELECT offering_id, key, value FROM observations WHERE node_id = $1', [nodeId]);
-      return rows.map((r) => ({ offering_id: r.offering_id, key: r.key, value: JSON.parse(r.value) }));
-    },
-    async close() { await p.end(); },
-  };
-}
+// Postgres storage driver (production). Same async contract as the sqlite driver.
+// Accepts a connection string, or an injected pg-compatible Pool (DI for tests: pg-mem).
+import pg from 'pg';
+
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS nodes (
+    id TEXT PRIMARY KEY, origin TEXT NOT NULL, card_url TEXT NOT NULL,
+    state TEXT NOT NULL, institutional INTEGER DEFAULT 0,
+    source TEXT NOT NULL DEFAULT 'registration',
+    created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS card_revisions (
+    node_id TEXT NOT NULL, revision TEXT NOT NULL, raw TEXT NOT NULL,
+    sig_ok INTEGER NOT NULL, fetched_at TEXT NOT NULL,
+    PRIMARY KEY (node_id, revision)
+  );
+  CREATE TABLE IF NOT EXISTS challenges (
+    node_id TEXT PRIMARY KEY, token TEXT NOT NULL, expires_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS probes (
+    id SERIAL PRIMARY KEY, node_id TEXT NOT NULL, offering_id TEXT,
+    stage TEXT NOT NULL, kind TEXT NOT NULL, ok INTEGER NOT NULL,
+    detail TEXT, measured TEXT, at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS transitions (
+    id SERIAL PRIMARY KEY, node_id TEXT NOT NULL,
+    from_state TEXT, to_state TEXT NOT NULL, reason TEXT, at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS fingerprints (
+    artifact TEXT NOT NULL, prompt TEXT NOT NULL, expected_hash TEXT NOT NULL,
+    PRIMARY KEY (artifact, prompt)
+  );
+  CREATE TABLE IF NOT EXISTS observations (
+    node_id TEXT NOT NULL, offering_id TEXT NOT NULL, key TEXT NOT NULL,
+    value TEXT NOT NULL, at TEXT NOT NULL,
+    PRIMARY KEY (node_id, offering_id, key)
+  );
+`;
+
+export async function createPgStore({ connectionString, pool } = {}) {
+  const p = pool ?? new pg.Pool({ connectionString, max: 10 });
+  for (const stmt of SCHEMA.split(';').map((s) => s.trim()).filter(Boolean)) {
+    await p.query(stmt);
+  }
+  const now = () => new Date().toISOString();
+  const q = async (text, params = []) => (await p.query(text, params)).rows;
+
+  return {
+    driver: 'postgres',
+    async upsertNode(id, origin, cardUrl, state, source = 'registration') {
+      await q(`INSERT INTO nodes (id, origin, card_url, state, source, created_at, updated_at)
+        VALUES ($1, $2, $3, $4, $5, $6, $7)
+        ON CONFLICT (id) DO UPDATE SET origin=excluded.origin, card_url=excluded.card_url,
+          source=excluded.source, updated_at=excluded.updated_at`,
+        [id, origin, cardUrl, state, source, now(), now()]);
+    },
+    async getNode(id) {
+      return (await q('SELECT * FROM nodes WHERE id = $1', [id]))[0];
+    },
+    async setState(id, toState, reason = null) {
+      const cur = await this.getNode(id);
+      await q('UPDATE nodes SET state = $1, updated_at = $2 WHERE id = $3', [toState, now(), id]);
+      await q('INSERT INTO transitions (node_id, from_state, to_state, reason, at) VALUES ($1, $2, $3, $4, $5)',
+        [id, cur?.state ?? null, toState, reason, now()]);
+    },
+    async saveRevision(nodeId, revision, card, sigOk) {
+      await q(`INSERT INTO card_revisions (node_id, revision, raw, sig_ok, fetched_at)
+        VALUES ($1, $2, $3, $4, $5)
+        ON CONFLICT (node_id, revision) DO UPDATE SET raw=excluded.raw,
+          sig_ok=excluded.sig_ok, fetched_at=excluded.fetched_at`,
+        [nodeId, revision, JSON.stringify(card), sigOk ? 1 : 0, now()]);
+    },
+    async latestCard(nodeId) {
+      const rows = await q('SELECT raw FROM card_revisions WHERE node_id = $1 ORDER BY revision DESC LIMIT 1', [nodeId]);
+      return rows[0] ? JSON.parse(rows[0].raw) : null;
+    },
+    async setChallenge(nodeId, token, ttlMs = 72 * 3600 * 1000) {
+      await q(`INSERT INTO challenges (node_id, token, expires_at) VALUES ($1, $2, $3)
+        ON CONFLICT (node_id) DO UPDATE SET token=excluded.token, expires_at=excluded.expires_at`,
+        [nodeId, token, new Date(Date.now() + ttlMs).toISOString()]);
+    },
+    async getChallenge(nodeId) {
+      const row = (await q('SELECT * FROM challenges WHERE node_id = $1', [nodeId]))[0];
+      if (!row || row.expires_at < now()) return null;
+      return row;
+    },
+    async recordProbe(nodeId, offeringId, stage, kind, ok, detail = null, measured = null) {
+      await q('INSERT INTO probes (node_id, offering_id, stage, kind, ok, detail, measured, at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)',
+        [nodeId, offeringId, stage, kind, ok ? 1 : 0, detail, measured ? JSON.stringify(measured) : null, now()]);
+    },
+    async probesFor(nodeId) {
+      return q('SELECT * FROM probes WHERE node_id = $1 ORDER BY id DESC LIMIT 100', [nodeId]);
+    },
+    async transitionsFor(nodeId) {
+      return q('SELECT * FROM transitions WHERE node_id = $1 ORDER BY id ASC', [nodeId]);
+    },
+    async allNodes() { return q('SELECT * FROM nodes'); },
+    async recentTransitions(limit = 50) {
+      return q(`SELECT t.*, n.source FROM transitions t
+        LEFT JOIN nodes n ON n.id = t.node_id ORDER BY t.id DESC LIMIT $1`, [limit]);
+    },
+    async addFingerprints(artifact, refs) {
+      for (const ref of refs) {
+        await q(`INSERT INTO fingerprints (artifact, prompt, expected_hash) VALUES ($1, $2, $3)
+          ON CONFLICT (artifact, prompt) DO UPDATE SET expected_hash=excluded.expected_hash`,
+          [artifact, ref.prompt, ref.expected_hash]);
+      }
+    },
+    async getFingerprints(artifact) {
+      return q('SELECT prompt, expected_hash FROM fingerprints WHERE artifact = $1', [artifact]);
+    },
+    async setObservation(nodeId, offeringId, key, value) {
+      await q(`INSERT INTO observations (node_id, offering_id, key, value, at) VALUES ($1, $2, $3, $4, $5)
+        ON CONFLICT (node_id, offering_id, key) DO UPDATE SET value=excluded.value, at=excluded.at`,
+        [nodeId, offeringId, key, JSON.stringify(value), now()]);
+    },
+    async getObservations(nodeId, offeringId) {
+      const rows = await q('SELECT key, value FROM observations WHERE node_id = $1 AND offering_id = $2', [nodeId, offeringId]);
+      return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+    },
+    async observationsForNode(nodeId) {
+      const rows = await q('SELECT offering_id, key, value FROM observations WHERE node_id = $1', [nodeId]);
+      return rows.map((r) => ({ offering_id: r.offering_id, key: r.key, value: JSON.parse(r.value) }));
+    },
+    async close() { await p.end(); },
+  };
+}

package/src/store.js

@@ -1,126 +1,126 @@
-// Registry storage. The async store API is the seam between drivers:
-// - sqlite (node:sqlite): zero-setup dev/tests, file or :memory:
-// - postgres (store-pg.js): production, selected by a postgres:// URL
-// Every method is async so both drivers present the identical contract.
-import { DatabaseSync } from 'node:sqlite';
-
-/** config: ':memory:' | sqlite file path | postgres:// URL */
-export async function createStore(config = ':memory:') {
-  if (typeof config === 'string' && /^postgres(ql)?:\/\//.test(config)) {
-    const { createPgStore } = await import('./store-pg.js');
-    return createPgStore({ connectionString: config });
-  }
-  return createSqliteStore(config);
-}
-
-export async function createSqliteStore(path = ':memory:') {
-  const db = new DatabaseSync(path);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS nodes (
-      id TEXT PRIMARY KEY, origin TEXT NOT NULL, card_url TEXT NOT NULL,
-      state TEXT NOT NULL, institutional INTEGER DEFAULT 0,
-      source TEXT NOT NULL DEFAULT 'registration',
-      created_at TEXT NOT NULL, updated_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS card_revisions (
-      node_id TEXT NOT NULL, revision TEXT NOT NULL, raw TEXT NOT NULL,
-      sig_ok INTEGER NOT NULL, fetched_at TEXT NOT NULL,
-      PRIMARY KEY (node_id, revision)
-    );
-    CREATE TABLE IF NOT EXISTS challenges (
-      node_id TEXT PRIMARY KEY, token TEXT NOT NULL, expires_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS probes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT, node_id TEXT NOT NULL, offering_id TEXT,
-      stage TEXT NOT NULL, kind TEXT NOT NULL, ok INTEGER NOT NULL,
-      detail TEXT, measured TEXT, at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS transitions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT, node_id TEXT NOT NULL,
-      from_state TEXT, to_state TEXT NOT NULL, reason TEXT, at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS fingerprints (
-      artifact TEXT NOT NULL, prompt TEXT NOT NULL, expected_hash TEXT NOT NULL,
-      PRIMARY KEY (artifact, prompt)
-    );
-    CREATE TABLE IF NOT EXISTS observations (
-      node_id TEXT NOT NULL, offering_id TEXT NOT NULL, key TEXT NOT NULL,
-      value TEXT NOT NULL, at TEXT NOT NULL,
-      PRIMARY KEY (node_id, offering_id, key)
-    );
-  `);
-
-  const now = () => new Date().toISOString();
-
-  return {
-    driver: 'sqlite',
-    async upsertNode(id, origin, cardUrl, state, source = 'registration') {
-      db.prepare(`INSERT INTO nodes (id, origin, card_url, state, source, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(id) DO UPDATE SET origin=excluded.origin, card_url=excluded.card_url,
-          source=excluded.source, updated_at=excluded.updated_at`)
-        .run(id, origin, cardUrl, state, source, now(), now());
-    },
-    async getNode(id) { return db.prepare('SELECT * FROM nodes WHERE id = ?').get(id); },
-    async setState(id, toState, reason = null) {
-      const cur = await this.getNode(id);
-      db.prepare('UPDATE nodes SET state = ?, updated_at = ? WHERE id = ?').run(toState, now(), id);
-      db.prepare('INSERT INTO transitions (node_id, from_state, to_state, reason, at) VALUES (?, ?, ?, ?, ?)')
-        .run(id, cur?.state ?? null, toState, reason, now());
-    },
-    async saveRevision(nodeId, revision, card, sigOk) {
-      db.prepare(`INSERT OR REPLACE INTO card_revisions (node_id, revision, raw, sig_ok, fetched_at)
-        VALUES (?, ?, ?, ?, ?)`).run(nodeId, revision, JSON.stringify(card), sigOk ? 1 : 0, now());
-    },
-    async latestCard(nodeId) {
-      const row = db.prepare('SELECT raw FROM card_revisions WHERE node_id = ? ORDER BY revision DESC LIMIT 1').get(nodeId);
-      return row ? JSON.parse(row.raw) : null;
-    },
-    async setChallenge(nodeId, token, ttlMs = 72 * 3600 * 1000) {
-      db.prepare('INSERT OR REPLACE INTO challenges (node_id, token, expires_at) VALUES (?, ?, ?)')
-        .run(nodeId, token, new Date(Date.now() + ttlMs).toISOString());
-    },
-    async getChallenge(nodeId) {
-      const row = db.prepare('SELECT * FROM challenges WHERE node_id = ?').get(nodeId);
-      if (!row || row.expires_at < now()) return null;
-      return row;
-    },
-    async recordProbe(nodeId, offeringId, stage, kind, ok, detail = null, measured = null) {
-      db.prepare('INSERT INTO probes (node_id, offering_id, stage, kind, ok, detail, measured, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
-        .run(nodeId, offeringId, stage, kind, ok ? 1 : 0, detail, measured ? JSON.stringify(measured) : null, now());
-    },
-    async probesFor(nodeId) {
-      return db.prepare('SELECT * FROM probes WHERE node_id = ? ORDER BY id DESC LIMIT 100').all(nodeId);
-    },
-    async transitionsFor(nodeId) {
-      return db.prepare('SELECT * FROM transitions WHERE node_id = ? ORDER BY id ASC').all(nodeId);
-    },
-    async allNodes() { return db.prepare('SELECT * FROM nodes').all(); },
-    async recentTransitions(limit = 50) {
-      return db.prepare(`SELECT t.*, n.source FROM transitions t
-        LEFT JOIN nodes n ON n.id = t.node_id ORDER BY t.id DESC LIMIT ?`).all(limit);
-    },
-    async addFingerprints(artifact, refs) {
-      for (const ref of refs) {
-        db.prepare('INSERT OR REPLACE INTO fingerprints (artifact, prompt, expected_hash) VALUES (?, ?, ?)')
-          .run(artifact, ref.prompt, ref.expected_hash);
-      }
-    },
-    async getFingerprints(artifact) {
-      return db.prepare('SELECT prompt, expected_hash FROM fingerprints WHERE artifact = ?').all(artifact);
-    },
-    async setObservation(nodeId, offeringId, key, value) {
-      db.prepare('INSERT OR REPLACE INTO observations (node_id, offering_id, key, value, at) VALUES (?, ?, ?, ?, ?)')
-        .run(nodeId, offeringId, key, JSON.stringify(value), now());
-    },
-    async getObservations(nodeId, offeringId) {
-      const rows = db.prepare('SELECT key, value FROM observations WHERE node_id = ? AND offering_id = ?').all(nodeId, offeringId);
-      return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
-    },
-    async observationsForNode(nodeId) {
-      const rows = db.prepare('SELECT offering_id, key, value FROM observations WHERE node_id = ?').all(nodeId);
-      return rows.map((r) => ({ offering_id: r.offering_id, key: r.key, value: JSON.parse(r.value) }));
-    },
-    async close() { db.close(); },
-  };
-}
+// Registry storage. The async store API is the seam between drivers:
+// - sqlite (node:sqlite): zero-setup dev/tests, file or :memory:
+// - postgres (store-pg.js): production, selected by a postgres:// URL
+// Every method is async so both drivers present the identical contract.
+import { DatabaseSync } from 'node:sqlite';
+
+/** config: ':memory:' | sqlite file path | postgres:// URL */
+export async function createStore(config = ':memory:') {
+  if (typeof config === 'string' && /^postgres(ql)?:\/\//.test(config)) {
+    const { createPgStore } = await import('./store-pg.js');
+    return createPgStore({ connectionString: config });
+  }
+  return createSqliteStore(config);
+}
+
+export async function createSqliteStore(path = ':memory:') {
+  const db = new DatabaseSync(path);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS nodes (
+      id TEXT PRIMARY KEY, origin TEXT NOT NULL, card_url TEXT NOT NULL,
+      state TEXT NOT NULL, institutional INTEGER DEFAULT 0,
+      source TEXT NOT NULL DEFAULT 'registration',
+      created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS card_revisions (
+      node_id TEXT NOT NULL, revision TEXT NOT NULL, raw TEXT NOT NULL,
+      sig_ok INTEGER NOT NULL, fetched_at TEXT NOT NULL,
+      PRIMARY KEY (node_id, revision)
+    );
+    CREATE TABLE IF NOT EXISTS challenges (
+      node_id TEXT PRIMARY KEY, token TEXT NOT NULL, expires_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS probes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, node_id TEXT NOT NULL, offering_id TEXT,
+      stage TEXT NOT NULL, kind TEXT NOT NULL, ok INTEGER NOT NULL,
+      detail TEXT, measured TEXT, at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS transitions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, node_id TEXT NOT NULL,
+      from_state TEXT, to_state TEXT NOT NULL, reason TEXT, at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS fingerprints (
+      artifact TEXT NOT NULL, prompt TEXT NOT NULL, expected_hash TEXT NOT NULL,
+      PRIMARY KEY (artifact, prompt)
+    );
+    CREATE TABLE IF NOT EXISTS observations (
+      node_id TEXT NOT NULL, offering_id TEXT NOT NULL, key TEXT NOT NULL,
+      value TEXT NOT NULL, at TEXT NOT NULL,
+      PRIMARY KEY (node_id, offering_id, key)
+    );
+  `);
+
+  const now = () => new Date().toISOString();
+
+  return {
+    driver: 'sqlite',
+    async upsertNode(id, origin, cardUrl, state, source = 'registration') {
+      db.prepare(`INSERT INTO nodes (id, origin, card_url, state, source, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET origin=excluded.origin, card_url=excluded.card_url,
+          source=excluded.source, updated_at=excluded.updated_at`)
+        .run(id, origin, cardUrl, state, source, now(), now());
+    },
+    async getNode(id) { return db.prepare('SELECT * FROM nodes WHERE id = ?').get(id); },
+    async setState(id, toState, reason = null) {
+      const cur = await this.getNode(id);
+      db.prepare('UPDATE nodes SET state = ?, updated_at = ? WHERE id = ?').run(toState, now(), id);
+      db.prepare('INSERT INTO transitions (node_id, from_state, to_state, reason, at) VALUES (?, ?, ?, ?, ?)')
+        .run(id, cur?.state ?? null, toState, reason, now());
+    },
+    async saveRevision(nodeId, revision, card, sigOk) {
+      db.prepare(`INSERT OR REPLACE INTO card_revisions (node_id, revision, raw, sig_ok, fetched_at)
+        VALUES (?, ?, ?, ?, ?)`).run(nodeId, revision, JSON.stringify(card), sigOk ? 1 : 0, now());
+    },
+    async latestCard(nodeId) {
+      const row = db.prepare('SELECT raw FROM card_revisions WHERE node_id = ? ORDER BY revision DESC LIMIT 1').get(nodeId);
+      return row ? JSON.parse(row.raw) : null;
+    },
+    async setChallenge(nodeId, token, ttlMs = 72 * 3600 * 1000) {
+      db.prepare('INSERT OR REPLACE INTO challenges (node_id, token, expires_at) VALUES (?, ?, ?)')
+        .run(nodeId, token, new Date(Date.now() + ttlMs).toISOString());
+    },
+    async getChallenge(nodeId) {
+      const row = db.prepare('SELECT * FROM challenges WHERE node_id = ?').get(nodeId);
+      if (!row || row.expires_at < now()) return null;
+      return row;
+    },
+    async recordProbe(nodeId, offeringId, stage, kind, ok, detail = null, measured = null) {
+      db.prepare('INSERT INTO probes (node_id, offering_id, stage, kind, ok, detail, measured, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+        .run(nodeId, offeringId, stage, kind, ok ? 1 : 0, detail, measured ? JSON.stringify(measured) : null, now());
+    },
+    async probesFor(nodeId) {
+      return db.prepare('SELECT * FROM probes WHERE node_id = ? ORDER BY id DESC LIMIT 100').all(nodeId);
+    },
+    async transitionsFor(nodeId) {
+      return db.prepare('SELECT * FROM transitions WHERE node_id = ? ORDER BY id ASC').all(nodeId);
+    },
+    async allNodes() { return db.prepare('SELECT * FROM nodes').all(); },
+    async recentTransitions(limit = 50) {
+      return db.prepare(`SELECT t.*, n.source FROM transitions t
+        LEFT JOIN nodes n ON n.id = t.node_id ORDER BY t.id DESC LIMIT ?`).all(limit);
+    },
+    async addFingerprints(artifact, refs) {
+      for (const ref of refs) {
+        db.prepare('INSERT OR REPLACE INTO fingerprints (artifact, prompt, expected_hash) VALUES (?, ?, ?)')
+          .run(artifact, ref.prompt, ref.expected_hash);
+      }
+    },
+    async getFingerprints(artifact) {
+      return db.prepare('SELECT prompt, expected_hash FROM fingerprints WHERE artifact = ?').all(artifact);
+    },
+    async setObservation(nodeId, offeringId, key, value) {
+      db.prepare('INSERT OR REPLACE INTO observations (node_id, offering_id, key, value, at) VALUES (?, ?, ?, ?, ?)')
+        .run(nodeId, offeringId, key, JSON.stringify(value), now());
+    },
+    async getObservations(nodeId, offeringId) {
+      const rows = db.prepare('SELECT key, value FROM observations WHERE node_id = ? AND offering_id = ?').all(nodeId, offeringId);
+      return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+    },
+    async observationsForNode(nodeId) {
+      const rows = db.prepare('SELECT offering_id, key, value FROM observations WHERE node_id = ?').all(nodeId);
+      return rows.map((r) => ({ offering_id: r.offering_id, key: r.key, value: JSON.parse(r.value) }));
+    },
+    async close() { db.close(); },
+  };
+}