sparda-mcp 0.9.0 → 0.10.1

package/README.md

@@ -84,6 +84,30 @@ To output raw JSON for integration:
 npx sparda-mcp report --json
 ```
 
+## Deployment Proof: Apocalypse
+
+SPARDA's Behavior Graph is a formal model of your system. Instead of waiting for runtime failures or relying on static analysis vibes, you can statically prove the safety of your backend before any deployment:
+```bash
+npx sparda-mcp apocalypse
+```
+This command reads the compiled `.sparda/ubg.json` (with zero source code parsing at runtime) and discharges five static correctness obligations:
+* **Unguarded Mutation (Critical)**: Flags any mutation path that does not cross a security `guard`.
+* **Non-Atomic Aggregate Write (High)**: Flags when an API writes to multiple tables of the same Consistency Domain (Aggregate) outside a single transaction scope.
+* **Unvalidated Constrained Write (Medium)**: Flags writes into columns with SQL invariants (CHECK, NOT NULL, UNIQUE) without prior validation (Zod/Pydantic).
+* **Irreversible Observable Effect (High)**: Flags out-of-process actions (like Stripe charges) that happen alongside state writes without a structural compensation path (like a catch-refund).
+* **Aggregate Member Bypass (Info)**: Flags mutating a member table directly without routing through the aggregate root.
+
+To save your current graph as a safe baseline:
+```bash
+npx sparda-mcp apocalypse --save-baseline
+```
+Subsequent runs will diff the candidate graph against this baseline to detect regression vectors:
+* Deletion of any security `guard` (Critical).
+* Deletion of a database SQL invariant (High).
+* API blast radius expansion (Medium).
+
+If any Critical or High finding is found, `apocalypse` exits with a non-zero code to block your CI pipeline.
+
 To undo everything: **`npx sparda-mcp remove`** restores your code byte-for-byte.
 
 ## The promise — every word is backed by a test in CI

package/SKILL.md

@@ -1,40 +1,30 @@
 ---
 name: sparda-mcp
 description: >-
-  Drive a SPARDA-generated MCP server to its full potential. Use this whenever
-  you are connected to an MCP server built by SPARDA (sparda-mcp) — recognizable
-  by the tools `sparda_get_context`, `sparda_info`, `sparda_confirm`, or composite
-  tools labelled "[Labs circuit]". It teaches the call-context-first workflow, how
-  to exploit the response-recycling flywheel, the circuit-breaker, crystallized
-  circuits and adaptive immunity, and the mandatory two-phase confirm protocol for
-  write tools. Reach for it before calling raw endpoints, before any write, or when
-  a tool returns 202 (awaiting confirmation) or 503 (quarantined).
+  Drive a SPARDA compiled Behavior Runtime to its full potential. Use this whenever
+  you are connected to a backend running the SPARDA Runtime (compiled into a SPARDA
+  Behavior Graph - SBG) — recognizable by the tools `sparda_get_context`, `sparda_info`,
+  `sparda_confirm`, or composite tools. It teaches the graph-context-first workflow,
+  how to exploit the response-recycling flywheel, the circuit-breaker, crystallized
+  circuits, offline Twin simulations, and the two-phase confirm protocol for writes.
 ---
 
-# Driving a SPARDA MCP server
+# Driving a SPARDA Behavior Runtime
 
-A SPARDA server is **not** a flat list of HTTP endpoints. SPARDA injected a live
-`/mcp` router *inside a real running app*, so its tools are that app's actual
-routes — wrapped in an intelligence layer that makes repeated use **cheaper** (it
-recycles stable answers from memory) and **safer** (it quarantines failing tools
-and gates writes behind human confirmation). Used naively it's just an API. Used
-well, it gets faster and safer the more you call it. This skill is how to use it
-well.
+A SPARDA server is driven by a compiled **SPARDA Behavior Graph (SBG)**. Instead of exposing raw, disconnected endpoints, SPARDA has compiled the host application's states, transitions, permissions, and side-effects into a deterministic behavioral model. The local **SPARDA Runtime** dynamically executes this graph inside the live host process, powering the MCP interface, the Twin simulation clone, and the Immune system offline.
 
 ## Rule 0 — call `sparda_get_context` first, every session
 
-Before anything else, call **`sparda_get_context`** (no params). It returns the
-*live* picture, so you never guess the surface:
+Before anything else, call **`sparda_get_context`** (no params). It returns the *live* state of the SPARDA Behavior Graph:
 
-- the enabled tools + their descriptions, and SPARDA's suggested **workflows**;
-- `runtime` — current `/mcp/stats` (per-tool call/error counts, tool "purity",
-  quarantine state);
-- the last ~20 **events** (errors, latency anomalies, immune diagnoses);
-- **immune memory** (known failure signatures + cached fixes);
-- **recycling** stats (how many calls were served from memory);
-- a `behavior` snapshot (which response fields are stable).
+- the active routes/tools, workflows, and type-propagated schemas;
+- `runtime` — current stats (calls, errors, quarantine states, Twin mode active);
+- the last ~20 **events** (errors, latency anomalies, immune alerts);
+- **immune memory** (cached antibodies and error diagnoses);
+- **recycling** metrics (flywheel memory hit rates);
+- a `behavior` snapshot of stable variables.
 
-Read it before acting. `sparda_info` gives a lighter summary if you only need counts.
+Read it to orient yourself inside the graph. `sparda_info` gives a lighter summary of counts.
 
 ## The tools you'll see
 
@@ -146,6 +136,7 @@ Writes are **disabled by default**. The protocol is not optional:
 - **General health** → `sparda doctor` checks Node version, framework detection,
   manifest validity, the semantic/immune cache, host reachability, and quarantine;
   it exits non-zero so it can gate CI.
+- **Formal Deployment Proof** → `sparda apocalypse` reads the compiled graph (`ubg.json`) and proves five correctness obligations: catches unguarded mutations, non-atomic aggregate writes, unvalidated writes to constrained tables, uncompensated observable effects, and aggregate root bypasses. Run `sparda apocalypse --save-baseline` to store the reference graph; subsequent runs diff against the baseline to catch dropped guards, dropped SQL invariants, or grown blast radiuses.
 - **Clone learning / Transfer sémantique** → Use `sparda seed export` to package your app's descriptions, workflows, and antibodies. Then `sparda seed import --germinate` in another clone to import the structure and germinate simulated twin instances.
 - **Learn exemplars** → Start your live app and run `sparda twin --learn` to fetch actual response data and construct `.sparda/twin.json` locally.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparda-mcp",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "mcpName": "io.github.zyx77550/sparda-mcp",
   "description": "Turn any codebase into an MCP server with one command. Express & FastAPI → Claude-ready in 3 minutes.",
   "type": "module",

package/src/commands/timeless.js

@@ -0,0 +1,187 @@
+// commands/timeless.js — production bugs become unit tests.
+//   sparda timeless                 list recorded flights
+//   sparda timeless replay <id>     re-fly the request against current code
+//   sparda timeless export <id>     generate a vitest test that replays it
+// Recording side: mount the recorder in the app (2 lines, documented in the
+// README) — `const flight = createFlightBox(); app.use(flight.middleware())`.
+// Replay imports the real entry file with `listen()` suppressed, feeds every
+// recorded tap back in strict order, and compares the response byte-for-byte.
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import { pathToFileURL } from 'node:url';
+import { detectStack } from '../detect.js';
+import { getFlightBox } from '../flight/box.js';
+import { replayFlight } from '../flight/replayer.js';
+import { listFlights, loadFlight } from '../flight/format.js';
+import { atomicWriteFileSync as atomicWrite } from '../server/persistence.js';
+
+const err = (message, hint) => Object.assign(new Error(message), { code: 'USER', hint });
+
+export async function runTimeless(opts, args) {
+  const [sub, id] = args.filter((a) => !a.startsWith('--'));
+
+  if (!sub || sub === 'list') return list(opts);
+  if (sub === 'replay') return replay(opts, requireId(id));
+  if (sub === 'export') return exportTest(opts, requireId(id));
+  throw err(
+    `unknown timeless subcommand "${sub}"`,
+    'use: list | replay <id> | export <id>',
+  );
+}
+
+const requireId = (id) => {
+  if (!id) throw err('flight id required', 'run `sparda timeless` to list flights');
+  return id;
+};
+
+function list(opts) {
+  const flights = listFlights(opts.cwd);
+  if (!flights.length) {
+    console.log(
+      'No flights recorded. Mount the recorder in your app (ESM):\n' +
+        "  import { getFlightBox } from 'sparda-mcp/src/flight/box.js';\n" +
+        '  const box = getFlightBox(); box.arm();\n' +
+        '  app.use(box.middleware());\n' +
+        '  const db = box.wrapClient(rawDb); // your query client\n' +
+        "  (CJS: const { getFlightBox } = await import('sparda-mcp/src/flight/box.js'))",
+    );
+    return { flights };
+  }
+  console.log(`${flights.length} flight(s) in .sparda/flight/`);
+  for (const f of flights) {
+    const { request, response } = loadFlight(opts.cwd, f);
+    console.log(
+      `  ${f}  ${request.method} ${request.url} → ${response.status} (${response.body.length}b, ${loadFlight(opts.cwd, f).taps.length} taps)`,
+    );
+  }
+  return { flights };
+}
+
+async function replay(opts, id) {
+  const flight = loadFlight(opts.cwd, id);
+  // the SHARED box: if the app integrates the recorder, its wrapClient rides
+  // the same AsyncLocalStorage this replay store lands on — load it BEFORE
+  // the app so both resolve the singleton
+  const box = getFlightBox();
+  const app = await loadApp(opts.cwd);
+  box.arm();
+  let result;
+  try {
+    result = await replayFlight(app, flight, box);
+  } finally {
+    box.disarm();
+  }
+
+  console.log(
+    `TIMELESS — replaying ${flight.request.method} ${flight.request.url} (${flight.taps.length} taps virtualized)`,
+  );
+  if (result.match) {
+    console.log(
+      `✓ byte-identical replay — status ${result.actual.status}, every tap consumed, zero divergence`,
+    );
+  } else {
+    if (!result.statusMatch)
+      console.log(
+        `  ✗ status: expected ${result.expected.status}, got ${result.actual.status}`,
+      );
+    if (!result.bodyMatch)
+      console.log(
+        `  ✗ body differs\n    expected: ${result.expected.body.slice(0, 200)}\n    actual:   ${result.actual.body.slice(0, 200)}`,
+      );
+    for (const d of result.divergences)
+      console.log(
+        `  ✗ divergence: expected ${d.kind} "${d.expected}", code asked "${d.got}"`,
+      );
+    for (const l of result.leftover)
+      console.log(
+        `  ✗ ${l.unconsumed} unconsumed ${l.kind} tap(s) — the code skipped step(s)`,
+      );
+    console.log(
+      '✗ NOT identical — the code no longer does what it did during the flight',
+    );
+    process.exitCode = 1;
+  }
+  return { result };
+}
+
+async function exportTest(opts, id) {
+  const flight = loadFlight(opts.cwd, id);
+  const stack = detectStack(opts.cwd);
+  if (stack.framework !== 'express')
+    throw err(
+      'timeless export supports Express apps in v1',
+      'FastAPI replay is a later round',
+    );
+
+  const testDir = path.join(opts.cwd, 'tests');
+  fs.mkdirSync(testDir, { recursive: true });
+  const testFile = path.join(testDir, `flight-${id}.test.js`);
+  const relEntry = path
+    .relative(testDir, path.resolve(opts.cwd, stack.entryFile))
+    .split(path.sep)
+    .join('/');
+
+  atomicWrite(
+    testFile,
+    `// flight-${id}.test.js — generated by \`sparda timeless export ${id}\`
+// Replays a recorded production request against the current code. A failure
+// means the behavior changed: if the change is the intended fix, re-record
+// the flight and re-export — this file asserts the PAST, on purpose.
+import { describe, it, expect } from 'vitest';
+import { getFlightBox } from 'sparda-mcp/src/flight/box.js';
+import { replayFlight } from 'sparda-mcp/src/flight/replayer.js';
+import { loadFlight } from 'sparda-mcp/src/flight/format.js';
+import appModule from '${relEntry.startsWith('.') ? relEntry : './' + relEntry}';
+
+describe('flight ${id} — ${flight.request.method} ${flight.request.url}', () => {
+  it('replays byte-identically', async () => {
+    const app = appModule.default ?? appModule;
+    const flight = loadFlight(process.cwd(), '${id}');
+    // the SHARED box — the app's own wrapClient must see the replay store
+    const box = getFlightBox();
+    box.arm();
+    try {
+      const result = await replayFlight(app, flight, box);
+      expect(result.divergences).toEqual([]);
+      expect(result.actual.status).toBe(result.expected.status);
+      expect(result.bodyMatch).toBe(true);
+      expect(result.leftover).toEqual([]);
+    } finally {
+      box.disarm();
+    }
+  });
+});
+`,
+  );
+  console.log(`✓ Test written: tests/flight-${id}.test.js — the bug is now a unit test`);
+  return { testFile };
+}
+
+// import the real entry with listen() suppressed — replay never binds ports
+async function loadApp(cwd) {
+  const stack = detectStack(cwd);
+  if (stack.framework !== 'express')
+    throw err(
+      'timeless replay supports Express apps in v1',
+      'FastAPI replay is a later round',
+    );
+  const origListen = http.Server.prototype.listen;
+  http.Server.prototype.listen = function suppressedListen(...args) {
+    const cb = args.find((a) => typeof a === 'function');
+    if (cb) setImmediate(cb);
+    return this;
+  };
+  try {
+    const mod = await import(pathToFileURL(path.resolve(cwd, stack.entryFile)).href);
+    const app = mod.default ?? mod;
+    if (typeof app !== 'function')
+      throw err(
+        'the entry file does not export the Express app',
+        'add `module.exports = app` (CJS) or `export default app` (ESM) to your entry',
+      );
+    return app;
+  } finally {
+    http.Server.prototype.listen = origListen;
+  }
+}

package/src/commands/ubg.js

@@ -44,7 +44,16 @@ export async function runUbg(opts) {
       console.log(
         `  ${p.pass}: ${names.length} domain(s) — ${names.join(', ')}${p.cycles.length ? ` (⚠ FK cycle: ${p.cycles.join(', ')})` : ''}`,
       );
-    }
+    } else if (p.pass === 'CapabilityExtraction' && p.capabilities)
+      console.log(
+        `  ${p.pass}: ${p.capabilities} capability(ies), ${p.guardsAnnotated} guard(s) annotated`,
+      );
+    else if (p.pass === 'ResourceLifetimes' && p.annotated)
+      console.log(
+        `  ${p.pass}: ${p.annotated} state(s)${p.immortal.length ? ` — immortal: ${p.immortal.join(', ')}` : ''}`,
+      );
+    else if (p.pass === 'StateMachineInference' && p.machines)
+      console.log(`  ${p.pass}: ${p.machines} machine(s) inferred`);
   }
 
   if (report.link.inferredTables.length)

package/src/flight/box.js

@@ -0,0 +1,245 @@
+// flight/box.js — the FlightBox: one set of patches, two modes.
+// In RECORD mode every nondeterminism point (fetch, Date.now, Math.random,
+// crypto.randomUUID, wrapped db clients) passes through to reality and leaves
+// a tap behind. In REPLAY mode the same points are fed the recorded values in
+// strict FIFO order per kind — label-checked, fail-loud: any mismatch is a
+// FlightDivergence, never a silent fuzzy match. Code OUTSIDE a request
+// context is untouched (AsyncLocalStorage decides), so arming the box in
+// production changes nothing for non-instrumented paths.
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { saveFlight } from './format.js';
+
+const MAX_BODY_BYTES = 262144; // 256 KB per recorded http body — bounded flights
+
+export class FlightDivergence extends Error {
+  constructor(message, detail = {}) {
+    super(message);
+    this.name = 'FlightDivergence';
+    this.detail = detail;
+  }
+}
+
+export function createFlightBox() {
+  const als = new AsyncLocalStorage();
+  const originals = {};
+  let armed = false;
+
+  function arm() {
+    if (armed) return;
+    armed = true;
+    originals.fetch = globalThis.fetch;
+    originals.dateNow = Date.now;
+    originals.random = Math.random;
+    originals.randomUUID = globalThis.crypto?.randomUUID?.bind(globalThis.crypto);
+
+    Date.now = function spardaDateNow() {
+      const store = als.getStore();
+      if (!store) return originals.dateNow();
+      if (store.mode === 'record') {
+        const v = originals.dateNow();
+        tapOut(store, 'time', 'Date.now', v);
+        return v;
+      }
+      return takeTap(store, 'time', 'Date.now');
+    };
+
+    Math.random = function spardaRandom() {
+      const store = als.getStore();
+      if (!store) return originals.random();
+      if (store.mode === 'record') {
+        const v = originals.random();
+        tapOut(store, 'random', 'Math.random', v);
+        return v;
+      }
+      return takeTap(store, 'random', 'Math.random');
+    };
+
+    if (originals.randomUUID) {
+      Object.defineProperty(globalThis.crypto, 'randomUUID', {
+        configurable: true,
+        value: function spardaRandomUUID() {
+          const store = als.getStore();
+          if (!store) return originals.randomUUID();
+          if (store.mode === 'record') {
+            const v = originals.randomUUID();
+            tapOut(store, 'uuid', 'crypto.randomUUID', v);
+            return v;
+          }
+          return takeTap(store, 'uuid', 'crypto.randomUUID');
+        },
+      });
+    }
+
+    globalThis.fetch = async function spardaFetch(input, init) {
+      const store = als.getStore();
+      if (!store) return originals.fetch(input, init);
+      const url = typeof input === 'string' ? input : (input?.url ?? String(input));
+      const method = (init?.method ?? 'GET').toUpperCase();
+      const label = `${method} ${url}`;
+      if (store.mode === 'record') {
+        const res = await originals.fetch(input, init);
+        const text = (await res.text()).slice(0, MAX_BODY_BYTES);
+        const headers = { 'content-type': res.headers.get('content-type') ?? '' };
+        tapOut(store, 'http', label, { status: res.status, headers, body: text });
+        return new Response(text, { status: res.status, headers });
+      }
+      const rec = takeTap(store, 'http', label);
+      return new Response(rec.body, { status: rec.status, headers: rec.headers });
+    };
+  }
+
+  function disarm() {
+    if (!armed) return;
+    armed = false;
+    globalThis.fetch = originals.fetch;
+    Date.now = originals.dateNow;
+    Math.random = originals.random;
+    if (originals.randomUUID)
+      Object.defineProperty(globalThis.crypto, 'randomUUID', {
+        configurable: true,
+        value: originals.randomUUID,
+      });
+  }
+
+  // any client exposing .query()/.execute() — pg, mysql2, sqlite wrappers …
+  function wrapClient(client, name = 'db') {
+    const wrapMethod = (method) =>
+      async function spardaQuery(...args) {
+        const store = als.getStore();
+        if (!store) return client[method](...args);
+        const label = `${name}.${method}:${String(args[0]).slice(0, 60)}`;
+        if (store.mode === 'record') {
+          const result = await client[method](...args);
+          tapOut(store, 'db', label, jsonClone(result, label));
+          return result;
+        }
+        return takeTap(store, 'db', label);
+      };
+    return new Proxy(client, {
+      get(target, prop, receiver) {
+        if (
+          (prop === 'query' || prop === 'execute') &&
+          typeof target[prop] === 'function'
+        )
+          return wrapMethod(prop);
+        return Reflect.get(target, prop, receiver);
+      },
+    });
+  }
+
+  // Express middleware — mount early; the request's whole async tree records.
+  // The flight is finalized and written on response finish.
+  function middleware({ cwd = process.cwd(), onFlight = null } = {}) {
+    return function spardaFlightRecorder(req, res, next) {
+      // replay wins over record: when the timeless CLI replays through an app
+      // that mounts this recorder, the outer replay store must reach the taps
+      // untouched — re-recording a replay would shadow it with live values
+      const outer = als.getStore();
+      if (outer?.mode === 'replay') return next();
+      if (process.env.SPARDA_FLIGHT === 'off') return next();
+      const store = { mode: 'record', taps: [] };
+      const chunks = [];
+      const origWrite = res.write.bind(res);
+      const origEnd = res.end.bind(res);
+      res.write = (chunk, ...rest) => {
+        if (chunk) chunks.push(Buffer.from(chunk));
+        return origWrite(chunk, ...rest);
+      };
+      res.end = (chunk, ...rest) => {
+        if (chunk && typeof chunk !== 'function') chunks.push(Buffer.from(chunk));
+        return origEnd(chunk, ...rest);
+      };
+      res.on('finish', () => {
+        const flight = {
+          request: {
+            method: req.method,
+            url: req.originalUrl ?? req.url,
+            headers: { 'content-type': req.headers['content-type'] ?? '' },
+            body: req.body ?? null,
+          },
+          response: {
+            status: res.statusCode,
+            headers: { 'content-type': res.getHeader('content-type') ?? '' },
+            body: Buffer.concat(chunks).toString('utf8').slice(0, MAX_BODY_BYTES),
+          },
+          taps: store.taps,
+        };
+        const saved = saveFlight(cwd, flight);
+        if (onFlight) onFlight(saved, flight);
+      });
+      als.run(store, next);
+    };
+  }
+
+  // replay plumbing — one store per replayed request
+  function makeReplayStore(flight) {
+    const queues = new Map();
+    for (const tap of flight.taps) {
+      if (!queues.has(tap.kind)) queues.set(tap.kind, []);
+      queues.get(tap.kind).push(tap);
+    }
+    return { mode: 'replay', queues, divergences: [] };
+  }
+
+  const runWith = (store, fn) => als.run(store, fn);
+
+  return { arm, disarm, wrapClient, middleware, makeReplayStore, runWith };
+}
+
+function tapOut(store, kind, label, result) {
+  store.taps.push({ seq: store.taps.length, kind, label, result });
+}
+
+// strict FIFO per kind, label-checked — the "quasi infallible" contract:
+// the replayed code must ask reality the SAME questions in the SAME order
+function takeTap(store, kind, label) {
+  const queue = store.queues.get(kind);
+  const tap = queue?.shift();
+  if (!tap) {
+    const d = { kind, expected: null, got: label };
+    store.divergences.push(d);
+    throw new FlightDivergence(
+      `replay diverged: code asked for ${kind} "${label}" but the flight has no more ${kind} taps`,
+      d,
+    );
+  }
+  if (tap.label !== label) {
+    const d = { kind, expected: tap.label, got: label };
+    store.divergences.push(d);
+    throw new FlightDivergence(
+      `replay diverged: flight expected ${kind} "${tap.label}", code asked for "${label}"`,
+      d,
+    );
+  }
+  return tap.result;
+}
+
+function jsonClone(value, label) {
+  try {
+    const s = JSON.stringify(value);
+    if (s === undefined) throw new Error('undefined');
+    return JSON.parse(s);
+  } catch {
+    // honesty over convenience: an unserializable tap cannot replay — record
+    // the fact so replay fails loudly instead of returning garbage
+    throw new FlightDivergence(`tap "${label}" returned an unserializable value`, {
+      label,
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Process singleton — THE box for app integration and the timeless CLI.
+// The app's wrapClient and the replayer must share ONE AsyncLocalStorage or
+// replay stores are invisible to the app's taps (silent passthrough to the
+// real db — the exact failure mode this singleton exists to kill). Module
+// caching guarantees identity as long as both sides resolve the same
+// sparda-mcp install, which `npx sparda` inside the app's project does.
+// createFlightBox() stays exported for isolated tests.
+// ---------------------------------------------------------------------------
+let singleton = null;
+
+export function getFlightBox() {
+  if (!singleton) singleton = createFlightBox();
+  return singleton;
+}

package/src/flight/format.js

@@ -0,0 +1,71 @@
+// flight/format.js — the flight file: one production request, replayable.
+// A flight is the ENTIRE nondeterminism of one request: the input, the final
+// response, and every tap (db, http, time, random, uuid) in execution order.
+// Identity is content: id = sha256 of the canonical JSON — no timestamps, no
+// counters, so the same request recorded twice on two machines is the same
+// flight. Everything between the taps is deterministic code; that is the
+// compiler's guarantee (SBIR §2.8) and the whole reason this file can exist.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { atomicWriteFileSync as atomicWrite } from '../server/persistence.js';
+
+export const FLIGHT_VERSION = 'sparda-flight/v1';
+
+export function canonicalJson(value) {
+  return JSON.stringify(sortKeysDeep(value), null, 2) + '\n';
+}
+
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) return value.map(sortKeysDeep); // tap ORDER is meaning
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const k of Object.keys(value).sort()) out[k] = sortKeysDeep(value[k]);
+    return out;
+  }
+  return value;
+}
+
+export function flightIdOf(flight) {
+  const { id: _drop, ...body } = flight;
+  return crypto
+    .createHash('sha256')
+    .update(canonicalJson(body))
+    .digest('hex')
+    .slice(0, 16);
+}
+
+export function flightDir(cwd) {
+  return path.join(cwd, '.sparda', 'flight');
+}
+
+export function saveFlight(cwd, flight) {
+  const body = { version: FLIGHT_VERSION, ...flight };
+  const id = flightIdOf(body);
+  const dir = flightDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, `${id}.json`);
+  atomicWrite(file, canonicalJson({ ...body, id }));
+  return { id, file };
+}
+
+export function loadFlight(cwd, id) {
+  const file = path.join(flightDir(cwd), `${id}.json`);
+  const flight = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (flight.version !== FLIGHT_VERSION)
+    throw Object.assign(
+      new Error(`flight ${id} has version ${flight.version}, expected ${FLIGHT_VERSION}`),
+      { code: 'USER' },
+    );
+  return flight;
+}
+
+export function listFlights(cwd) {
+  const dir = flightDir(cwd);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => f.slice(0, -5))
+    .sort();
+}

package/src/flight/replayer.js

@@ -0,0 +1,97 @@
+// flight/replayer.js — re-fly one recorded request against the real code.
+// The app runs in-process on an ephemeral port; every nondeterminism point is
+// fed the recorded value by the FlightBox; the response must come out
+// byte-equal (JSON-canonical when both sides parse as JSON). The verdict is
+// three-part and all three must hold for a match:
+//   1. the response is identical,
+//   2. no divergence was raised (same questions, same order),
+//   3. every tap was consumed (the code didn't silently skip a step).
+import http from 'node:http';
+
+export async function replayFlight(app, flight, box) {
+  const store = box.makeReplayStore(flight);
+
+  const server = http.createServer((req, res) => {
+    box.runWith(store, () => app(req, res));
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const { port } = server.address();
+
+  let actual;
+  try {
+    const { request } = flight;
+    const hasBody = request.body !== null && request.method !== 'GET';
+    // raw http.request on purpose: the box may have global fetch patched, the
+    // replayer's own client must be immune to every virtualization layer
+    actual = await rawRequest({
+      port,
+      method: request.method,
+      path: request.url,
+      headers: hasBody
+        ? { 'content-type': request.headers['content-type'] || 'application/json' }
+        : {},
+      body: hasBody ? JSON.stringify(request.body) : null,
+    });
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  const expected = { status: flight.response.status, body: flight.response.body };
+  const bodyMatch = jsonOrRawEqual(expected.body, actual.body);
+  const statusMatch = expected.status === actual.status;
+  const leftover = [...store.queues.entries()]
+    .filter(([, q]) => q.length)
+    .map(([kind, q]) => ({ kind, unconsumed: q.length }));
+
+  return {
+    match:
+      statusMatch && bodyMatch && store.divergences.length === 0 && leftover.length === 0,
+    statusMatch,
+    bodyMatch,
+    expected,
+    actual,
+    divergences: store.divergences,
+    leftover,
+  };
+}
+
+export function rawRequest({ port, method, path, headers = {}, body = null }) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      { host: '127.0.0.1', port, method, path, headers },
+      (res) => {
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () =>
+          resolve({
+            status: res.statusCode,
+            body: Buffer.concat(chunks).toString('utf8'),
+          }),
+        );
+      },
+    );
+    req.on('error', reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+// byte-equality with one mercy: JSON key order is not meaning
+function jsonOrRawEqual(a, b) {
+  if (a === b) return true;
+  try {
+    return canonical(JSON.parse(a)) === canonical(JSON.parse(b));
+  } catch {
+    return false;
+  }
+}
+
+function canonical(v) {
+  if (Array.isArray(v)) return `[${v.map(canonical).join(',')}]`;
+  if (v && typeof v === 'object')
+    return `{${Object.keys(v)
+      .sort()
+      .map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`)
+      .join(',')}}`;
+  return JSON.stringify(v);
+}

package/src/index.js

@@ -15,6 +15,7 @@ const getOpt = (name, dflt) => {
 
 const opts = {
   yes: flags.has('--yes') || flags.has('-y'),
+  saveBaseline: flags.has('--save-baseline'),
   verbose: flags.has('--verbose'),
   quiet: flags.has('--quiet'),
   probe: flags.has('--probe'),
@@ -99,6 +100,16 @@ try {
       await runUbg(opts);
       break;
     }
+    case 'apocalypse': {
+      const { runApocalypse } = await import('./commands/apocalypse.js');
+      await runApocalypse(opts);
+      break;
+    }
+    case 'timeless': {
+      const { runTimeless } = await import('./commands/timeless.js');
+      await runTimeless(opts, rest);
+      break;
+    }
     default:
       console.log(`SPARDA v${VERSION} — Turn any codebase into an MCP server.
 
@@ -116,6 +127,8 @@ Usage:
   npx sparda-mcp grammar   Which call sequences mean something (observed + hypotheses)
   npx sparda-mcp evolve    Trial hypothesis chains against the twin; survivors become suggestions
   npx sparda-mcp ubg       Compile the codebase to its Unified Behavior Graph (.sparda/ubg.json)
+  npx sparda-mcp apocalypse  Prove the deploy: guards, invariants, transactions, aggregates (--save-baseline)
+  npx sparda-mcp timeless  Replay production requests (list | replay <id> | export <id> → vitest)
 
 Flags: --yes (skip prompts)  --port <n>  --quiet  --verbose
        --probe (init: also run the app to discover dynamic routes the AST missed)

package/src/ubg/extract.js

@@ -243,6 +243,21 @@ function visit(node, out, ctx) {
     return;
   }
 
+  // `new Date()` — wall-clock read: an entropy effect the flight recorder
+  // must tap for deterministic replay (SBIR v1.2 / Timeless)
+  if (
+    node.type === 'NewExpression' &&
+    node.callee?.type === 'Identifier' &&
+    node.callee.name === 'Date' &&
+    node.arguments.length === 0
+  ) {
+    pushEffect(out, ctx, {
+      effectType: 'entropy',
+      target: 'time',
+      line: node.loc?.start.line ?? 0,
+    });
+  }
+
   if (node.type === 'CallExpression') {
     // transaction scope: db.transaction(cb) / prisma.$transaction(...) — the
     // innermost scope wins; isolation only from a string literal, never guessed
@@ -319,6 +334,10 @@ function inspectCall(node, out, ctx) {
       });
       return;
     }
+    if (/^(uuid|uuidv4|nanoid|randomuuid|ulid)$/i.test(callee.name)) {
+      pushEffect(out, ctx, { effectType: 'entropy', target: 'uuid', line });
+      return;
+    }
     if (out.calls.length < MAX_CALLS) out.calls.push({ name: callee.name, line });
     return;
   }
@@ -328,6 +347,20 @@ function inspectCall(node, out, ctx) {
   const methodLower = method.toLowerCase();
   const rootName = rootIdentifier(callee);
 
+  // ---- entropy: nondeterminism points the replayer must virtualize
+  if (rootName === 'Date' && methodLower === 'now') {
+    pushEffect(out, ctx, { effectType: 'entropy', target: 'time', line });
+    return;
+  }
+  if (rootName === 'Math' && methodLower === 'random') {
+    pushEffect(out, ctx, { effectType: 'entropy', target: 'random', line });
+    return;
+  }
+  if (/^crypto$/i.test(rootName ?? '') && methodLower === 'randomuuid') {
+    pushEffect(out, ctx, { effectType: 'entropy', target: 'uuid', line });
+    return;
+  }
+
   // ---- input validation signal (SBIR §2.1): zod-style .safeParse / Schema.parse
   if (
     methodLower === 'safeparse' ||
@@ -585,7 +618,11 @@ function builderTableOf(node) {
   return null;
 }
 
-// 'INSERT INTO users (a) VALUES (1)' → { effectType, op, table }
+// 'INSERT INTO users (a) VALUES (1)' → { effectType, op, table, … }
+// Literal column values are also harvested (SET x = 'v', WHERE x = 'v',
+// INSERT (…) VALUES (…)) — the raw material StateMachineInference reads.
+// Everything is lowercased: deterministic, and SQL identifiers are
+// case-insensitive anyway (literal VALUES lose case — documented trade-off).
 export function parseSqlCall(sql) {
   const s = sql.trim().toLowerCase();
   const verb = s.split(/\s+/)[0];
@@ -598,7 +635,47 @@ export function parseSqlCall(sql) {
   else if (verb === 'delete') m = s.match(/delete\s+from\s+"?([\w.]+)"?/);
   else m = s.match(/\bfrom\s+"?([\w.]+)"?/);
   if (m) table = m[1].includes('.') ? m[1].split('.').pop() : m[1];
-  return { ...known, table };
+
+  const details = {};
+  if (verb === 'update') {
+    const setM = s.match(/\bset\s+([\s\S]*?)(?:\s+where\s|$)/);
+    if (setM) {
+      const sets = literalPairsOf(setM[1]);
+      if (Object.keys(sets).length) details.sets = sets;
+    }
+  }
+  if (verb === 'update' || verb === 'delete' || verb === 'select') {
+    const whereM = s.match(/\bwhere\s+([\s\S]*)$/);
+    if (whereM) {
+      const where = literalPairsOf(whereM[1]);
+      if (Object.keys(where).length) details.where = where;
+    }
+  }
+  if (verb === 'insert') {
+    const im = s.match(/\(([^)]*)\)\s*values\s*\(([^)]*)\)/);
+    if (im) {
+      const cols = im[1].split(',').map((c) => c.trim().replace(/"/g, ''));
+      const vals = im[2].split(',').map((v) => v.trim());
+      const inserts = {};
+      cols.forEach((c, i) => {
+        const q = vals[i]?.match(/^'([^']*)'$/);
+        if (q) inserts[c] = q[1];
+      });
+      if (Object.keys(inserts).length) details.inserts = inserts;
+    }
+  }
+  return { ...known, table, ...details };
+}
+
+// "status = 'paid', total = 3" → { status: 'paid' } — string literals only,
+// bounded; placeholders and expressions are invisible on purpose
+function literalPairsOf(clause) {
+  const pairs = {};
+  for (const m of clause.matchAll(/([\w"]+)\s*=\s*'([^']*)'/g)) {
+    if (Object.keys(pairs).length >= 8) break;
+    pairs[m[1].replace(/"/g, '')] = m[2];
+  }
+  return pairs;
 }
 
 // middleware classifier: name smell OR observed 401/403 denial → guard

package/src/ubg/fastapi_extract.py

@@ -44,6 +44,16 @@ def root_name(node):
     return None
 
 
+def literal_pairs_of(clause):
+    """"status = 'paid', x = 3" -> {status: paid} — string literals only."""
+    pairs = {}
+    for m in re.finditer(r"([\w\"]+)\s*=\s*'([^']*)'", clause):
+        if len(pairs) >= 8:
+            break
+        pairs[m.group(1).replace('"', "")] = m.group(2)
+    return pairs
+
+
 def parse_sql(sql):
     s = sql.strip().lower()
     verb = s.split()[0] if s.split() else ""
@@ -62,7 +72,35 @@ def parse_sql(sql):
     table = None
     if m:
         table = m.group(1).split(".")[-1]
-    return {"effectType": effect_type, "op": op, "table": table}
+    effect = {"effectType": effect_type, "op": op, "table": table}
+
+    # literal column values — StateMachineInference raw material (SBIR v1.2)
+    if verb == "update":
+        set_m = re.search(r"\bset\s+([\s\S]*?)(?:\s+where\s|$)", s)
+        if set_m:
+            sets = literal_pairs_of(set_m.group(1))
+            if sets:
+                effect["sets"] = sets
+    if verb in ("update", "delete", "select"):
+        where_m = re.search(r"\bwhere\s+([\s\S]*)$", s)
+        if where_m:
+            where = literal_pairs_of(where_m.group(1))
+            if where:
+                effect["where"] = where
+    if verb == "insert":
+        im = re.search(r"\(([^)]*)\)\s*values\s*\(([^)]*)\)", s)
+        if im:
+            cols = [c.strip().replace('"', "") for c in im.group(1).split(",")]
+            vals = [v.strip() for v in im.group(2).split(",")]
+            inserts = {}
+            for i, col in enumerate(cols):
+                if i < len(vals):
+                    q = re.match(r"^'([^']*)'$", vals[i])
+                    if q:
+                        inserts[col] = q.group(1)
+            if inserts:
+                effect["inserts"] = inserts
+    return effect
 
 
 def sql_literal_of(arg):
@@ -270,6 +308,20 @@ def inspect_call(node, out, ctx):
     method = func.attr
     root = root_name(func)
 
+    # entropy: nondeterminism points the flight replayer must virtualize
+    if root == "datetime" and method in ("now", "utcnow", "today"):
+        push_effect(out, ctx, {"effectType": "entropy", "target": "time", "line": line})
+        return
+    if root == "time" and method in ("time", "monotonic", "time_ns"):
+        push_effect(out, ctx, {"effectType": "entropy", "target": "time", "line": line})
+        return
+    if root == "random":
+        push_effect(out, ctx, {"effectType": "entropy", "target": "random", "line": line})
+        return
+    if root == "uuid" and method.startswith("uuid"):
+        push_effect(out, ctx, {"effectType": "entropy", "target": "uuid", "line": line})
+        return
+
     # input validation signal (SBIR §2.1): explicit Pydantic validation calls
     if method in ("model_validate", "model_validate_json", "parse_obj", "parse_raw"):
         out["validatesInput"] = True

package/src/ubg/passes/capabilities.js

@@ -0,0 +1,73 @@
+// ubg/passes/capabilities.js — pass 6 (SBIR v1.2 §2.5).
+// "POST /transfer" is a route; "update:users + insert:orders" is what it can
+// DO. Capabilities are derived, never declared: the sorted set of verbs an
+// entrypoint's reachable effects perform on named resources. Guards then
+// learn what they protect — the union of the capabilities behind them. This
+// is the vocabulary a permission auditor or an AI-agent policy layer reads
+// instead of guessing from URL strings. Annotation-only.
+import { reachabilityOf } from '../reach.js';
+
+export const name = 'CapabilityExtraction';
+
+export function run(graph) {
+  const reach = reachabilityOf(graph);
+  const mutOut = new Map();
+  const readIn = new Map(); // effect id -> state ids read
+  for (const e of graph.edges) {
+    if (e.kind === 'mutation') {
+      if (!mutOut.has(e.from)) mutOut.set(e.from, []);
+      mutOut.get(e.from).push(e);
+    }
+    if (e.kind === 'data_flow' && graph.nodes.get(e.from)?.kind === 'state') {
+      if (!readIn.has(e.to)) readIn.set(e.to, []);
+      readIn.get(e.to).push(e.from);
+    }
+  }
+
+  const all = new Set();
+  const guardProtects = new Map();
+
+  for (const [epId, reached] of reach) {
+    const ep = graph.nodes.get(epId);
+    const caps = new Set();
+    for (const id of [...reached].sort()) {
+      const node = graph.nodes.get(id);
+      if (node?.kind !== 'effect') continue;
+      for (const m of mutOut.get(id) ?? []) {
+        const table = graph.nodes.get(m.to)?.meta.table ?? 'unknown';
+        caps.add(`${m.meta.op ?? 'write'}:${table}`);
+      }
+      for (const sid of readIn.get(id) ?? []) {
+        caps.add(`read:${graph.nodes.get(sid)?.meta.table ?? 'unknown'}`);
+      }
+      if (node.meta.effectType === 'http_call')
+        caps.add(`call:${hostOf(node.meta.target)}`);
+      if (node.meta.effectType === 'fs_write') caps.add('fs:write');
+      if (node.meta.effectType === 'fs_read') caps.add('fs:read');
+    }
+    if (caps.size) {
+      ep.meta.capabilities = [...caps].sort();
+      for (const c of caps) all.add(c);
+    }
+    // a guard on this route protects everything the route can do
+    for (const id of reached) {
+      if (graph.nodes.get(id)?.kind !== 'guard') continue;
+      if (!guardProtects.has(id)) guardProtects.set(id, new Set());
+      for (const c of caps) guardProtects.get(id).add(c);
+    }
+  }
+
+  for (const [guardId, caps] of guardProtects) {
+    graph.nodes.get(guardId).meta.protects = [...caps].sort();
+  }
+
+  return { capabilities: all.size, guardsAnnotated: guardProtects.size };
+}
+
+function hostOf(target) {
+  try {
+    return new URL(target).host;
+  } catch {
+    return 'dynamic';
+  }
+}

package/src/ubg/passes/effect-algebra.js

@@ -35,6 +35,11 @@ export function run(graph) {
         observable = false;
         compensable = true; // nothing to undo
         break;
+      case 'entropy': // reads the world's dice — different every call
+        idempotent = false;
+        observable = false;
+        compensable = true;
+        break;
       case 'db_write':
         idempotent = IDEMPOTENT_DB_OPS.has(m.op);
         observable = false;

package/src/ubg/passes/resource-lifetimes.js

@@ -0,0 +1,73 @@
+// ubg/passes/resource-lifetimes.js — pass 7 (SBIR v1.2 §2.6).
+// Every state answers four questions: who creates me, who updates me, who
+// destroys me, who reads me — as sorted entrypoint lists derived from the
+// mutation/data_flow edges. The report flags two smells worth a human eye:
+// immortal resources (created, never destroyed — unbounded growth) and
+// unmanaged ones (destroyed here, created elsewhere — split ownership).
+// Annotation-only.
+import { reachabilityOf } from '../reach.js';
+
+export const name = 'ResourceLifetimes';
+
+const OP_BUCKET = {
+  insert: 'createdBy',
+  update: 'updatedBy',
+  upsert: 'updatedBy',
+  delete: 'destroyedBy',
+};
+
+export function run(graph) {
+  const reach = reachabilityOf(graph);
+
+  // effect id -> entrypoints that can reach it
+  const epsOfEffect = new Map();
+  for (const [epId, reached] of reach) {
+    for (const id of reached) {
+      if (graph.nodes.get(id)?.kind !== 'effect') continue;
+      if (!epsOfEffect.has(id)) epsOfEffect.set(id, new Set());
+      epsOfEffect.get(id).add(epId);
+    }
+  }
+
+  const lifetimes = new Map(); // state id -> buckets
+  const bucketsFor = (sid) => {
+    if (!lifetimes.has(sid))
+      lifetimes.set(sid, {
+        createdBy: new Set(),
+        updatedBy: new Set(),
+        destroyedBy: new Set(),
+        readBy: new Set(),
+      });
+    return lifetimes.get(sid);
+  };
+
+  for (const e of graph.edges) {
+    if (e.kind === 'mutation') {
+      const bucket = OP_BUCKET[e.meta.op] ?? 'updatedBy';
+      for (const ep of epsOfEffect.get(e.from) ?? []) bucketsFor(e.to)[bucket].add(ep);
+    }
+    if (e.kind === 'data_flow' && graph.nodes.get(e.from)?.kind === 'state') {
+      for (const ep of epsOfEffect.get(e.to) ?? []) bucketsFor(e.from).readBy.add(ep);
+    }
+  }
+
+  const immortal = [];
+  const unmanaged = [];
+  let annotated = 0;
+  for (const [sid, buckets] of [...lifetimes].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const state = graph.nodes.get(sid);
+    if (!state) continue;
+    state.meta.lifetime = Object.fromEntries(
+      Object.entries(buckets).map(([k, v]) => [k, [...v].sort()]),
+    );
+    annotated++;
+    if (buckets.createdBy.size && !buckets.destroyedBy.size)
+      immortal.push(state.meta.table);
+    if (buckets.destroyedBy.size && !buckets.createdBy.size)
+      unmanaged.push(state.meta.table);
+  }
+
+  immortal.sort();
+  unmanaged.sort();
+  return { annotated, immortal, unmanaged };
+}

package/src/ubg/passes/state-machines.js

@@ -0,0 +1,104 @@
+// ubg/passes/state-machines.js — pass 8 (SBIR v1.2 §2.7).
+// "POST /orders then PATCH /orders/:id/pay" is routing; "∅→pending→paid" is
+// what the system MEANS. The machine is derived from three declared sources,
+// never guessed: (1) the status-like column, (2) the CHECK … IN (…) invariant
+// naming the legal states, (3) literal column values the effects write —
+// INSERT literals are initial transitions (∅→v), UPDATE SET literals are
+// transitions whose from-state is the WHERE literal when present, '*' when
+// the code doesn't constrain it (over-approximation, said out loud).
+// Annotation-only.
+import { reachabilityOf } from '../reach.js';
+
+export const name = 'StateMachineInference';
+
+const FIELD_RE = /^(status|state)$/;
+
+export function run(graph) {
+  const reach = reachabilityOf(graph);
+  const epsOfEffect = new Map();
+  for (const [epId, reached] of reach) {
+    for (const id of reached) {
+      if (graph.nodes.get(id)?.kind !== 'effect') continue;
+      if (!epsOfEffect.has(id)) epsOfEffect.set(id, new Set());
+      epsOfEffect.get(id).add(epId);
+    }
+  }
+
+  const mutIn = new Map(); // state id -> [{ effect, op }]
+  for (const e of graph.edges) {
+    if (e.kind !== 'mutation') continue;
+    if (!mutIn.has(e.to)) mutIn.set(e.to, []);
+    mutIn.get(e.to).push({ effect: graph.nodes.get(e.from), op: e.meta.op });
+  }
+
+  let machines = 0;
+  const states = [...graph.nodes.values()]
+    .filter((n) => n.kind === 'state')
+    .sort((a, b) => a.id.localeCompare(b.id));
+
+  for (const state of states) {
+    const field = fieldOf(state);
+    if (!field) continue;
+
+    const declared = declaredStatesOf(state, field);
+    const transitions = [];
+    const observed = new Set();
+
+    for (const { effect } of mutIn.get(state.id) ?? []) {
+      if (!effect) continue;
+      const via = [...(epsOfEffect.get(effect.id) ?? [])].sort();
+      const insertV = effect.meta.inserts?.[field];
+      if (insertV !== undefined) {
+        transitions.push({ from: '∅', to: insertV, via });
+        observed.add(insertV);
+      }
+      const setV = effect.meta.sets?.[field];
+      if (setV !== undefined) {
+        const from = effect.meta.where?.[field] ?? '*';
+        transitions.push({ from, to: setV, via });
+        observed.add(setV);
+        if (from !== '*') observed.add(from);
+      }
+    }
+
+    if (!transitions.length && !declared.length) continue;
+    transitions.sort(
+      (a, b) =>
+        a.from.localeCompare(b.from) ||
+        a.to.localeCompare(b.to) ||
+        (a.via[0] ?? '').localeCompare(b.via[0] ?? ''),
+    );
+    state.meta.stateMachine = {
+      field,
+      states: declared.length ? declared : [...observed].sort(),
+      transitions,
+    };
+    machines++;
+  }
+
+  return { machines };
+}
+
+// a column literally named status/state, else one whose CHECK names it
+function fieldOf(state) {
+  for (const col of state.meta.columns ?? []) {
+    if (FIELD_RE.test(col.name)) return col.name;
+  }
+  for (const inv of state.meta.invariants ?? []) {
+    if (inv.type !== 'check') continue;
+    const m = inv.expression?.match(/^(\w+)\s+in\s*\(/i);
+    if (m && FIELD_RE.test(m[1])) return m[1];
+  }
+  return null;
+}
+
+// CHECK (status IN ('pending', 'paid')) → ['paid', 'pending']
+function declaredStatesOf(state, field) {
+  for (const inv of state.meta.invariants ?? []) {
+    if (inv.type !== 'check') continue;
+    const m = inv.expression?.match(new RegExp(`${field}\\s+in\\s*\\(([^)]*)\\)`, 'i'));
+    if (!m) continue;
+    return [...m[1].matchAll(/'([^']*)'/g)].map((x) => x[1]).sort();
+  }
+  return [];
+}

package/src/ubg/pipeline.js

@@ -11,14 +11,22 @@ import * as stateMinimization from './passes/state-minimization.js';
 import * as typePropagation from './passes/type-propagation.js';
 import * as effectAlgebra from './passes/effect-algebra.js';
 import * as consistencyDomains from './passes/consistency-domains.js';
+import * as capabilities from './passes/capabilities.js';
+import * as resourceLifetimes from './passes/resource-lifetimes.js';
+import * as stateMachines from './passes/state-machines.js';
 
-// SBIR §4 — normative order: reap, merge, type, classify, derive domains
+// SBIR §4 — normative order: reap, merge, type, classify, derive domains,
+// then the v1.2 derivations (capabilities, lifetimes, machines) which read
+// everything the earlier passes established
 export const PASSES = [
   deadPathElimination,
   stateMinimization,
   typePropagation,
   effectAlgebra,
   consistencyDomains,
+  capabilities,
+  resourceLifetimes,
+  stateMachines,
 ];
 
 export function optimize(graph, { passes = PASSES } = {}) {

package/src/ubg/reach.js

@@ -0,0 +1,39 @@
+// ubg/reach.js — route-aware reachability, the one traversal everything
+// per-entrypoint shares. Chain control_flow edges carry meta.route; walking
+// from an entrypoint never crosses into a sibling route's chain (a middleware
+// shared by N routes fans out to N handlers, but a request walks ONE edge).
+export function buildCfIndex(edges) {
+  const cfOut = new Map();
+  for (const e of edges) {
+    if (e.kind !== 'control_flow') continue;
+    if (!cfOut.has(e.from)) cfOut.set(e.from, []);
+    cfOut.get(e.from).push({ to: e.to, route: e.meta?.route ?? null });
+  }
+  return cfOut;
+}
+
+export function reachFrom(epId, cfOut) {
+  const seen = new Set();
+  const queue = [epId];
+  while (queue.length) {
+    const id = queue.shift();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    for (const next of cfOut.get(id) ?? []) {
+      if (next.route === null || next.route === epId) queue.push(next.to);
+    }
+  }
+  seen.delete(epId);
+  return seen;
+}
+
+// entrypointId -> Set(reached node ids), for every entrypoint, sorted walk
+export function reachabilityOf(graph) {
+  const cfOut = buildCfIndex(graph.edges);
+  const map = new Map();
+  const entrypoints = [...graph.nodes.values()]
+    .filter((n) => n.kind === 'entrypoint')
+    .sort((a, b) => a.id.localeCompare(b.id));
+  for (const ep of entrypoints) map.set(ep.id, reachFrom(ep.id, cfOut));
+  return map;
+}

package/src/ubg/translate.js

@@ -136,7 +136,13 @@ function translateRoute(
   for (const step of fullChain) {
     const { id: stepId, scan } = ensureChainNode(graph, step, scanCache);
     chainNodes.push({ id: stepId, step, scan });
-    addEdge(graph, makeEdge('control_flow', prevId, stepId, { order: order++ }));
+    // chain edges carry their route: a middleware shared by N routes fans out
+    // to N handlers, but a request only ever walks ONE of those edges —
+    // per-entrypoint traversals filter on meta.route to stay leak-free
+    addEdge(
+      graph,
+      makeEdge('control_flow', prevId, stepId, { order: order++, route: epId }),
+    );
     prevId = stepId;
   }
 
@@ -242,6 +248,10 @@ function attachBody(graph, ownerId, scan, helperByName, scanCache, expanded) {
           ...(eff.target ? { target: eff.target } : {}),
           ...(eff.driver ? { driver: eff.driver } : {}),
           ...(eff.httpMethod ? { httpMethod: eff.httpMethod } : {}),
+          // literal column values (SBIR v1.2) — StateMachineInference fuel
+          ...(eff.sets ? { sets: eff.sets } : {}),
+          ...(eff.where ? { where: eff.where } : {}),
+          ...(eff.inserts ? { inserts: eff.inserts } : {}),
           // SBIR v1.1 §2.2 — transaction scope id is file-qualified here,
           // where the owner's file is known
           ...(eff.txLine != null