0sec-cli 0.15.0 → 0.17.0

package/chunks/chunk-47TQJWDH.js

@@ -0,0 +1,3729 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+import {
+  runReproducerInKernelVm
+} from "./chunk-SNKTC4BP.js";
+import {
+  makeSkepticVerifier,
+  runHuntScan,
+  scoreGeometry
+} from "./chunk-K26SZ37E.js";
+import {
+  LlmApiRuntime
+} from "./chunk-2SANI5RH.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-IR537GON.js";
+
+// packages/core/dist/stages/tree-sitter-runtime.cjs
+var require_tree_sitter_runtime = __commonJS({
+  "packages/core/dist/stages/tree-sitter-runtime.cjs"(exports, module) {
+    "use strict";
+    var compiled = false;
+    if (!compiled) {
+      module.exports = {
+        Parser: __require("tree-sitter"),
+        language: __require("tree-sitter-c")
+      };
+    } else {
+      module.exports = {
+        Parser: __require("./tree-sitter-compiled/tree-sitter-runtime.cjs"),
+        language: __require("./tree-sitter-compiled/tree-sitter-c.node")
+      };
+    }
+  }
+});
+
+// packages/core/dist/stages/assumption-mining.js
+import { readFileSync as readFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, join } from "node:path";
+import { tmpdir } from "node:os";
+
+// packages/core/dist/stages/c-dataflow.js
+var import_tree_sitter_runtime = __toESM(require_tree_sitter_runtime(), 1);
+var { Parser: TreeSitterParser, language: C } = import_tree_sitter_runtime.default;
+var PARSER = null;
+function parser() {
+  if (!PARSER) {
+    PARSER = new TreeSitterParser();
+    PARSER.setLanguage(C);
+  }
+  return PARSER;
+}
+function parseC(src) {
+  try {
+    return parser().parse(src, void 0, {
+      bufferSize: Buffer.byteLength(src, "utf8") + 8192
+    }).rootNode;
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_ACQUIRE_FNS = [
+  "spin_lock",
+  "spin_lock_bh",
+  "spin_lock_irq",
+  "spin_lock_irqsave",
+  "spin_trylock",
+  "raw_spin_lock",
+  "raw_spin_lock_bh",
+  "raw_spin_lock_irqsave",
+  "mutex_lock",
+  "mutex_lock_interruptible",
+  "mutex_trylock",
+  "read_lock",
+  "read_lock_bh",
+  "write_lock",
+  "write_lock_bh",
+  "down",
+  "down_read",
+  "down_write",
+  "down_interruptible",
+  "down_trylock"
+];
+var DEFAULT_RELEASE_FNS = [
+  "spin_unlock",
+  "spin_unlock_bh",
+  "spin_unlock_irq",
+  "spin_unlock_irqrestore",
+  "raw_spin_unlock",
+  "raw_spin_unlock_bh",
+  "raw_spin_unlock_irqrestore",
+  "mutex_unlock",
+  "read_unlock",
+  "read_unlock_bh",
+  "write_unlock",
+  "write_unlock_bh",
+  "up",
+  "up_read",
+  "up_write"
+];
+function releaseFnsFor(acquireFns) {
+  const rel = new Set(DEFAULT_RELEASE_FNS);
+  for (const a of acquireFns) {
+    if (a === "down" || a === "down_interruptible" || a === "down_trylock")
+      rel.add("up");
+    else if (a === "down_read")
+      rel.add("up_read");
+    else if (a === "down_write")
+      rel.add("up_write");
+    else if (a.includes("irqsave"))
+      rel.add(a.replace("irqsave", "irqrestore").replace("_lock", "_unlock"));
+    else if (a.includes("lock"))
+      rel.add(a.replace("trylock", "unlock").replace("_lock", "_unlock"));
+  }
+  return [...rel];
+}
+var collapseWs = (s) => s.replace(/\s+/g, "");
+function canon(node, src) {
+  switch (node.type) {
+    case "identifier":
+    case "field_identifier":
+    case "type_identifier":
+      return src.slice(node.startIndex, node.endIndex);
+    case "parenthesized_expression": {
+      const inner = node.namedChildren[0];
+      return inner ? canon(inner, src) : collapseWs(src.slice(node.startIndex, node.endIndex));
+    }
+    case "pointer_expression": {
+      const op = node.child(0);
+      const arg = node.childForFieldName("argument") ?? node.namedChildren[0];
+      if (!arg)
+        return collapseWs(src.slice(node.startIndex, node.endIndex));
+      return op && src.slice(op.startIndex, op.endIndex) === "&" ? canon(arg, src) : "*" + canon(arg, src);
+    }
+    case "field_expression": {
+      const arg = node.childForFieldName("argument");
+      const field = node.childForFieldName("field");
+      const base = arg ? canon(arg, src) : "";
+      const f = field ? src.slice(field.startIndex, field.endIndex) : "";
+      return `${base}->${f}`;
+    }
+    case "subscript_expression": {
+      const arg = node.childForFieldName("argument") ?? node.namedChildren[0];
+      return (arg ? canon(arg, src) : "") + "[]";
+    }
+    default:
+      return collapseWs(src.slice(node.startIndex, node.endIndex));
+  }
+}
+var firstIdent = (s) => /^[A-Za-z_][A-Za-z0-9_]*/.exec(s)?.[0] ?? s;
+function normalizeLockToken(token) {
+  const key = collapseWs(token.replace(/^&/, "").replace(/\./g, "->"));
+  const idx = key.lastIndexOf("->");
+  if (idx === -1)
+    return { key, lockField: key, receiver: "", global: true };
+  return { key, lockField: key.slice(idx + 2), receiver: key.slice(0, idx), global: false };
+}
+var RECOGNIZED_CALL_SHAPE = /* @__PURE__ */ new Set(["identifier"]);
+function collectEvents(node, src, sink) {
+  const line = (n) => n.startPosition.row + 1;
+  const visit = (n, assignTarget) => {
+    switch (n.type) {
+      case "call_expression": {
+        const callee = n.childForFieldName("function");
+        const args = n.childForFieldName("arguments");
+        const calleeName2 = callee && RECOGNIZED_CALL_SHAPE.has(callee.type) ? src.slice(callee.startIndex, callee.endIndex) : "";
+        const arg0Node = args?.namedChildren[0];
+        const arg0 = arg0Node ? canon(arg0Node, src) : "";
+        sink.push({ kind: "call", index: n.endIndex, line: line(n), callee: calleeName2, arg0 });
+        if (args) {
+          const kids = args.namedChildren;
+          for (let i = 1; i < kids.length; i++)
+            visit(kids[i], false);
+        }
+        return;
+      }
+      case "assignment_expression": {
+        const left = n.childForFieldName("left");
+        const right = n.childForFieldName("right");
+        if (left) {
+          sink.push({ kind: "def", index: left.startIndex, line: line(left), canonStr: canon(left, src), base: firstIdent(canon(left, src)) });
+          visit(left, true);
+        }
+        if (right)
+          visit(right, false);
+        return;
+      }
+      case "init_declarator": {
+        const decl = n.childForFieldName("declarator");
+        const value = n.childForFieldName("value");
+        if (decl && decl.type === "identifier") {
+          const c = canon(decl, src);
+          sink.push({ kind: "def", index: decl.startIndex, line: line(decl), canonStr: c, base: firstIdent(c) });
+        }
+        if (value)
+          visit(value, false);
+        return;
+      }
+      case "field_expression": {
+        const arg = n.childForFieldName("argument");
+        const field = n.childForFieldName("field");
+        const receiver = arg ? canon(arg, src) : "";
+        const fname = field ? src.slice(field.startIndex, field.endIndex) : "";
+        const c = canon(n, src);
+        sink.push({
+          kind: "field",
+          index: n.startIndex,
+          line: line(n),
+          receiver,
+          field: fname,
+          canonStr: c,
+          isAssignTarget: assignTarget,
+          base: firstIdent(c),
+          isDeref: true
+        });
+        if (arg)
+          visit(arg, false);
+        return;
+      }
+      case "subscript_expression": {
+        const arg = n.childForFieldName("argument") ?? n.namedChildren[0];
+        const c = canon(n, src);
+        sink.push({ kind: "ref", index: n.startIndex, line: line(n), canonStr: c, base: firstIdent(c), isDeref: true });
+        if (arg)
+          visit(arg, false);
+        const idx = n.childForFieldName("index");
+        if (idx)
+          visit(idx, false);
+        return;
+      }
+      case "pointer_expression": {
+        const op = n.child(0);
+        const arg = n.childForFieldName("argument") ?? n.namedChildren[0];
+        if (op && src.slice(op.startIndex, op.endIndex) === "*" && arg) {
+          const c = canon(arg, src);
+          sink.push({ kind: "ref", index: n.startIndex, line: line(n), canonStr: c, base: firstIdent(c), isDeref: true });
+        }
+        if (arg)
+          visit(arg, false);
+        return;
+      }
+      case "identifier": {
+        const c = src.slice(n.startIndex, n.endIndex);
+        sink.push({ kind: "ref", index: n.startIndex, line: line(n), canonStr: c, base: c, isDeref: false });
+        return;
+      }
+      default: {
+        for (const k of n.namedChildren)
+          visit(k, false);
+        return;
+      }
+    }
+  };
+  visit(node, false);
+}
+function buildCfg(body, src) {
+  const blocks = [];
+  const mk = () => {
+    const id = blocks.length;
+    blocks.push({ id, events: [], succs: /* @__PURE__ */ new Set() });
+    return id;
+  };
+  const edge = (a, b) => blocks[a].succs.add(b);
+  const entry = mk();
+  const exit = mk();
+  let cur = entry;
+  const breakStack = [];
+  const continueStack = [];
+  const labels = /* @__PURE__ */ new Map();
+  const pendingGotos = [];
+  const emitInto = (block, node) => collectEvents(node, src, blocks[block].events);
+  const emit = (node) => {
+    switch (node.type) {
+      case "compound_statement": {
+        for (const child of node.namedChildren)
+          emit(child);
+        return;
+      }
+      case "expression_statement":
+      case "declaration": {
+        emitInto(cur, node);
+        return;
+      }
+      case "return_statement": {
+        emitInto(cur, node);
+        edge(cur, exit);
+        cur = mk();
+        return;
+      }
+      case "if_statement": {
+        const cond = node.childForFieldName("condition");
+        if (cond)
+          emitInto(cur, cond);
+        const condBlock = cur;
+        const consequence = node.childForFieldName("consequence");
+        const alternative = node.childForFieldName("alternative");
+        const thenEntry = mk();
+        edge(condBlock, thenEntry);
+        cur = thenEntry;
+        if (consequence)
+          emit(consequence);
+        const thenExit = cur;
+        const merge = mk();
+        edge(thenExit, merge);
+        if (alternative) {
+          const elseEntry = mk();
+          edge(condBlock, elseEntry);
+          cur = elseEntry;
+          const altStmt = alternative.type === "else_clause" ? alternative.namedChildren[0] ?? alternative : alternative;
+          emit(altStmt);
+          edge(cur, merge);
+        } else {
+          edge(condBlock, merge);
+        }
+        cur = merge;
+        return;
+      }
+      case "while_statement":
+      case "for_statement": {
+        const cond = node.childForFieldName("condition");
+        const init = node.childForFieldName("initializer");
+        const update = node.childForFieldName("update");
+        if (init)
+          emitInto(cur, init);
+        const header = mk();
+        edge(cur, header);
+        if (cond)
+          emitInto(header, cond);
+        const bodyEntry = mk();
+        const exitLoop = mk();
+        edge(header, bodyEntry);
+        edge(header, exitLoop);
+        breakStack.push(exitLoop);
+        continueStack.push(header);
+        cur = bodyEntry;
+        const bodyStmt = node.childForFieldName("body");
+        if (bodyStmt)
+          emit(bodyStmt);
+        if (update)
+          emitInto(cur, update);
+        edge(cur, header);
+        breakStack.pop();
+        continueStack.pop();
+        cur = exitLoop;
+        return;
+      }
+      case "do_statement": {
+        const bodyEntry = mk();
+        edge(cur, bodyEntry);
+        const exitLoop = mk();
+        breakStack.push(exitLoop);
+        continueStack.push(bodyEntry);
+        cur = bodyEntry;
+        const bodyStmt = node.childForFieldName("body");
+        if (bodyStmt)
+          emit(bodyStmt);
+        const cond = node.childForFieldName("condition");
+        if (cond)
+          emitInto(cur, cond);
+        edge(cur, bodyEntry);
+        edge(cur, exitLoop);
+        breakStack.pop();
+        continueStack.pop();
+        cur = exitLoop;
+        return;
+      }
+      case "switch_statement": {
+        const cond = node.childForFieldName("condition");
+        if (cond)
+          emitInto(cur, cond);
+        const switchBlock = cur;
+        const exitSwitch = mk();
+        breakStack.push(exitSwitch);
+        const bodyStmt = node.childForFieldName("body");
+        if (bodyStmt) {
+          let prev = null;
+          for (const caseNode of bodyStmt.namedChildren) {
+            const caseEntry = mk();
+            edge(switchBlock, caseEntry);
+            if (prev !== null)
+              edge(prev, caseEntry);
+            cur = caseEntry;
+            for (const s of caseNode.namedChildren) {
+              if (s.type === "case_statement" || s.type === "default_statement")
+                emit(s);
+              else
+                emit(s);
+            }
+            prev = cur;
+          }
+          if (prev !== null)
+            edge(prev, exitSwitch);
+        }
+        edge(switchBlock, exitSwitch);
+        breakStack.pop();
+        cur = exitSwitch;
+        return;
+      }
+      case "case_statement":
+      case "default_statement": {
+        for (const child of node.namedChildren) {
+          if (child.type === "number_literal" || child.type === "identifier" || child.type === "char_literal")
+            continue;
+          emit(child);
+        }
+        return;
+      }
+      case "goto_statement": {
+        const lbl = node.namedChildren.find((c) => c.type === "statement_identifier");
+        if (lbl)
+          pendingGotos.push({ from: cur, label: src.slice(lbl.startIndex, lbl.endIndex) });
+        cur = mk();
+        return;
+      }
+      case "labeled_statement": {
+        const lbl = node.namedChildren.find((c) => c.type === "statement_identifier");
+        const labelBlock = mk();
+        edge(cur, labelBlock);
+        if (lbl)
+          labels.set(src.slice(lbl.startIndex, lbl.endIndex), labelBlock);
+        cur = labelBlock;
+        const inner = node.namedChildren.find((c) => c.type !== "statement_identifier");
+        if (inner)
+          emit(inner);
+        return;
+      }
+      case "break_statement": {
+        if (breakStack.length)
+          edge(cur, breakStack[breakStack.length - 1]);
+        cur = mk();
+        return;
+      }
+      case "continue_statement": {
+        if (continueStack.length)
+          edge(cur, continueStack[continueStack.length - 1]);
+        cur = mk();
+        return;
+      }
+      default: {
+        emitInto(cur, node);
+        return;
+      }
+    }
+  };
+  emit(body);
+  edge(cur, exit);
+  for (const g of pendingGotos) {
+    const target = labels.get(g.label);
+    if (target !== void 0)
+      edge(g.from, target);
+  }
+  for (const b of blocks)
+    b.events.sort((a, c) => a.index - c.index);
+  return { blocks, entry, exit };
+}
+function preds(cfg) {
+  const p = cfg.blocks.map(() => []);
+  for (const b of cfg.blocks)
+    for (const s of b.succs)
+      p[s].push(b.id);
+  return p;
+}
+function lockGenKill(block, ctx) {
+  const held = /* @__PURE__ */ new Set();
+  const killed = /* @__PURE__ */ new Set();
+  for (const ev of block.events) {
+    if (ev.kind !== "call" || !ev.callee || !ev.arg0)
+      continue;
+    if (ctx.acquireFns.has(ev.callee)) {
+      held.add(ev.arg0);
+      killed.delete(ev.arg0);
+    } else if (ctx.releaseFns.has(ev.callee)) {
+      held.delete(ev.arg0);
+      killed.add(ev.arg0);
+    }
+  }
+  return { gen: held, kill: killed };
+}
+function lockUniverse(cfg, ctx) {
+  const u = /* @__PURE__ */ new Set();
+  for (const b of cfg.blocks)
+    for (const ev of b.events)
+      if (ev.kind === "call" && ev.callee && ctx.acquireFns.has(ev.callee) && ev.arg0)
+        u.add(ev.arg0);
+  return u;
+}
+function lockSetIn(cfg, ctx) {
+  const P = preds(cfg);
+  const universe = lockUniverse(cfg, ctx);
+  const genKill = cfg.blocks.map((b) => lockGenKill(b, ctx));
+  const IN = /* @__PURE__ */ new Map();
+  const OUT = /* @__PURE__ */ new Map();
+  for (const b of cfg.blocks) {
+    IN.set(b.id, new Set(universe));
+    OUT.set(b.id, new Set(universe));
+  }
+  IN.set(cfg.entry, /* @__PURE__ */ new Set());
+  const maxIter = cfg.blocks.length * 4 + 10;
+  for (let iter = 0; iter < maxIter; iter++) {
+    let changed = false;
+    for (const b of cfg.blocks) {
+      let inSet;
+      if (b.id === cfg.entry)
+        inSet = /* @__PURE__ */ new Set();
+      else if (P[b.id].length === 0)
+        inSet = /* @__PURE__ */ new Set();
+      else {
+        inSet = new Set(OUT.get(P[b.id][0]));
+        for (let i = 1; i < P[b.id].length; i++) {
+          const po = OUT.get(P[b.id][i]);
+          for (const k of [...inSet])
+            if (!po.has(k))
+              inSet.delete(k);
+        }
+      }
+      const { gen, kill } = genKill[b.id];
+      const outSet = /* @__PURE__ */ new Set();
+      for (const k of inSet)
+        if (!kill.has(k))
+          outSet.add(k);
+      for (const k of gen)
+        outSet.add(k);
+      if (!setEq(inSet, IN.get(b.id)) || !setEq(outSet, OUT.get(b.id))) {
+        changed = true;
+        IN.set(b.id, inSet);
+        OUT.set(b.id, outSet);
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return IN;
+}
+function setEq(a, b) {
+  if (a.size !== b.size)
+    return false;
+  for (const k of a)
+    if (!b.has(k))
+      return false;
+  return true;
+}
+function freeGenKill(block, freeFns) {
+  const gen = /* @__PURE__ */ new Set();
+  const kill = /* @__PURE__ */ new Set();
+  for (const ev of block.events) {
+    if (ev.kind === "call" && ev.callee && freeFns.has(ev.callee) && ev.arg0) {
+      gen.add(ev.arg0);
+      kill.delete(ev.arg0);
+    } else if (ev.kind === "def" && ev.canonStr) {
+      kill.add(ev.canonStr);
+      gen.delete(ev.canonStr);
+    }
+  }
+  return { gen, kill };
+}
+function freeSetIn(cfg, freeFns) {
+  const P = preds(cfg);
+  const genKill = cfg.blocks.map((b) => freeGenKill(b, freeFns));
+  const IN = /* @__PURE__ */ new Map();
+  const OUT = /* @__PURE__ */ new Map();
+  for (const b of cfg.blocks) {
+    IN.set(b.id, /* @__PURE__ */ new Set());
+    OUT.set(b.id, /* @__PURE__ */ new Set());
+  }
+  const maxIter = cfg.blocks.length * 4 + 10;
+  for (let iter = 0; iter < maxIter; iter++) {
+    let changed = false;
+    for (const b of cfg.blocks) {
+      const inSet = /* @__PURE__ */ new Set();
+      for (const p of P[b.id])
+        for (const k of OUT.get(p))
+          inSet.add(k);
+      const { gen, kill } = genKill[b.id];
+      const outSet = /* @__PURE__ */ new Set();
+      for (const k of inSet)
+        if (!kill.has(k))
+          outSet.add(k);
+      for (const k of gen)
+        outSet.add(k);
+      if (!setEq(inSet, IN.get(b.id)) || !setEq(outSet, OUT.get(b.id))) {
+        changed = true;
+        IN.set(b.id, inSet);
+        OUT.set(b.id, outSet);
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return IN;
+}
+function collectFunctions(root, src) {
+  const out = [];
+  const walk = (n) => {
+    if (n.type === "function_definition") {
+      const body = n.childForFieldName("body");
+      if (body && body.type === "compound_statement") {
+        out.push({ name: functionName(n, src), body, startLine: n.startPosition.row + 1 });
+      }
+      return;
+    }
+    for (const c of n.namedChildren)
+      walk(c);
+  };
+  walk(root);
+  return out;
+}
+function functionName(fnDef, src) {
+  let decl = fnDef.childForFieldName("declarator");
+  const seen = /* @__PURE__ */ new Set();
+  while (decl && !seen.has(decl.id)) {
+    seen.add(decl.id);
+    if (decl.type === "identifier")
+      return src.slice(decl.startIndex, decl.endIndex);
+    const inner = decl.childForFieldName("declarator");
+    if (inner) {
+      decl = inner;
+      continue;
+    }
+    const idChild = decl.namedChildren.find((c) => c.type === "identifier");
+    if (idChild)
+      return src.slice(idChild.startIndex, idChild.endIndex);
+    break;
+  }
+  return "<anonymous>";
+}
+function findViolationsDataflow(model, sources, opts = {}) {
+  const log = opts.log ?? (() => {
+  });
+  const maxViolations = opts.maxViolations ?? 40;
+  const refcountCheck = opts.refcountCheck ?? true;
+  const violations = [];
+  for (const { file, text } of sources) {
+    const root = parseC(text);
+    if (!root) {
+      log(`[dataflow] parse failed for ${file}`);
+      continue;
+    }
+    const fns = collectFunctions(root, text);
+    for (const fn of fns) {
+      const cfg = buildCfg(fn.body, text);
+      for (const obj of model.objects) {
+        for (const rule of obj.lockRules) {
+          const acquireFns = rule.acquireFns && rule.acquireFns.length > 0 ? [...rule.acquireFns] : [...DEFAULT_ACQUIRE_FNS];
+          const norm = normalizeLockToken(rule.lock);
+          const ctx = {
+            object: obj.object,
+            acquireFns: new Set(acquireFns),
+            releaseFns: new Set(releaseFnsFor(acquireFns)),
+            lockField: norm.lockField,
+            receiver: norm.receiver,
+            global: norm.global,
+            guardedFields: new Set(rule.guardedFields),
+            guardKey: rule.lock
+          };
+          const touches = cfg.blocks.some((b) => b.events.some((e) => e.kind === "field" && e.field && ctx.guardedFields.has(e.field)));
+          if (!touches)
+            continue;
+          const IN = lockSetIn(cfg, ctx);
+          const flaggedField = /* @__PURE__ */ new Set();
+          for (const b of cfg.blocks) {
+            if (P0(cfg, b.id) && b.id !== cfg.entry)
+              continue;
+            const held = new Set(IN.get(b.id));
+            for (const ev of b.events) {
+              if (ev.kind === "call" && ev.callee && ev.arg0) {
+                if (ctx.acquireFns.has(ev.callee))
+                  held.add(ev.arg0);
+                else if (ctx.releaseFns.has(ev.callee))
+                  held.delete(ev.arg0);
+                continue;
+              }
+              if (ev.kind !== "field" || !ev.field || !ctx.guardedFields.has(ev.field))
+                continue;
+              if (flaggedField.has(ev.field))
+                continue;
+              const required = ctx.global ? norm.key : `${ev.receiver}->${ctx.lockField}`;
+              if (held.has(required))
+                continue;
+              flaggedField.add(ev.field);
+              violations.push({
+                kind: "unlocked-field-access",
+                object: obj.object,
+                file,
+                line: ev.line,
+                functionName: fn.name,
+                invariant: `field '${ev.field}' of ${obj.object} must only be accessed while holding ${ctx.guardKey}`,
+                detail: `${fn.name}() accesses ${ev.canonStr} at line ${ev.line} while ${ctx.guardKey} is NOT in the held-lock set at that program point (lock-set dataflow over the function CFG). ` + (ctx.global ? `Global lock '${norm.key}' is not held on this path.` : `Required lock '${required}' resolved from the access receiver; not held on this path (e.g. released on an earlier branch or never taken).`)
+              });
+            }
+          }
+        }
+        for (const rule of obj.lifecycleRules) {
+          const freeFns = /* @__PURE__ */ new Set([rule.freeFn]);
+          const IN = freeSetIn(cfg, freeFns);
+          const flaggedKey = /* @__PURE__ */ new Set();
+          for (const b of cfg.blocks) {
+            if (P0(cfg, b.id) && b.id !== cfg.entry)
+              continue;
+            const freed = new Set(IN.get(b.id));
+            for (const ev of b.events) {
+              if (ev.kind === "call" && ev.callee && freeFns.has(ev.callee) && ev.arg0) {
+                freed.add(ev.arg0);
+                continue;
+              }
+              if (ev.kind === "def" && ev.canonStr) {
+                freed.delete(ev.canonStr);
+                continue;
+              }
+              if ((ev.kind === "field" || ev.kind === "ref") && ev.base) {
+                const baseFreed = freed.has(ev.base);
+                const exactFreed = ev.canonStr !== void 0 && freed.has(ev.canonStr);
+                let isUAF;
+                let freedThing;
+                if (ev.isAssignTarget) {
+                  isUAF = baseFreed && ev.base !== ev.canonStr;
+                  freedThing = ev.base;
+                } else {
+                  isUAF = baseFreed || exactFreed;
+                  freedThing = baseFreed ? ev.base : ev.canonStr ?? ev.base;
+                }
+                if (!isUAF)
+                  continue;
+                const isUse = ev.isDeref || ev.kind === "ref";
+                if (!isUse)
+                  continue;
+                if (flaggedKey.has(freedThing))
+                  continue;
+                flaggedKey.add(freedThing);
+                violations.push({
+                  kind: "use-after-free-order",
+                  object: obj.object,
+                  file,
+                  line: ev.line,
+                  functionName: fn.name,
+                  invariant: `'${freedThing}' must not be used after ${rule.freeFn}() releases it`,
+                  detail: `${fn.name}() uses ${ev.canonStr} at line ${ev.line} on a path where ${rule.freeFn}(${freedThing}) reaches it with no intervening re-assignment (reaching-free dataflow over the CFG \u2014 a free on a returning error branch does NOT reach this use).`
+                });
+              }
+            }
+          }
+        }
+        if (refcountCheck) {
+          for (const rule of obj.refcountRules) {
+            let getCount = 0;
+            let putCount = 0;
+            let firstPutLine = 0;
+            for (const b of cfg.blocks) {
+              for (const ev of b.events) {
+                if (ev.kind !== "call" || !ev.callee)
+                  continue;
+                if (ev.callee === rule.getFn)
+                  getCount++;
+                else if (ev.callee === rule.putFn) {
+                  putCount++;
+                  if (firstPutLine === 0)
+                    firstPutLine = ev.line;
+                }
+              }
+            }
+            if (putCount > 0 && getCount === 0 && firstPutLine > 0) {
+              violations.push({
+                kind: "refcount-imbalance",
+                object: obj.object,
+                file,
+                line: firstPutLine,
+                functionName: fn.name,
+                invariant: `${rule.name}: every ${rule.putFn}() must be balanced by a prior ${rule.getFn}()`,
+                detail: `${fn.name}() calls ${rule.putFn}() (${putCount}x) but no ${rule.getFn}() \u2014 possible double-put / underflow if the ref wasn't held on entry. WEAK signal (per-function heuristic): the get is often legitimately in a caller (needs a call graph to resolve).`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  violations.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+  const capped = violations.slice(0, maxViolations);
+  log(`[dataflow] ${violations.length} violation candidate(s)${capped.length < violations.length ? ` (capped to ${capped.length})` : ""}`);
+  return capped;
+}
+function P0(cfg, id) {
+  for (const b of cfg.blocks)
+    if (b.succs.has(id))
+      return false;
+  return true;
+}
+
+// packages/core/dist/stages/interproc-refcount.js
+var collapseWs2 = (s) => s.replace(/\s+/g, "");
+function canon2(node, src) {
+  switch (node.type) {
+    case "identifier":
+    case "field_identifier":
+    case "type_identifier":
+      return src.slice(node.startIndex, node.endIndex);
+    case "parenthesized_expression": {
+      const inner = node.namedChildren[0];
+      return inner ? canon2(inner, src) : collapseWs2(src.slice(node.startIndex, node.endIndex));
+    }
+    case "cast_expression": {
+      const value = node.childForFieldName("value");
+      return value ? canon2(value, src) : collapseWs2(src.slice(node.startIndex, node.endIndex));
+    }
+    case "pointer_expression": {
+      const op = node.child(0);
+      const arg = node.childForFieldName("argument") ?? node.namedChildren[0];
+      if (!arg)
+        return collapseWs2(src.slice(node.startIndex, node.endIndex));
+      return op && src.slice(op.startIndex, op.endIndex) === "&" ? canon2(arg, src) : "*" + canon2(arg, src);
+    }
+    case "field_expression": {
+      const arg = node.childForFieldName("argument");
+      const field = node.childForFieldName("field");
+      const base = arg ? canon2(arg, src) : "";
+      const f = field ? src.slice(field.startIndex, field.endIndex) : "";
+      return `${base}->${f}`;
+    }
+    case "subscript_expression": {
+      const arg = node.childForFieldName("argument") ?? node.namedChildren[0];
+      return (arg ? canon2(arg, src) : "") + "[]";
+    }
+    default:
+      return collapseWs2(src.slice(node.startIndex, node.endIndex));
+  }
+}
+var firstIdent2 = (s) => /^[A-Za-z_][A-Za-z0-9_]*/.exec(s)?.[0] ?? s;
+function fieldOf(key) {
+  const idx = key.lastIndexOf("->");
+  return idx === -1 ? "" : key.slice(idx + 2).replace(/\[\]$/, "");
+}
+var NON_REFCOUNT_TOKENS = /* @__PURE__ */ new Set([
+  // plain atomic counters
+  "atomic_inc",
+  "atomic_dec",
+  "atomic_add",
+  "atomic_sub",
+  "atomic_inc_return",
+  "atomic_dec_return",
+  "atomic_dec_and_test",
+  "atomic_add_return",
+  "atomic64_inc",
+  "atomic64_dec",
+  "atomic_long_inc",
+  "atomic_long_dec",
+  "atomic_fetch_inc",
+  "atomic_fetch_dec",
+  // allocation pairs (ownership-by-alloc, not a get/put refcount)
+  "kzalloc",
+  "kmalloc",
+  "kcalloc",
+  "kvzalloc",
+  "kvmalloc",
+  "vmalloc",
+  "vzalloc",
+  "kfree",
+  "kvfree",
+  "vfree",
+  "kmem_cache_alloc",
+  "kmem_cache_zalloc",
+  "kmem_cache_free",
+  "alloc_skb",
+  "alloc_skb_with_frags",
+  "kfree_skb",
+  "consume_skb",
+  "skb_free",
+  "sk_msg_alloc",
+  "sk_msg_free",
+  "sk_msg_free_nocharge",
+  "napi_alloc_skb",
+  // page refs (never the modeled object)
+  "get_page",
+  "put_page",
+  "__free_page",
+  "__free_pages",
+  "free_page",
+  "free_pages",
+  "get_user_pages",
+  "put_user_page",
+  // module refs (never the modeled object)
+  "try_module_get",
+  "__module_get",
+  "module_put"
+]);
+var GET_TOKENS = ["get", "hold", "grab", "_inc", "acquire", "pin", "_ref", "take"];
+var PUT_TOKENS = ["put", "_free", "release", "_dec", "drop", "unref", "unpin", "destroy", "kill"];
+var looksIdentifier = (s) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(s);
+function isRefcountLikeRule(rule) {
+  const g = (rule.getFn ?? "").trim();
+  const p = (rule.putFn ?? "").trim();
+  if (!g || !p || !looksIdentifier(g) || !looksIdentifier(p))
+    return false;
+  if (g === p)
+    return false;
+  const gl = g.toLowerCase();
+  const pl = p.toLowerCase();
+  if (NON_REFCOUNT_TOKENS.has(gl) || NON_REFCOUNT_TOKENS.has(pl))
+    return false;
+  const gLooksGet = GET_TOKENS.some((t) => gl.includes(t));
+  const pLooksPut = PUT_TOKENS.some((t) => pl.includes(t));
+  if (gLooksGet && pLooksPut)
+    return true;
+  const stem = (s) => s.replace(/^(__|_)+/, "").split("_")[0] ?? "";
+  const shareStem = stem(gl).length >= 4 && stem(gl) === stem(pl);
+  return shareStem && (gLooksGet || pLooksPut);
+}
+function isDestructorFamily(name) {
+  return /(?:_|^)(?:destruct(?:or)?|dtor|free|release|evict|reclaim|destroy|put|dealloc|cleanup|teardown|drop|kill)(?:_|$)/i.test(name);
+}
+var line1 = (n) => n.startPosition.row + 1;
+function extractParams(fnDef, src) {
+  const out = /* @__PURE__ */ new Set();
+  const pl = findDescendant(fnDef.childForFieldName("declarator"), "parameter_list");
+  if (!pl)
+    return out;
+  for (const p of pl.namedChildren) {
+    if (p.type !== "parameter_declaration")
+      continue;
+    const id = findDescendant(p.childForFieldName("declarator") ?? p, "identifier");
+    if (id)
+      out.add(src.slice(id.startIndex, id.endIndex));
+  }
+  return out;
+}
+function findDescendant(node, type) {
+  if (!node)
+    return null;
+  const q = [node];
+  while (q.length) {
+    const n = q.shift();
+    if (n.type === type)
+      return n;
+    for (const c of n.namedChildren)
+      q.push(c);
+  }
+  return null;
+}
+function calleeName(call, src) {
+  const fn = call.childForFieldName("function");
+  return fn && fn.type === "identifier" ? src.slice(fn.startIndex, fn.endIndex) : "";
+}
+function isReturnedInline(call) {
+  let n = call;
+  for (; ; ) {
+    const parent = n.parent;
+    if (!parent)
+      return false;
+    if (parent.type === "return_statement")
+      return true;
+    if (parent.type === "parenthesized_expression" || parent.type === "cast_expression") {
+      n = parent;
+      continue;
+    }
+    return false;
+  }
+}
+function resultKeyOf(call, src) {
+  const p = call.parent;
+  if (!p)
+    return void 0;
+  if (p.type === "assignment_expression" && p.childForFieldName("right")?.id === call.id) {
+    const left = p.childForFieldName("left");
+    return left ? canon2(left, src) : void 0;
+  }
+  if (p.type === "init_declarator" && p.childForFieldName("value")?.id === call.id) {
+    const decl = p.childForFieldName("declarator");
+    const id = decl && decl.type === "identifier" ? decl : findDescendant(decl, "identifier");
+    return id ? src.slice(id.startIndex, id.endIndex) : void 0;
+  }
+  return void 0;
+}
+function extractBody(body, src) {
+  const calls = [];
+  const aliases = [];
+  const fieldAliases = [];
+  const returnBases = /* @__PURE__ */ new Set();
+  const noteFieldAlias = (localName, valueNode) => {
+    if (!localName || valueNode.type !== "field_expression")
+      return;
+    const field = fieldOf(canon2(valueNode, src));
+    if (field)
+      fieldAliases.push({ local: localName, field });
+  };
+  const declLocalName = (decl) => {
+    let d = decl;
+    const seen = /* @__PURE__ */ new Set();
+    while (d && !seen.has(d.id)) {
+      seen.add(d.id);
+      if (d.type === "identifier")
+        return src.slice(d.startIndex, d.endIndex);
+      if (d.type === "pointer_declarator" || d.type === "parenthesized_declarator") {
+        d = d.childForFieldName("declarator") ?? d.namedChildren.find((c) => c.type.endsWith("declarator") || c.type === "identifier") ?? null;
+        continue;
+      }
+      return null;
+    }
+    return null;
+  };
+  const walk = (n) => {
+    switch (n.type) {
+      case "call_expression": {
+        const callee = calleeName(n, src);
+        if (callee) {
+          const args = n.childForFieldName("arguments");
+          const a0 = args?.namedChildren[0];
+          calls.push({
+            callee,
+            arg0Key: a0 ? canon2(a0, src) : "",
+            ...resultKeyOf(n, src) ? { resultKey: resultKeyOf(n, src) } : {},
+            returnedInline: isReturnedInline(n),
+            line: line1(n)
+          });
+        }
+        break;
+      }
+      case "assignment_expression": {
+        const left = n.childForFieldName("left");
+        const right = n.childForFieldName("right");
+        if (left && right && right.type === "identifier") {
+          aliases.push({ lhsKey: canon2(left, src), rhsIdent: src.slice(right.startIndex, right.endIndex), line: line1(n) });
+        }
+        if (left && right)
+          noteFieldAlias(left.type === "identifier" ? src.slice(left.startIndex, left.endIndex) : null, right);
+        break;
+      }
+      case "init_declarator": {
+        const decl = n.childForFieldName("declarator");
+        const value = n.childForFieldName("value");
+        if (decl && decl.type === "identifier" && value && value.type === "identifier") {
+          aliases.push({ lhsKey: src.slice(decl.startIndex, decl.endIndex), rhsIdent: src.slice(value.startIndex, value.endIndex), line: line1(n) });
+        }
+        if (decl && value)
+          noteFieldAlias(declLocalName(decl), value);
+        break;
+      }
+      case "return_statement": {
+        const e = n.namedChildren[0];
+        if (e)
+          returnBases.add(firstIdent2(canon2(e, src)));
+        break;
+      }
+    }
+    for (const c of n.namedChildren)
+      walk(c);
+  };
+  walk(body);
+  return { calls, aliases, fieldAliases, returnBases };
+}
+function collectFnDefs(root, src, file) {
+  const out = [];
+  const walk = (n) => {
+    if (n.type === "function_definition") {
+      const body = n.childForFieldName("body");
+      if (body && body.type === "compound_statement") {
+        const { calls, aliases, fieldAliases, returnBases } = extractBody(body, src);
+        out.push({
+          name: fnName(n, src),
+          file,
+          startLine: line1(n),
+          calls,
+          aliases,
+          fieldAliases,
+          returnBases,
+          params: extractParams(n, src)
+        });
+      }
+      return;
+    }
+    for (const c of n.namedChildren)
+      walk(c);
+  };
+  walk(root);
+  return out;
+}
+function fnName(fnDef, src) {
+  let decl = fnDef.childForFieldName("declarator");
+  const seen = /* @__PURE__ */ new Set();
+  while (decl && !seen.has(decl.id)) {
+    seen.add(decl.id);
+    if (decl.type === "identifier")
+      return src.slice(decl.startIndex, decl.endIndex);
+    const inner = decl.childForFieldName("declarator");
+    if (inner) {
+      decl = inner;
+      continue;
+    }
+    const id = decl.namedChildren.find((c) => c.type === "identifier");
+    if (id)
+      return src.slice(id.startIndex, id.endIndex);
+    break;
+  }
+  return "<anonymous>";
+}
+function buildCallGraph(sources) {
+  const fns = [];
+  for (const { file, text } of sources) {
+    const root = parseC(text);
+    if (!root)
+      continue;
+    fns.push(...collectFnDefs(root, text, file));
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const f of fns)
+    if (!byName.has(f.name))
+      byName.set(f.name, f);
+  return { fns, byName };
+}
+function resolveWrapperOps(cg, rule) {
+  const getOps = /* @__PURE__ */ new Map([
+    [rule.getFn, { via: rule.getFn, resolvedFile: "", resolvedLine: 0, rawOp: rule.getFn }]
+  ]);
+  const putOps = /* @__PURE__ */ new Map([
+    [rule.putFn, { via: rule.putFn, resolvedFile: "", resolvedLine: 0, rawOp: rule.putFn }]
+  ]);
+  for (let iter = 0; iter < cg.fns.length + 2; iter++) {
+    let changed = false;
+    for (const fn of cg.fns) {
+      if (!getOps.has(fn.name)) {
+        for (const call of fn.calls) {
+          const seed = getOps.get(call.callee);
+          if (!seed)
+            continue;
+          const produced = call.resultKey ? firstIdent2(call.resultKey) : firstIdent2(call.arg0Key);
+          const returnsAcquired = call.returnedInline || !!produced && fn.returnBases.has(produced);
+          if (returnsAcquired) {
+            getOps.set(fn.name, {
+              via: fn.name,
+              resolvedFile: seed.resolvedFile || fn.file,
+              resolvedLine: seed.resolvedLine || call.line,
+              rawOp: seed.rawOp
+            });
+            changed = true;
+            break;
+          }
+        }
+      }
+      if (!putOps.has(fn.name)) {
+        for (const call of fn.calls) {
+          const seed = putOps.get(call.callee);
+          if (!seed)
+            continue;
+          if (call.arg0Key && fn.params.has(firstIdent2(call.arg0Key))) {
+            putOps.set(fn.name, {
+              via: fn.name,
+              resolvedFile: seed.resolvedFile || fn.file,
+              resolvedLine: seed.resolvedLine || call.line,
+              rawOp: seed.rawOp
+            });
+            changed = true;
+            break;
+          }
+        }
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return { getOps, putOps };
+}
+function findInterprocRefcountCouplings(model, sources, opts = {}) {
+  const log = opts.log ?? (() => {
+  });
+  const maxCouplings = opts.maxCouplings ?? 40;
+  const cg = buildCallGraph(sources);
+  const couplings = [];
+  let rejectedRules = 0;
+  for (const obj of model.objects) {
+    for (const rule of obj.refcountRules) {
+      if (!isRefcountLikeRule(rule)) {
+        rejectedRules++;
+        log(`[interproc-refcount] rejected non-refcount rule "${rule.name}" (${rule.getFn}/${rule.putFn})`);
+        continue;
+      }
+      const { getOps, putOps } = resolveWrapperOps(cg, rule);
+      const allPuts = [];
+      for (const fn of cg.fns) {
+        const inDestructor = isDestructorFamily(fn.name);
+        for (const call of fn.calls) {
+          const seed = putOps.get(call.callee);
+          if (!seed)
+            continue;
+          let argField = fieldOf(call.arg0Key);
+          let fieldViaAlias = false;
+          if (!argField) {
+            const local = firstIdent2(call.arg0Key);
+            const fa = fn.fieldAliases.find((a) => a.local === local);
+            if (fa) {
+              argField = fa.field;
+              fieldViaAlias = true;
+            }
+          }
+          allPuts.push({
+            fn: fn.name,
+            file: fn.file,
+            line: call.line,
+            callee: call.callee,
+            arg0: call.arg0Key,
+            argField,
+            resolvedFile: seed.resolvedFile || fn.file,
+            rawOp: seed.rawOp,
+            matchedBy: "same-var",
+            // refined per get below
+            fromDestructor: inDestructor,
+            fieldViaAlias
+          });
+        }
+      }
+      for (const fn of cg.fns) {
+        for (const call of fn.calls) {
+          const seed = getOps.get(call.callee);
+          if (!seed)
+            continue;
+          const refVar = call.resultKey ? call.resultKey : call.arg0Key;
+          if (!refVar)
+            continue;
+          const refBase = firstIdent2(refVar);
+          const aliasStore = fn.aliases.find((a) => a.rhsIdent === refBase && fieldOf(a.lhsKey));
+          const storedField = aliasStore ? fieldOf(aliasStore.lhsKey) : fieldOf(refVar) || void 0;
+          const getSite = {
+            fn: fn.name,
+            file: fn.file,
+            line: call.line,
+            callee: call.callee,
+            refVar,
+            ...storedField ? { storedField } : {},
+            resolvedFile: seed.resolvedFile || fn.file,
+            resolvedLine: seed.resolvedLine || call.line,
+            rawOp: seed.rawOp
+          };
+          const matched = [];
+          for (const p of allPuts) {
+            const sameVar = p.fn === fn.name && p.file === fn.file && firstIdent2(p.arg0) === refBase && p.line >= call.line;
+            const sameField = storedField !== void 0 && p.argField === storedField;
+            if (sameVar)
+              matched.push({ ...p, matchedBy: "same-var" });
+            else if (sameField)
+              matched.push({ ...p, matchedBy: "stored-field" });
+          }
+          const crossFile = getSite.resolvedFile !== getSite.file || matched.some((p) => p.resolvedFile !== p.file || p.file !== getSite.file);
+          const crossFunction = matched.some((p) => p.fn !== fn.name);
+          const returnedToCaller = fn.returnBases.has(refBase) || call.returnedInline;
+          const sameVarPutCount = matched.filter((p) => p.matchedBy === "same-var").length;
+          let verdict;
+          if (matched.length > 0 || returnedToCaller)
+            verdict = "balanced";
+          else
+            verdict = "leak-suspect";
+          const wrapNote = getSite.callee !== rule.getFn ? `get-wrapper ${getSite.callee}() resolves to ${getSite.rawOp}() @ ${getSite.resolvedFile}:${getSite.resolvedLine}` : `direct ${rule.getFn}()`;
+          const putNote = matched.length === 0 ? "no matching put found in the subsystem" : matched.map((p) => `${p.callee}(${p.arg0}) @ ${p.file}:${p.line} [${p.matchedBy}${p.fromDestructor ? " in destructor/free-path" : ""}${p.fieldViaAlias ? " (field via local copy)" : ""}${p.callee !== rule.putFn ? ` \u2192 ${p.rawOp}() @ ${p.resolvedFile}` : ""}]`).join("; ");
+          couplings.push({
+            object: obj.object,
+            refcount: rule.name,
+            getSite,
+            putSites: matched,
+            crossFile,
+            crossFunction,
+            verdict,
+            sameVarPutCount,
+            detail: `${rule.name}: ${wrapNote}. GET at ${getSite.file}:${getSite.line} in ${getSite.fn}()` + (storedField ? ` stores the ref into ->${storedField}` : "") + `. PUT(s): ${putNote}.` + (crossFile ? " COUPLING SPANS FILES (get/put resolve to a different file than the call site)." : "") + (verdict === "leak-suspect" ? returnedToCaller ? "" : " No release reaches the acquired ref on the analyzed paths \u2014 leak/UAF SUSPECT." : returnedToCaller && matched.length === 0 ? " The ref is RETURNED to the caller (ownership transfer) \u2014 balanced; the caller owns the release." : ` A release is present (${sameVarPutCount} same-var, ${matched.length - sameVarPutCount} via stored field) \u2014 balanced; the candidate is the cross-scope coupling itself.` + (sameVarPutCount >= 2 ? " NOTE: >=2 same-var releases \u2014 likely the exclusive error/success cleanup pair, NOT a double-put; confirming a real double-put needs the path-sensitive CFG (out of scope for this increment)." : ""))
+          });
+        }
+      }
+    }
+  }
+  const rank = (c) => (c.verdict === "balanced" ? 0 : 1) * 0 + // keep all; ordering below
+  (c.crossFile ? 0 : 1);
+  couplings.sort((a, b) => rank(a) - rank(b) || a.getSite.file.localeCompare(b.getSite.file) || a.getSite.line - b.getSite.line);
+  const capped = couplings.slice(0, maxCouplings);
+  log(`[interproc-refcount] ${couplings.length} coupling candidate(s) (${couplings.filter((c) => c.crossFile).length} cross-file, ${couplings.filter((c) => c.verdict !== "balanced").length} imbalance-suspect)${rejectedRules ? `, ${rejectedRules} non-refcount rule(s) rejected` : ""}${capped.length < couplings.length ? ` (capped to ${capped.length})` : ""}`);
+  return capped;
+}
+function couplingsToHuntPlan(model, couplings, includeBalanced = false) {
+  const selected = includeBalanced ? couplings : couplings.filter((c) => c.verdict !== "balanced");
+  const bySite = /* @__PURE__ */ new Map();
+  for (const c of selected) {
+    const hint = `INTER-PROCEDURAL REFCOUNT COUPLING candidate (call-graph resolved). ${c.detail} Verify the get/put balance across all reachable paths \u2014 this pairing spans ${c.crossFile ? "files" : "functions"} and was resolved through refcount-op wrappers, so confirm the wrapper resolution and the field-based cross-function match are real (not a name-collision or an unfollowed alias).`;
+    const existing = bySite.get(c.getSite.file);
+    if (existing)
+      existing.hint = `${existing.hint}
+---
+${hint}`;
+    else
+      bySite.set(c.getSite.file, { path: c.getSite.file, hint });
+  }
+  const brief = {
+    bugClass: `inter-procedural refcount imbalance (seedless, call-graph): ${model.subsystem}`,
+    pattern: `A refcount get/put coupling in ${model.subsystem} is split across functions and/or files: the get and put bottom out in refcount ops (e.g. sock_hold/sock_put) reached only through wrapper functions defined in a different file. A candidate is emitted when the acquired ref has no reaching release (leak/UAF) or a doubled release (double-put). Confirm the call-graph resolution and reject name-collision / unfollowed-alias false positives.`,
+    fixReference: void 0
+  };
+  return { couplings, brief, candidates: [...bySite.values()] };
+}
+
+// packages/core/dist/stages/invariant-spec-builder.js
+var DEFAULT_MAX_CHARS_PER_FILE = 24e3;
+function clipSource(s, n) {
+  return s.length > n ? s.slice(0, n) + `
+...[truncated ${s.length - n} chars]` : s;
+}
+async function extractInvariantSpec(input) {
+  const maxCharsPerFile = input.maxCharsPerFile ?? DEFAULT_MAX_CHARS_PER_FILE;
+  const sourceBlocks = input.sources.map((s) => `### FILE: ${s.file}
+\`\`\`c
+${clipSource(s.text, maxCharsPerFile)}
+\`\`\``).join("\n\n");
+  const messages = [{ role: "user", content: [{ type: "text", text: `## Subsystem source
+
+${sourceBlocks}` }] }];
+  const rt = new LlmApiRuntime({ type: "api", ...input.model ? { model: input.model } : {}, timeout: 3e5 });
+  try {
+    const res = await rt.executeNative(input.system, messages, [input.tool], {
+      onThinking() {
+      },
+      onDelta() {
+      },
+      onText() {
+      },
+      onUsage() {
+      }
+    });
+    const call = (res.content ?? []).find((b) => b.type === "tool_use" && b.name === input.tool.name);
+    return call?.input ?? null;
+  } catch (e) {
+    throw new Error(`${input.errorLabel} LLM call failed: ${String(e).slice(0, 200)}`);
+  }
+}
+
+// packages/core/dist/stages/subsystem-invariant-model.js
+import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, posix, relative, resolve, sep, win32 } from "node:path";
+var INVARIANT_MODEL_VERSION = 1;
+function pathIsWithin(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function resolveContainedSourcePath(sourceRoot, relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/");
+  if (!normalized || normalized.includes("\0") || posix.isAbsolute(normalized) || win32.isAbsolute(normalized) || /^[A-Za-z]:/.test(normalized))
+    return null;
+  const parts = normalized.split("/");
+  if (parts.some((part) => !part || part === "." || part === ".."))
+    return null;
+  try {
+    const rootAbs = resolve(sourceRoot);
+    const candidateAbs = resolve(rootAbs, ...parts);
+    if (!pathIsWithin(rootAbs, candidateAbs))
+      return null;
+    const rootReal = realpathSync(rootAbs);
+    const candidateReal = realpathSync(candidateAbs);
+    return pathIsWithin(rootReal, candidateReal) ? candidateReal : null;
+  } catch {
+    return null;
+  }
+}
+function readSource(sourceRoot, file) {
+  const path = resolveContainedSourcePath(sourceRoot, file);
+  if (!path)
+    return null;
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+var MODEL_TOOL = {
+  name: "emit_invariant_model",
+  description: "Emit the EXPLICIT, STRUCTURED invariant model for each key object in the subsystem: lock discipline, refcount balance, lifetime rules, init-order. This is a MODEL, not a bug report \u2014 do not hunt bugs here; describe the rules the code is SUPPOSED to uphold so a separate deterministic checker can find violations.",
+  input_schema: {
+    type: "object",
+    properties: {
+      objects: {
+        type: "array",
+        description: "One model per key heap object / state machine in the subsystem.",
+        items: {
+          type: "object",
+          properties: {
+            object: { type: "string", description: "The struct/object, e.g. 'struct nfc_llcp_local'." },
+            allocSite: { type: "string", description: "Function where it's allocated (provenance)." },
+            freeSite: { type: "string", description: "Function where it's freed (provenance)." },
+            lockRules: {
+              type: "array",
+              description: "Which lock guards which fields.",
+              items: {
+                type: "object",
+                properties: {
+                  lock: { type: "string", description: "The lock token as written at the acquire site, e.g. 'local->sockets.lock' or 'llcp_devices_lock'." },
+                  guardedFields: { type: "array", items: { type: "string" }, description: "Field names (as written after -> or .) this lock protects from concurrent mutation." },
+                  acquireFns: { type: "array", items: { type: "string" }, description: "Acquire-call tokens, e.g. ['spin_lock','spin_lock_bh','mutex_lock']. Omit for the common defaults." }
+                },
+                required: ["lock", "guardedFields"]
+              }
+            },
+            refcountRules: {
+              type: "array",
+              description: "get/put pairings that must balance.",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string", description: "Human name, e.g. 'nfc_llcp_local ref'." },
+                  getFn: { type: "string", description: "The acquire/get call token, e.g. 'nfc_llcp_local_get' or 'sock_hold'." },
+                  putFn: { type: "string", description: "The release/put call token, e.g. 'nfc_llcp_local_put' or 'sock_put'." }
+                },
+                required: ["name", "getFn", "putFn"]
+              }
+            },
+            lifecycleRules: {
+              type: "array",
+              description: "Free/release calls after which the freed variable must not be used.",
+              items: {
+                type: "object",
+                properties: {
+                  freeFn: { type: "string", description: "The free/release call token, e.g. 'kfree', 'nfc_llcp_local_put', 'sock_put'." },
+                  note: { type: "string", description: "What it frees (provenance)." }
+                },
+                required: ["freeFn"]
+              }
+            },
+            initOrder: { type: "array", items: { type: "string" }, description: "Fields that must be initialized before first use (notes)." }
+          },
+          required: ["object", "lockRules", "refcountRules", "lifecycleRules"]
+        }
+      },
+      notes: { type: "string", description: "Free-form provenance notes about the model." }
+    },
+    required: ["objects"]
+  }
+};
+var MODEL_SYSTEM = "You are a kernel subsystem analyst building a REUSABLE INVARIANT MODEL of a subsystem's key objects. You are given the source. Your job is NOT to find bugs \u2014 it is to describe, per key heap object / state machine, the RULES the code is supposed to uphold, so a separate deterministic checker can later find code that violates them.\n\nFor each key object emit:\n  - LOCK DISCIPLINE: which lock (spinlock/mutex/rwlock/seqlock) guards which FIELDS. Give the lock token EXACTLY as it is written at the acquire site (e.g. 'local->sockets.lock', 'llcp_devices_lock', 'sk->sk_lock.slock'), and the field names exactly as written after '->' or '.'. If a nonstandard acquire wrapper is used, list it in acquireFns.\n  - REFCOUNT BALANCE: the get/put (or hold/put, kref_get/kref_put) call-token PAIRS that must balance.\n  - LIFETIME: the free/release call tokens (kfree, *_put, *_free) after which the object must NOT be used.\n  - INIT-ORDER: fields that must be initialized before first use.\n\nBe precise about TOKENS \u2014 the downstream checker matches your tokens literally against the source, so a lock token or field name that doesn't appear verbatim in the code is useless. Prefer the objects reachable from UNPRIVILEGED syscalls. Emit the model via emit_invariant_model.";
+async function buildInvariantModel(input) {
+  const log = input.log ?? (() => {
+  });
+  if (!input.subsystemFiles || input.subsystemFiles.length === 0) {
+    throw new Error("invariant model build needs at least one subsystemFile");
+  }
+  const sources = [];
+  for (const file of input.subsystemFiles) {
+    const text = readSource(input.sourceRoot, file);
+    if (text == null) {
+      log(`[invariant-model] could not read ${file}`);
+      continue;
+    }
+    sources.push({ file, text });
+  }
+  if (sources.length === 0) {
+    throw new Error("invariant model build could not read any subsystemFile under sourceRoot");
+  }
+  const modelOut = await extractInvariantSpec({
+    sources,
+    system: MODEL_SYSTEM,
+    tool: MODEL_TOOL,
+    ...input.model ? { model: input.model } : {},
+    ...input.maxCharsPerFile !== void 0 ? { maxCharsPerFile: input.maxCharsPerFile } : {},
+    errorLabel: "invariant-model"
+  });
+  const objects = Array.isArray(modelOut?.objects) ? modelOut.objects : [];
+  if (objects.length === 0)
+    throw new Error("model build emitted no objects");
+  const normalized = objects.filter((o) => o && typeof o.object === "string").map((o) => ({
+    object: o.object,
+    ...o.allocSite ? { allocSite: o.allocSite } : {},
+    ...o.freeSite ? { freeSite: o.freeSite } : {},
+    lockRules: Array.isArray(o.lockRules) ? o.lockRules.filter((r) => r && typeof r.lock === "string" && Array.isArray(r.guardedFields)) : [],
+    refcountRules: Array.isArray(o.refcountRules) ? o.refcountRules.filter((r) => r && typeof r.getFn === "string" && typeof r.putFn === "string") : [],
+    lifecycleRules: Array.isArray(o.lifecycleRules) ? o.lifecycleRules.filter((r) => r && typeof r.freeFn === "string") : [],
+    ...Array.isArray(o.initOrder) ? { initOrder: o.initOrder } : {}
+  }));
+  if (normalized.length === 0)
+    throw new Error("model build emitted no well-formed objects");
+  log(`[invariant-model] built model for ${normalized.length} object(s) in ${input.subsystem}`);
+  return {
+    modelVersion: INVARIANT_MODEL_VERSION,
+    subsystem: input.subsystem,
+    subsystemFiles: sources.map((s) => s.file),
+    objects: normalized,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...modelOut?.notes ? { notes: modelOut.notes } : {}
+  };
+}
+function storeInvariantModel(model, path) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(model, null, 2) + "\n", "utf8");
+  return path;
+}
+function loadInvariantModel(path) {
+  const model = JSON.parse(readFileSync(path, "utf8"));
+  if (model.modelVersion !== INVARIANT_MODEL_VERSION) {
+    throw new Error(`stored model is schema v${model.modelVersion}, checker is v${INVARIANT_MODEL_VERSION} \u2014 rebuild the model`);
+  }
+  if (!Array.isArray(model.objects))
+    throw new Error("stored model has no objects array");
+  return model;
+}
+var CONTROL_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "do",
+  "else",
+  "return",
+  "sizeof",
+  "typeof",
+  "__attribute__",
+  "case",
+  "default",
+  "goto",
+  "asm",
+  "__asm__",
+  "static_assert"
+]);
+function blankCommentsAndStrings(src) {
+  const out = src.split("");
+  let i = 0;
+  const n = src.length;
+  const blank = (a, b) => {
+    for (let k = a; k < b && k < n; k++)
+      if (out[k] !== "\n")
+        out[k] = " ";
+  };
+  while (i < n) {
+    const c = src[i];
+    const c2 = src[i + 1];
+    if (c === "/" && c2 === "/") {
+      let j = i + 2;
+      while (j < n && src[j] !== "\n")
+        j++;
+      blank(i, j);
+      i = j;
+    } else if (c === "/" && c2 === "*") {
+      let j = i + 2;
+      while (j < n && !(src[j] === "*" && src[j + 1] === "/"))
+        j++;
+      j = Math.min(n, j + 2);
+      blank(i, j);
+      i = j;
+    } else if (c === '"' || c === "'") {
+      const quote = c;
+      let j = i + 1;
+      while (j < n) {
+        if (src[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (src[j] === quote) {
+          j++;
+          break;
+        }
+        if (src[j] === "\n")
+          break;
+        j++;
+      }
+      blank(i, j);
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  return out.join("");
+}
+function lineAt(src, offset) {
+  let line = 1;
+  for (let k = 0; k < offset && k < src.length; k++)
+    if (src[k] === "\n")
+      line++;
+  return line;
+}
+var IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/;
+function splitCFunctions(src) {
+  const blanked = blankCommentsAndStrings(src);
+  const fns = [];
+  let depth = 0;
+  const n = blanked.length;
+  for (let i = 0; i < n; i++) {
+    const ch = blanked[i];
+    if (ch === "{") {
+      if (depth === 0) {
+        let j = i - 1;
+        while (j >= 0 && /\s/.test(blanked[j]))
+          j--;
+        if (j >= 0 && blanked[j] === ")") {
+          let pd = 0;
+          let k = j;
+          for (; k >= 0; k--) {
+            if (blanked[k] === ")")
+              pd++;
+            else if (blanked[k] === "(") {
+              pd--;
+              if (pd === 0)
+                break;
+            }
+          }
+          if (k >= 0) {
+            let m = k - 1;
+            while (m >= 0 && /\s/.test(blanked[m]))
+              m--;
+            let e = m;
+            while (e >= 0 && /[A-Za-z0-9_]/.test(blanked[e]))
+              e--;
+            const name = blanked.slice(e + 1, m + 1).trim();
+            if (name && IDENT_RE.test(name) && !CONTROL_KEYWORDS.has(name)) {
+              let bd = 0;
+              let end = i;
+              for (; end < n; end++) {
+                if (blanked[end] === "{")
+                  bd++;
+                else if (blanked[end] === "}") {
+                  bd--;
+                  if (bd === 0)
+                    break;
+                }
+              }
+              let sigStart = e + 1;
+              while (sigStart > 0 && blanked[sigStart - 1] !== "\n")
+                sigStart--;
+              fns.push({
+                name,
+                startLine: lineAt(src, sigStart),
+                endLine: lineAt(src, end),
+                text: src.slice(sigStart, Math.min(n, end + 1)),
+                startOffset: sigStart
+              });
+              depth = 0;
+              i = end;
+              continue;
+            }
+          }
+        }
+      }
+      depth++;
+    } else if (ch === "}") {
+      if (depth > 0)
+        depth--;
+    }
+  }
+  return fns;
+}
+var DEFAULT_ACQUIRE_FNS2 = [
+  "spin_lock",
+  "spin_lock_bh",
+  "spin_lock_irq",
+  "spin_lock_irqsave",
+  "spin_trylock",
+  "raw_spin_lock",
+  "raw_spin_lock_bh",
+  "raw_spin_lock_irqsave",
+  "mutex_lock",
+  "mutex_lock_interruptible",
+  "mutex_trylock",
+  "read_lock",
+  "read_lock_bh",
+  "write_lock",
+  "write_lock_bh",
+  "down",
+  "down_read",
+  "down_write",
+  "down_interruptible"
+];
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function bodyHoldsLock(blankedBody, lock, acquireFns) {
+  const lockRe = escapeRe(lock);
+  for (const fn of acquireFns) {
+    const re = new RegExp(`\\b${escapeRe(fn)}\\s*\\(\\s*&?\\s*${lockRe}\\b`);
+    if (re.test(blankedBody))
+      return true;
+  }
+  return false;
+}
+function fieldAccessLines(blankedBody, bodyStartLine, field) {
+  const re = new RegExp(`(->|\\.)\\s*${escapeRe(field)}\\b`, "g");
+  const lines = [];
+  let m;
+  while ((m = re.exec(blankedBody)) !== null) {
+    lines.push(bodyStartLine + countNewlines(blankedBody, m.index));
+  }
+  return lines;
+}
+function countNewlines(s, upto) {
+  let c = 0;
+  for (let k = 0; k < upto && k < s.length; k++)
+    if (s[k] === "\n")
+      c++;
+  return c;
+}
+function parseFreeCall(blankedBody, callIndex, fn) {
+  const open = blankedBody.indexOf("(", callIndex + fn.length);
+  if (open === -1)
+    return null;
+  let depth = 0;
+  let firstArgEnd = -1;
+  let callEnd = -1;
+  for (let end = open + 1; end < blankedBody.length; end++) {
+    const ch = blankedBody[end];
+    if (ch === "(")
+      depth++;
+    else if (ch === ")") {
+      if (depth === 0) {
+        callEnd = end + 1;
+        if (firstArgEnd === -1)
+          firstArgEnd = end;
+        break;
+      }
+      depth--;
+    } else if (ch === "," && depth === 0 && firstArgEnd === -1) {
+      firstArgEnd = end;
+    }
+  }
+  if (firstArgEnd === -1 || callEnd === -1)
+    return null;
+  const arg = blankedBody.slice(open + 1, firstArgEnd).trim();
+  const m = /^&?\s*([A-Za-z_][A-Za-z0-9_]*)/.exec(arg);
+  return m ? { freedVar: m[1], callEnd } : null;
+}
+function findInvariantViolations(model, sources, opts = {}) {
+  return findViolationsDataflow(model, sources, {
+    ...opts.maxViolations !== void 0 ? { maxViolations: opts.maxViolations } : {},
+    ...opts.refcountCheck !== void 0 ? { refcountCheck: opts.refcountCheck } : {},
+    ...opts.log ? { log: opts.log } : {}
+  });
+}
+function findInvariantViolationsTokenLevel(model, sources, opts = {}) {
+  const log = opts.log ?? (() => {
+  });
+  const maxViolations = opts.maxViolations ?? 40;
+  const refcountCheck = opts.refcountCheck ?? true;
+  const violations = [];
+  for (const { file, text } of sources) {
+    const blanked = blankCommentsAndStrings(text);
+    const fns = splitCFunctions(text);
+    for (const fn of fns) {
+      const bStart = fn.startOffset;
+      const bEnd = bStart + fn.text.length;
+      const blankedBody = blanked.slice(bStart, bEnd);
+      const bodyStartLine = fn.startLine;
+      for (const obj of model.objects) {
+        for (const rule of obj.lockRules) {
+          const acquireFns = rule.acquireFns && rule.acquireFns.length > 0 ? rule.acquireFns : DEFAULT_ACQUIRE_FNS2;
+          const holds = bodyHoldsLock(blankedBody, rule.lock, acquireFns);
+          if (holds)
+            continue;
+          for (const field of rule.guardedFields) {
+            const lines = fieldAccessLines(blankedBody, bodyStartLine, field);
+            if (lines.length === 0)
+              continue;
+            violations.push({
+              kind: "unlocked-field-access",
+              object: obj.object,
+              file,
+              line: lines[0],
+              functionName: fn.name,
+              invariant: `field '${field}' of ${obj.object} must only be accessed while holding ${rule.lock}`,
+              detail: `${fn.name}() accesses ->${field} (line ${lines[0]}${lines.length > 1 ? `, +${lines.length - 1} more` : ""}) but never acquires ${rule.lock} in this function body. Confirm the lock isn't held by a caller (intra-procedural check \u2014 caller-held locks are a false positive).`
+            });
+          }
+        }
+        for (const rule of obj.lifecycleRules) {
+          const callRe = new RegExp(`\\b${escapeRe(rule.freeFn)}\\s*\\(`, "g");
+          let cm;
+          while ((cm = callRe.exec(blankedBody)) !== null) {
+            const parsed = parseFreeCall(blankedBody, cm.index, rule.freeFn);
+            if (!parsed)
+              continue;
+            const { freedVar, callEnd } = parsed;
+            const freeLine = bodyStartLine + countNewlines(blankedBody, cm.index);
+            const useRe = new RegExp(`\\b${escapeRe(freedVar)}\\b`, "g");
+            useRe.lastIndex = callEnd;
+            let um;
+            while ((um = useRe.exec(blankedBody)) !== null) {
+              const after = blankedBody.slice(um.index + freedVar.length);
+              if (/^\s*=[^=]/.test(after))
+                break;
+              const isDeref = /^\s*(->|\[)/.test(after);
+              const isCallArg = /^\s*[,)]/.test(after);
+              if (isDeref || isCallArg) {
+                const useLine = bodyStartLine + countNewlines(blankedBody, um.index);
+                violations.push({
+                  kind: "use-after-free-order",
+                  object: obj.object,
+                  file,
+                  line: useLine,
+                  functionName: fn.name,
+                  invariant: `'${freedVar}' must not be used after ${rule.freeFn}() releases it`,
+                  detail: `${fn.name}() calls ${rule.freeFn}(${freedVar}) at line ${freeLine}, then uses ${freedVar} again at line ${useLine}. Confirm this isn't a different-object reassignment or a path where the free didn't run (intra-procedural, path-insensitive check).`
+                });
+                break;
+              }
+            }
+          }
+        }
+        if (refcountCheck) {
+          for (const rule of obj.refcountRules) {
+            const getCount = (blankedBody.match(new RegExp(`\\b${escapeRe(rule.getFn)}\\s*\\(`, "g")) ?? []).length;
+            const putM = new RegExp(`\\b${escapeRe(rule.putFn)}\\s*\\(`, "g").exec(blankedBody);
+            const putCount = (blankedBody.match(new RegExp(`\\b${escapeRe(rule.putFn)}\\s*\\(`, "g")) ?? []).length;
+            if (putCount > 0 && getCount === 0 && putM) {
+              const putLine = bodyStartLine + countNewlines(blankedBody, putM.index);
+              violations.push({
+                kind: "refcount-imbalance",
+                object: obj.object,
+                file,
+                line: putLine,
+                functionName: fn.name,
+                invariant: `${rule.name}: every ${rule.putFn}() must be balanced by a prior ${rule.getFn}()`,
+                detail: `${fn.name}() calls ${rule.putFn}() (${putCount}x) but no ${rule.getFn}() \u2014 possible double-put / underflow if the ref wasn't held on entry. WEAK signal: the get is often legitimately in a caller.`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  violations.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+  const capped = violations.slice(0, maxViolations);
+  log(`[invariant-check] ${violations.length} violation candidate(s)${capped.length < violations.length ? ` (capped to ${capped.length})` : ""}`);
+  return capped;
+}
+var KIND_LABEL = {
+  "unlocked-field-access": "UNLOCKED FIELD ACCESS",
+  "use-after-free-order": "USE-AFTER-FREE ORDER",
+  "refcount-imbalance": "REFCOUNT IMBALANCE"
+};
+function violationsToHuntPlan(model, violations) {
+  const bySite = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const hint = `${KIND_LABEL[v.kind]} candidate (deterministic, from stored invariant model). Invariant: ${v.invariant}. Site: ${v.file}:${v.line} in ${v.functionName}(). ${v.detail}`;
+    const existing = bySite.get(v.file);
+    if (existing)
+      existing.hint = `${existing.hint}
+---
+${hint}`;
+    else
+      bySite.set(v.file, { path: v.file, hint });
+  }
+  const kinds = [...new Set(violations.map((v) => v.kind))].map((k) => KIND_LABEL[k]).join(", ");
+  const brief = {
+    bugClass: `invariant-model violation (seedless): ${kinds || "lock/refcount/lifetime discipline"}`,
+    pattern: `A key object in ${model.subsystem} violates its modeled invariant \u2014 a guarded field touched without its lock, a variable used after free, or an unbalanced refcount put. The candidate sites below were found by a deterministic checker against the stored invariant model; verify each is a real, reachable violation and not a caller-held-lock / path-insensitive false positive.`,
+    fixReference: void 0
+  };
+  return { model, violations, brief, candidates: [...bySite.values()] };
+}
+async function runSubsystemInvariantHunt(input) {
+  const log = input.log ?? (() => {
+  });
+  let model;
+  let modelLoaded = false;
+  if (!input.rebuildModel) {
+    try {
+      model = loadInvariantModel(input.modelPath);
+      modelLoaded = true;
+      log(`[invariant] loaded stored model ${input.modelPath} (${model.objects.length} object(s)) \u2014 no LLM call`);
+    } catch {
+      model = await buildInvariantModel(input);
+      storeInvariantModel(model, input.modelPath);
+      log(`[invariant] built + stored model ${input.modelPath}`);
+    }
+  } else {
+    model = await buildInvariantModel(input);
+    storeInvariantModel(model, input.modelPath);
+    log(`[invariant] rebuilt + stored model ${input.modelPath}`);
+  }
+  const sources = [];
+  for (const file of input.subsystemFiles) {
+    const text = readSource(input.sourceRoot, file);
+    if (text != null)
+      sources.push({ file, text });
+  }
+  if (sources.length === 0)
+    throw new Error("invariant hunt could not read any subsystemFile under sourceRoot");
+  const violations = findInvariantViolations(model, sources, { ...input.findOptions, log });
+  const plan = violationsToHuntPlan(model, violations);
+  if (input.skipHunt || plan.candidates.length === 0) {
+    return { model, modelPath: input.modelPath, modelLoaded, violations, plan };
+  }
+  const verify = input.verify ?? makeSkepticVerifier({ sourceRoot: input.sourceRoot, runtime: input.runtime });
+  const hunt = await runHuntScan({
+    sourceRoot: input.sourceRoot,
+    candidates: plan.candidates,
+    brief: plan.brief,
+    runtime: input.runtime,
+    ...input.finderModels && input.finderModels.length > 0 ? { models: input.finderModels } : {},
+    verify,
+    ...input.exploitability ? { exploitability: input.exploitability } : {},
+    log
+  });
+  return { model, modelPath: input.modelPath, modelLoaded, violations, plan, hunt };
+}
+
+// packages/core/dist/stages/dynamic-witness.js
+import { createHash } from "node:crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function dualViewCandidateFromContext(ctx, assumption, bodies, subsystem) {
+  if (!ctx.dualView || !ctx.object || !ctx.pairedEntry)
+    return null;
+  const entryA = ctx.pairedEntry;
+  const entryB = ctx.caller;
+  const sources = [];
+  const push = (label, fn) => {
+    const code = bodies.get(fn);
+    if (code)
+      sources.push({ label, fn, code });
+  };
+  push("entryA (establishing view)", entryA);
+  push("entryB (skipping view)", entryB);
+  if (assumption.subject !== entryA && assumption.subject !== entryB) {
+    push("relied-on subject", assumption.subject);
+  }
+  return {
+    assumptionId: ctx.assumptionId,
+    subsystem,
+    object: ctx.object,
+    subject: ctx.subject,
+    entryA,
+    entryB,
+    establisherToken: ctx.establisherToken,
+    kind: assumption.kind,
+    securityRelevance: assumption.securityRelevance,
+    predicate: assumption.predicate,
+    unprivEntry: ctx.unprivEntry,
+    sources,
+    detail: ctx.detail
+  };
+}
+var DEFAULT_RACE_THREADS = 4;
+var DEFAULT_RACE_ITERS = 2e5;
+var DEFAULT_RACE_CONFIG = { threads: DEFAULT_RACE_THREADS, iters: DEFAULT_RACE_ITERS };
+var RACE_SHAPED_KINDS = /* @__PURE__ */ new Set([
+  "lock-held",
+  "ownership-exclusive",
+  "refcount-positive",
+  "called-once",
+  "revalidated"
+]);
+function isRaceShapedCandidate(c) {
+  if (RACE_SHAPED_KINDS.has(c.kind))
+    return true;
+  if (c.unprivEntry && (c.securityRelevance === "lifetime" || c.securityRelevance === "type"))
+    return true;
+  return false;
+}
+function resolveWitnessMode(mode, c) {
+  if (mode === "single")
+    return "single";
+  if (mode === "race")
+    return "race";
+  return isRaceShapedCandidate(c) ? "race" : "single";
+}
+var SYNTH_SYSTEM = "You are a world-class Linux kernel exploit engineer writing a PROOF-OF-CONCEPT trigger, not a description. You are given a DUAL-VIEW / CROSS-PHASE assumption candidate: a long-lived kernel object reached by TWO distinct entries/phases, where entry A establishes a guarantee (a held lock / a validated ref / an exclusive owner / a once-only init) and entry B reaches the SAME object WITHOUT re-establishing it. Your job: produce a SELF-CONTAINED, UNPRIVILEGED C program that (a) sets up the object via entry A's path to establish the assumed state, (b) drives entry B's path in the way that VIOLATES entry A's assumption on the SAME object instance, and (c) triggers the dereference/use that would fault \u2014 aiming for a KASAN use-after-free / out-of-bounds / double-free on the candidate's object.\n\nHARD RULES:\n  1. Output ONE complete C file in a single ```c fenced block. It must compile with `gcc -O0 -static -o poc poc.c -lpthread` on a modern glibc. No external headers beyond libc/uapi; if a syscall wrapper is missing, use syscall(2) with the __NR_ number directly.\n  2. Drop privileges early: call setuid(65534)/setgid(65534) after any setup that is itself unprivileged, so the trigger runs as an UNPRIVILEGED user (the whole point \u2014 the object must be reachable without root). If the whole flow is unprivileged (SCM_RIGHTS, AF_UNIX, io_uring, fuse mounts in a userns), drop immediately.\n  3. To hit a cross-phase RACE, spawn threads that hammer entry A and entry B concurrently on the SAME object (the same fd / same socket / same registered buffer), pinned to CPUs if it helps, looping thousands of times.\n  4. Do NOT print fabricated kernel logs. NEVER printf a 'BUG: KASAN' / 'use-after-free' / 'general protection' string \u2014 the witness is the KERNEL's splat on the serial console, and a PoC that prints one is rejected as fabrication. Print only your own progress markers.\n  5. Make it deterministic-ish and bounded: exit within ~20s even if it does not trigger (the harness caps the run). Emit via the fenced C block only; a one-paragraph plan before it is fine.";
+var RACE_SYNTH_SYSTEM = "You are a world-class Linux kernel exploit engineer writing a genuinely CONCURRENT, MULTI-THREAD PROOF-OF-CONCEPT race trigger, not a description and not a single-threaded stub. You are given a DUAL-VIEW / CROSS-PHASE assumption candidate whose violation is a RACE: a long-lived kernel object reached by TWO distinct entries/phases, where entry A holds a guarantee (a held lock / a validated ref / an exclusive owner / a live refcount) and entry B, run CONCURRENTLY on the SAME object instance, tears it down or mutates it out from under A \u2014 the DirtyCred/DirtyPipe class (a put racing a use, a same-type object swapped mid-use, a double-fetch, a concurrent teardown). Your job: produce a SELF-CONTAINED, UNPRIVILEGED C program that races entry A against entry B on the SAME object to trip a KASAN use-after-free / out-of-bounds / double-free.\n\nHARD RULES:\n  1. Output ONE complete C file in a single ```c fenced block. It MUST compile with `gcc -O0 -static -o poc poc.c -lpthread` on a modern glibc. Include <pthread.h>, <sched.h>, <unistd.h>. No external headers beyond libc/uapi; if a syscall wrapper is missing, use syscall(2) with __NR_ directly.\n  2. GENUINELY CONCURRENT STRUCTURE \u2014 all of these, not a sketch:\n     \u2022 A `pthread_barrier_t` start barrier so every worker begins the contended window at the SAME instant (initialize it for exactly the number of threads that wait on it, and have each worker `pthread_barrier_wait` before its hammer loop).\n     \u2022 N worker threads via `pthread_create` \u2014 roughly half driving entry A's path, half driving entry B's path, all on the SAME shared object (same fd / same socket / same registered buffer/id).\n     \u2022 CPU PINNING: each worker calls `sched_setaffinity` onto a DISTINCT core (cpu = worker_index % get_nprocs()) so A and B run on different physical CPUs and actually overlap.\n     \u2022 A tight HAMMER LOOP of a HIGH iteration count (100000+ per thread) around the contended syscall pair, and an OUTER loop that RE-ARMS the object (re-create/re-register) each attempt so the window is retried many times \u2014 a race almost never fires on the first pass.\n  3. Drop privileges early (setuid/setgid to 65534) once setup is unprivileged, OR run fully unprivileged from the start (SCM_RIGHTS, AF_UNIX, io_uring, userns) \u2014 the object must be reachable without root.\n  4. Do NOT print fabricated kernel logs. NEVER printf a 'BUG: KASAN' / 'use-after-free' / 'general protection' string \u2014 the witness is the KERNEL's splat on serial; a PoC that prints one is rejected as fabrication. Print only your own progress markers (e.g. iteration counts).\n  5. Bounded: cap total wall time (~20s) with an overall attempt ceiling and join all threads before exit, so it terminates even when the race does not fire (the harness also caps the run). Emit the fenced C block; a one-paragraph plan before it is fine.";
+function raceScaffoldSpec(c, race) {
+  return `## RACE SYNTHESIS \u2014 emit a CONCURRENT multi-thread PoC
+This seam is race-shaped: the violation of '${c.predicate}' on struct ${c.object} is a concurrent interleave, NOT a sequential A-then-B ordering. A single-threaded PoC CANNOT witness it. Race entry A (${c.entryA}, which establishes ${c.establisherToken}) against entry B (${c.entryB}, which skips it) on the SAME struct ${c.object} instance.
+
+REQUIRED structure (all must appear in the emitted C):
+- pthread_barrier_t start barrier; every worker pthread_barrier_wait()s before the hammer loop.
+- ${race.threads} worker threads via pthread_create: ~half drive ${c.entryA}'s syscall path, ~half drive ${c.entryB}'s, all on ONE shared object.
+- sched_setaffinity pinning each worker to a distinct CPU (cpu = idx % get_nprocs()).
+- a per-thread hammer loop of ${race.iters}+ iterations around the contended syscalls, inside an outer loop that RE-ARMS the object each attempt.
+- join all threads; bounded ~20s wall clock; no fabricated splat strings.
+`;
+}
+function buildRaceSynthesisPrompt(input) {
+  const c = input.candidate;
+  const race = input.race ?? DEFAULT_RACE_CONFIG;
+  const excerpts = c.sources.map((s) => `### ${s.label} \u2014 ${s.fn}()
+\`\`\`c
+${clip(s.code, 8e3)}
+\`\`\``).join("\n\n");
+  const header = `## Dual-view RACE candidate (subsystem: ${c.subsystem})
+- object (type reached + contended by both views): struct ${c.object}
+- entry A (ESTABLISHES ${c.establisherToken}): ${c.entryA}()
+- entry B (SKIPS ${c.establisherToken}, race it): ${c.entryB}()
+- relied-on subject: ${c.subject}()
+- assumption kind: ${c.kind} (${c.securityRelevance})
+- relied-on precondition (entry B races to violate): ${c.predicate}
+- unprivileged-reachable entry B: ${c.unprivEntry ? "yes" : "unknown"}
+
+${c.detail}
+`;
+  if (input.round > 1) {
+    return `${header}
+${raceScaffoldSpec(c, race)}
+## Prior race PoC (round ${input.round - 1}) did NOT witness the bug \u2014 FIX it.
+\`\`\`c
+${clip(input.priorCSource ?? "", 9e3)}
+\`\`\`
+
+## Boot feedback (compile error, or serial/dmesg with NO object-bound KASAN splat)
+\`\`\`
+${clip(input.priorFeedback ?? "(none captured)", 6e3)}
+\`\`\`
+
+Diagnose why the race did not fire (window too narrow? threads not on the same instance? barrier/affinity missing? too few iterations? compile error?) and emit a corrected complete concurrent C file that keeps the required race structure.
+
+## Source excerpts
+
+${excerpts}`;
+  }
+  return `${header}
+${raceScaffoldSpec(c, race)}
+## Source excerpts
+
+${excerpts}
+
+Synthesize the concurrent race PoC now.`;
+}
+function buildSynthesisPrompt(input) {
+  if (input.mode === "race")
+    return buildRaceSynthesisPrompt(input);
+  const c = input.candidate;
+  const excerpts = c.sources.map((s) => `### ${s.label} \u2014 ${s.fn}()
+\`\`\`c
+${clip(s.code, 8e3)}
+\`\`\``).join("\n\n");
+  const header = `## Dual-view assumption candidate (subsystem: ${c.subsystem})
+- object (type reached by both views): struct ${c.object}
+- entry A (ESTABLISHES ${c.establisherToken}): ${c.entryA}()
+- entry B (SKIPS ${c.establisherToken}): ${c.entryB}()
+- relied-on subject: ${c.subject}()
+- assumption kind: ${c.kind} (${c.securityRelevance})
+- relied-on precondition (entry B may violate): ${c.predicate}
+- unprivileged-reachable entry B: ${c.unprivEntry ? "yes" : "unknown"}
+
+${c.detail}
+`;
+  if (input.round > 1) {
+    return `${header}
+## Prior PoC (round ${input.round - 1}) did NOT witness the bug \u2014 FIX it.
+\`\`\`c
+${clip(input.priorCSource ?? "", 9e3)}
+\`\`\`
+
+## Boot feedback (compile error, or serial/dmesg with NO object-bound KASAN splat)
+\`\`\`
+${clip(input.priorFeedback ?? "(none captured)", 6e3)}
+\`\`\`
+
+Diagnose why it did not trigger (wrong syscall sequence? never reached entry B on the same instance? window too narrow? compile error?) and emit a corrected complete C file.
+
+## Source excerpts
+
+${excerpts}`;
+  }
+  return `${header}
+## Source excerpts
+
+${excerpts}
+
+Synthesize the PoC now.`;
+}
+function clip(s, n) {
+  return s.length > n ? s.slice(0, n) + `
+/* ...[truncated ${s.length - n} chars] */` : s;
+}
+function extractCFromLlmOutput(text) {
+  if (!text)
+    return null;
+  const fenced = text.match(/```(?:c|cpp|c\+\+)?\s*\n([\s\S]*?)```/i);
+  if (fenced && fenced[1].trim())
+    return fenced[1].replace(/\s+$/, "") + "\n";
+  if (/#include\b|\bint\s+main\s*\(/.test(text))
+    return text.replace(/\s+$/, "") + "\n";
+  return null;
+}
+function makeDefaultSynthesizePoc(_runtime, model, timeoutMs = 3e5) {
+  return async (input) => {
+    const rt = new LlmApiRuntime({ type: "api", timeout: timeoutMs, ...model ? { model } : {} });
+    const system = input.mode === "race" ? RACE_SYNTH_SYSTEM : SYNTH_SYSTEM;
+    const res = await rt.executeNative(system, [{ role: "user", content: [{ type: "text", text: buildSynthesisPrompt(input) }] }], []);
+    const text = (res.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("\n");
+    const cSource = extractCFromLlmOutput(text);
+    if (!cSource)
+      return null;
+    return { cSource };
+  };
+}
+var defaultBootPoc = (cSource) => {
+  const report = {
+    raw: "",
+    crashType: "unknown",
+    faultingFunction: "unknown",
+    stackFrames: [],
+    reproducer: cSource,
+    reproducerLanguage: "c"
+  };
+  return runReproducerInKernelVm(report);
+};
+var WITNESS_SIGNATURES = [
+  { pattern: /KASAN:\s+slab-use-after-free|KASAN:.*use-after-free|use-after-free in/i, signature: "kasan-uaf" },
+  { pattern: /KASAN:\s+slab-out-of-bounds|KASAN:.*out-of-bounds|out-of-bounds in/i, signature: "kasan-oob" },
+  { pattern: /KASAN:.*double-free|double-free or invalid-free/i, signature: "kasan-double-free" },
+  { pattern: /KASAN:.*invalid-free/i, signature: "kasan-invalid-free" },
+  { pattern: /KASAN:.*stack-out-of-bounds/i, signature: "kasan-stack-oob" }
+];
+var ANY_CRASH = /BUG:\s*KASAN|KASAN:\s*(?:slab-|global-|stack-|vmalloc-|use-after-free|out-of-bounds|invalid-free|double-free)|UBSAN|general protection fault|NULL pointer dereference|kernel NULL pointer|BUG:\s*KCSAN/i;
+function candidateReferenceTokens(c) {
+  const toks = /* @__PURE__ */ new Set();
+  for (const t of [c.object, c.subject, c.entryA, c.entryB, ...c.sources.map((s) => s.fn)]) {
+    const s = (t ?? "").trim();
+    if (s && s.length >= 4)
+      toks.add(s);
+  }
+  return [...toks];
+}
+function extractSplatRegion(dmesg) {
+  if (!dmesg)
+    return null;
+  const lines = dmesg.split(/\r?\n/);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/BUG:\s*KASAN|KASAN:\s*(slab|global|stack|use-after|out-of|double-free|invalid-free)|general protection fault|NULL pointer dereference/i.test(lines[i])) {
+      start = i;
+      break;
+    }
+  }
+  if (start < 0)
+    return null;
+  if (start > 0 && /^={5,}\s*$/.test(lines[start - 1].replace(/^\[\s*\d+\.\d+\]\s*/, "").trim()))
+    start -= 1;
+  let end = Math.min(lines.length, start + 80);
+  for (let i = start + 1; i < Math.min(lines.length, start + 120); i++) {
+    if (/^={5,}\s*$/.test(lines[i].replace(/^\[\s*\d+\.\d+\]\s*/, "").trim())) {
+      end = i + 1;
+      break;
+    }
+  }
+  return lines.slice(start, end).join("\n");
+}
+function pocFabricatesSplat(cSource, dmesg) {
+  if (!cSource || !dmesg)
+    return false;
+  const src = cSource;
+  for (const line of dmesg.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t.length < 12)
+      continue;
+    if (!ANY_CRASH.test(t))
+      continue;
+    const bare = t.replace(/^\[\s*\d+\.\d+\]\s*/, "");
+    if (bare.length >= 12 && src.includes(bare))
+      return true;
+  }
+  return false;
+}
+function checkWitness(candidate, cSource, result) {
+  const dmesg = `${result.dmesg ?? ""}
+${result.output ?? ""}`;
+  const splat = extractSplatRegion(dmesg);
+  if (!result.executed) {
+    return { witnessed: false, objectBound: false, reason: result.compiled ? "PoC compiled but did not execute in the VM" : "PoC did not compile", ...splat ? { splat } : {} };
+  }
+  const sigHit = WITNESS_SIGNATURES.find((s) => s.pattern.test(dmesg));
+  if (!sigHit) {
+    return { witnessed: false, objectBound: false, reason: ANY_CRASH.test(dmesg) ? "a kernel crash fired but not a promote-class KASAN UAF/OOB/double-free splat" : "no KASAN splat in the boot output", ...splat ? { splat } : {} };
+  }
+  if (pocFabricatesSplat(cSource, dmesg)) {
+    return { witnessed: false, objectBound: false, signature: sigHit.signature, reason: "REJECTED: a splat line is a verbatim substring of the PoC source \u2014 fabricated, not a kernel-emitted splat", ...splat ? { splat } : {} };
+  }
+  const region = splat ?? dmesg;
+  const tokens = candidateReferenceTokens(candidate);
+  const boundTo = tokens.find((t) => new RegExp(`\\b${escapeRe2(t)}\\b`).test(region));
+  if (!boundTo) {
+    return { witnessed: false, objectBound: false, signature: sigHit.signature, reason: `KASAN ${sigHit.signature} splat fired but is NOT bound to the candidate \u2014 no candidate object/function [${tokens.join(", ")}] appears in the splat (incidental splat)`, ...splat ? { splat } : {} };
+  }
+  return {
+    witnessed: true,
+    objectBound: true,
+    signature: sigHit.signature,
+    boundTo,
+    ...splat ? { splat } : {},
+    reason: `object-bound ${sigHit.signature}: the splat references '${boundTo}' (the candidate's ${boundTo === candidate.object ? "object type" : "entry/subject"}) \u2014 a real dynamic witness of the assumption violation`
+  };
+}
+var escapeRe2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+async function witnessAssumptionViolation(candidate, deps = {}) {
+  const log = deps.log ?? (() => {
+  });
+  const maxRounds = Math.max(1, deps.maxRounds ?? 3);
+  const synthesize = deps.synthesizePoc ?? makeDefaultSynthesizePoc(deps.runtime ?? "api", deps.model);
+  const boot = deps.bootPoc ?? defaultBootPoc;
+  const resolvedMode = resolveWitnessMode(deps.witnessMode ?? "auto", candidate);
+  const raceConfig = {
+    threads: deps.raceConfig?.threads ?? DEFAULT_RACE_THREADS,
+    iters: deps.raceConfig?.iters ?? DEFAULT_RACE_ITERS
+  };
+  if (resolvedMode === "race") {
+    log(`[witness]   race-shaped seam \u2192 CONCURRENT PoC synthesis (${raceConfig.threads} threads \xD7 ${raceConfig.iters} iters)`);
+  }
+  const attempts = [];
+  let priorCSource;
+  let priorFeedback;
+  let lastCSource;
+  for (let round = 1; round <= maxRounds; round++) {
+    log(`[witness] ${candidate.assumptionId} ${candidate.entryA}\u21C4${candidate.entryB} on struct ${candidate.object} \u2014 round ${round}/${maxRounds}: synthesizing PoC`);
+    let synth = null;
+    try {
+      synth = await synthesize({
+        candidate,
+        round,
+        // Only the race path adds mode/race to the input — a single-resolved seam keeps
+        // the original input shape (mode undefined), so its prompt is byte-for-byte unchanged.
+        ...resolvedMode === "race" ? { mode: "race", race: raceConfig } : {},
+        ...priorCSource ? { priorCSource } : {},
+        ...priorFeedback ? { priorFeedback } : {}
+      });
+    } catch (err) {
+      log(`[witness]   synthesis error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!synth || !synth.cSource.trim()) {
+      attempts.push({ round, synthesized: false, compiled: false, executed: false, timedOut: false, feedbackTail: "synthesizer produced no PoC" });
+      priorFeedback = "the previous round produced no usable C \u2014 emit a complete compilable file in a ```c block";
+      continue;
+    }
+    lastCSource = synth.cSource;
+    log(`[witness]   booting PoC (${synth.cSource.length} bytes) in KASAN VM`);
+    let result;
+    try {
+      result = await boot(synth.cSource, candidate);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      attempts.push({ round, synthesized: true, compiled: false, executed: false, timedOut: false, feedbackTail: `boot error: ${msg}`.slice(0, 4e3) });
+      priorCSource = synth.cSource;
+      priorFeedback = `the KASAN boot errored: ${msg}`.slice(0, 4e3);
+      continue;
+    }
+    const check = checkWitness(candidate, synth.cSource, result);
+    const feedbackTail = (result.compiled ? result.dmesg || result.output : result.output).slice(-4e3);
+    const attempt = {
+      round,
+      synthesized: true,
+      compiled: result.compiled,
+      executed: result.executed,
+      timedOut: result.timedOut,
+      check,
+      feedbackTail
+    };
+    attempts.push(attempt);
+    log(`[witness]   round ${round}: compiled=${result.compiled} executed=${result.executed} \u21D2 ${check.witnessed ? "WITNESSED" : "no witness"} (${check.reason})`);
+    if (check.witnessed) {
+      return {
+        candidate,
+        verdict: "confirmed",
+        attempts,
+        witnessedAttempt: attempt,
+        finalCSource: synth.cSource,
+        ...check.splat ? { splat: check.splat } : {},
+        summary: `CONFIRMED: object-bound ${check.signature} witnessed on struct ${candidate.object} at round ${round} \u2014 ${check.reason}`
+      };
+    }
+    priorCSource = synth.cSource;
+    priorFeedback = `${check.reason}
+--- boot output tail ---
+${feedbackTail}`;
+  }
+  const everRan = attempts.some((a) => a.executed);
+  const verdict = everRan ? "refuted" : "inconclusive";
+  return {
+    candidate,
+    verdict,
+    attempts,
+    ...lastCSource ? { finalCSource: lastCSource } : {},
+    summary: verdict === "refuted" ? `refuted: ${attempts.length} PoC round(s) compiled + ran but produced no object-bound KASAN splat on struct ${candidate.object} (assume-FP holds)` : `inconclusive: no PoC compiled+executed within ${maxRounds} round(s) (AEG/synthesis limit \u2014 NOT evidence the assumption holds)`
+  };
+}
+var WITNESSABLE_RELEVANCE = /* @__PURE__ */ new Set(["lifetime", "type", "bounds"]);
+function preFilterDualViewContexts(contexts, byId, bodies) {
+  const kept = [];
+  const dropped = [];
+  for (const ctx of contexts) {
+    if (!ctx.dualView) {
+      kept.push(ctx);
+      continue;
+    }
+    const a = byId.get(ctx.assumptionId);
+    if (!a) {
+      kept.push(ctx);
+      continue;
+    }
+    if (!WITNESSABLE_RELEVANCE.has(a.securityRelevance)) {
+      dropped.push({
+        ctx,
+        reason: `securityRelevance '${a.securityRelevance}' is not memory-safety \u2014 the KASAN oracle can only witness lifetime/type/bounds (UAF/OOB/double-free), so this can never be confirmed dynamically`
+      });
+      continue;
+    }
+    const entryBBody = bodies.get(ctx.caller);
+    if (entryBBody) {
+      const selfReason = subjectSelfEnforces(entryBBody, a);
+      if (selfReason) {
+        dropped.push({ ctx, reason: `entryB ${ctx.caller}() ${selfReason}` });
+        continue;
+      }
+      const toks = [a.oracle.establisherToken, ...a.oracle.establisherAliases ?? []].filter(isMechanizableEstablisher);
+      const present = toks.find((t) => new RegExp(`\\b${escapeRe2(t)}\\s*\\(`).test(entryBBody));
+      if (present) {
+        dropped.push({
+          ctx,
+          reason: `entryB ${ctx.caller}() directly calls establisher '${present}' \u2014 both phases take the guard (illusory dual-view skip)`
+        });
+        continue;
+      }
+    }
+    kept.push(ctx);
+  }
+  return { kept, dropped };
+}
+var ROTATION_STATE_VERSION = 1;
+var ROTATION_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+var ROTATION_RETENTION_MS = 2 * ROTATION_TTL_MS;
+var ROTATION_MAX_ENTRIES = 5e3;
+function candidateStableId(parts) {
+  const key = [parts.object, parts.entryA, parts.entryB, parts.entryBFile ?? "", parts.assumptionId, parts.predicate ?? ""].join("\0");
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+function candidateStableIdFromContext(ctx, predicate) {
+  return candidateStableId({
+    object: ctx.object ?? "",
+    entryA: ctx.pairedEntry ?? "",
+    entryB: ctx.caller,
+    entryBFile: ctx.callerFile,
+    assumptionId: ctx.assumptionId,
+    predicate
+  });
+}
+function loadRotationState(path) {
+  try {
+    const raw = JSON.parse(readFileSync2(path, "utf8"));
+    if (raw && raw.version === ROTATION_STATE_VERSION && raw.candidates && typeof raw.candidates === "object") {
+      return raw;
+    }
+  } catch {
+  }
+  return { version: ROTATION_STATE_VERSION, candidates: {} };
+}
+function pruneRotationState(state, now = Date.now()) {
+  const entries = Object.entries(state.candidates).filter(([, e]) => {
+    const t = Date.parse(e.witnessedAt);
+    return Number.isFinite(t) && now - t < ROTATION_RETENTION_MS;
+  }).sort((a, b) => Date.parse(b[1].witnessedAt) - Date.parse(a[1].witnessedAt)).slice(0, ROTATION_MAX_ENTRIES);
+  return { version: ROTATION_STATE_VERSION, candidates: Object.fromEntries(entries) };
+}
+function saveRotationState(path, state, now = Date.now()) {
+  const pruned = pruneRotationState(state, now);
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(pruned, null, 2) + "\n", "utf8");
+}
+function isWitnessedWithinTtl(state, id, now = Date.now(), ttlMs = ROTATION_TTL_MS) {
+  const e = state.candidates[id];
+  if (!e)
+    return false;
+  const t = Date.parse(e.witnessedAt);
+  return Number.isFinite(t) && now - t < ttlMs;
+}
+async function witnessDualViewContexts(input) {
+  const log = input.log ?? input.deps?.log ?? (() => {
+  });
+  const byId = new Map(input.kept.map((a) => [a.id, a]));
+  const cap = input.maxCandidates ?? 10;
+  const now = input.now ?? Date.now();
+  const dualCtxs = input.contexts.filter((c) => c.dualView);
+  const pf = preFilterDualViewContexts(dualCtxs, byId, input.bodies);
+  for (const d of pf.dropped) {
+    log(`[witness] pre-filter dropped ${d.ctx.caller}\u21C4${d.ctx.pairedEntry ?? "?"} on struct ${d.ctx.object ?? "?"}: ${d.reason}`);
+  }
+  if (pf.dropped.length) {
+    log(`[witness] pre-filter kept ${pf.kept.length}/${dualCtxs.length} dual-view candidate(s) (${pf.dropped.length} benign dropped)`);
+  }
+  const rotationState = input.rotationStatePath ? loadRotationState(input.rotationStatePath) : null;
+  const idOf = (ctx) => candidateStableIdFromContext(ctx, byId.get(ctx.assumptionId)?.predicate ?? "");
+  const selected = [];
+  let skippedByRotation = 0;
+  for (const ctx of pf.kept) {
+    if (rotationState && isWitnessedWithinTtl(rotationState, idOf(ctx), now)) {
+      skippedByRotation++;
+      continue;
+    }
+    selected.push(ctx);
+    if (selected.length >= cap)
+      break;
+  }
+  if (skippedByRotation) {
+    log(`[witness] rotation skipped ${skippedByRotation} candidate(s) already witnessed within the ${ROTATION_TTL_MS / 864e5}d TTL \u2014 testing fresh ones`);
+  }
+  const candidates = [];
+  const idByCandidate = /* @__PURE__ */ new Map();
+  for (const ctx of selected) {
+    const a = byId.get(ctx.assumptionId);
+    if (!a)
+      continue;
+    const cand = dualViewCandidateFromContext(ctx, a, input.bodies, input.subsystem);
+    if (cand) {
+      candidates.push(cand);
+      idByCandidate.set(cand, idOf(ctx));
+    }
+  }
+  log(`[witness] running the dynamic oracle on ${candidates.length} dual-view candidate(s) (bypassing the static skeptic)`);
+  const results = [];
+  for (const cand of candidates) {
+    results.push(await witnessAssumptionViolation(cand, { ...input.deps, log }));
+  }
+  if (rotationState && input.rotationStatePath) {
+    const at = new Date(now).toISOString();
+    for (const r of results) {
+      const id = idByCandidate.get(r.candidate);
+      if (!id)
+        continue;
+      rotationState.candidates[id] = {
+        verdict: r.verdict,
+        witnessedAt: at,
+        object: r.candidate.object,
+        entryA: r.candidate.entryA,
+        entryB: r.candidate.entryB
+      };
+    }
+    saveRotationState(input.rotationStatePath, rotationState, now);
+  }
+  return {
+    results,
+    confirmed: results.filter((r) => r.verdict === "confirmed"),
+    refuted: results.filter((r) => r.verdict === "refuted"),
+    inconclusive: results.filter((r) => r.verdict === "inconclusive")
+  };
+}
+
+// packages/core/dist/stages/assumption-mining.js
+var ASSUMPTION_MODEL_VERSION = 1;
+var ASSUMPTION_ARCHETYPE_FEWSHOTS = [
+  // A9 dual-view / DirtyCred — a consumer relies on the object being the one it validated.
+  `dual-view / DirtyCred (ownership-exclusive): a function uses a file/cred/sk it looked up EARLIER, relying that no concurrent path swapped a same-type object underneath it. subject=the consumer; predicate="'file' is still the same object validated at lookup"; establisherToken=the lookup/get that pins it (fget/fdget/get_file/sock_hold); kind=ownership-exclusive; securityRelevance=lifetime.`,
+  // A6/err-path double-put — a cleanup relies on the ref not already having been released.
+  `err-path double-put (refcount-positive): a release relies on the ref being HELD at that point, but an error path already released it. subject=the releasing fn; predicate="'sk' still holds a ref here"; establisherToken=the get that must dominate the put (sock_hold/get_pid/kref_get); kind=refcount-positive; securityRelevance=lifetime.`,
+  // A1/double-fetch — a use relies on a value not having changed since it was validated.
+  `double-fetch / revalidate (revalidated): a function validates a length/index, then RE-READS the same user/shared value at use, relying it did not change. subject=the using fn; predicate="'len' at use equals the validated 'len'"; establisherToken=the bounds check/copy that must re-run (copy_from_user/ check_add_overflow/a *_ok validator); kind=revalidated; securityRelevance=bounds.`,
+  // A2/called-once — an init/free relies on running exactly once per object.
+  `called-once (called-once): an init/free/attach relies on running EXACTLY ONCE for an object, but a reachable re-entry runs it twice. subject=the once-fn; predicate="this runs once per object"; establisherToken=the guard/state flag that must gate re-entry (test_and_set_bit/a state== check/ a WAS_INIT flag); kind=called-once; securityRelevance=lifetime.`,
+  // A11/A12 authz sibling / incomplete-fix — a handler relies on a cap check a sibling path skips.
+  `authz sibling / incomplete-fix (state-precondition): a handler relies on a capability/permission having been checked by the dispatcher, but a sibling entry reaches it without the check. subject=the handler; predicate="caller verified CAP_NET_ADMIN in the target netns"; establisherToken=the check a caller must perform (ns_capable/capable/netlink_capable); kind=state-precondition; securityRelevance=authz.`,
+  // A9' cross-api dual-view (THE high-value shape) — request/submit phase vs reply/completion/release phase.
+  `cross-api dual-view / cross-phase (relied-on-cross-api): a REQUEST/SUBMIT/CREATE phase sets up a long-lived object (a fuse_req, an io_uring registered fd/creds, a dma_buf, a reused pipe_buffer) and a SECOND, userspace-/IRQ-/completion-driven phase (the REPLY/COMPLETION/RELEASE view) reaches the SAME object via a DISTINCT entry. subject=the phase that RELIES on stability; object='struct fuse_req' (name the STRUCT TYPE, it is the dual-view join); predicate="req fields validated at request time are not mutated by the reply path"; establisherToken=the flag/lock/state the setup phase sets that the second phase must honor (a *_INIT/*_LOCKED flag, req->state==, a held lock); kind=ownership-exclusive or state-precondition; provenance=relied-on-cross-api; securityRelevance=lifetime or type.`,
+  // fd-install / SCM_RIGHTS dual-view — installer establishes a type/validity the consumer trusts.
+  `fd-install dual-view (relied-on-cross-api): one API INSTALLS an fd/file into a receiver (SCM_RIGHTS, fd passing) whose type/validity the CONSUMER assumes was checked at install. subject=the receiver/consumer; object='struct file'; predicate="the installed file was type-checked to the expected f_op/proto_ops"; establisherToken=the validating check the install path must perform (an f_op== compare, a proto check, a security_ hook); kind=ownership-exclusive; provenance=relied-on-cross-api; securityRelevance=type.`
+];
+var MINE_TOOL = {
+  name: "emit_assumption_set",
+  description: "Emit the set of implicit RELIED-ON preconditions in the subsystem. Do NOT hunt bugs. For each key function, state a precondition it DEPENDS ON but does NOT itself establish, and name the exact TOKEN (a call / lock / validator identifier) that a caller, a lock, or another API uses to establish it \u2014 that token's ABSENCE on a path is what a separate deterministic checker will hunt.",
+  input_schema: {
+    type: "object",
+    properties: {
+      assumptions: {
+        type: "array",
+        description: "One entry per relied-on precondition. Prefer preconditions on objects reachable from unprivileged syscalls.",
+        items: {
+          type: "object",
+          properties: {
+            kind: {
+              type: "string",
+              enum: [
+                "non-null",
+                "validated-range",
+                "revalidated",
+                "state-precondition",
+                "called-once",
+                "refcount-positive",
+                "lock-held",
+                "field-initialized",
+                "ownership-exclusive",
+                "size-consistent"
+              ],
+              description: "The precondition shape (see the archetypes in the system prompt)."
+            },
+            object: { type: "string", description: "The object/struct the precondition constrains, e.g. 'struct sock'." },
+            subject: { type: "string", description: "The function that RELIES on the precondition (exact name as defined)." },
+            predicate: { type: "string", description: `The precondition, e.g. "'other' still holds an sk ref here".` },
+            location: { type: "string", description: "Where the reliance is, as file:line or function name." },
+            provenance: {
+              type: "string",
+              enum: ["enforced-local", "relied-on-caller", "relied-on-subsystem", "relied-on-cross-api", "relied-on-concurrency"],
+              description: "Where the precondition is supposed to be established. Use enforced-local ONLY if the subject itself establishes it."
+            },
+            establishedBy: { type: "string", description: "Who normally establishes it (a caller / lock / API name)." },
+            oracle: {
+              type: "object",
+              properties: {
+                mechanism: {
+                  type: "string",
+                  enum: ["establisher-absent-on-path", "state-not-established", "revalidation-absent", "establisher-absent-cross-api"]
+                },
+                target: { type: "string", description: "The object/expression checked, e.g. 'other' or 'skb->len'." },
+                establisherToken: {
+                  type: "string",
+                  description: "The SINGLE call/lock/validator identifier that establishes the precondition, verbatim as it appears in code (e.g. 'sock_hold', 'mutex_lock', 'ns_capable'). The checker greps this literally \u2014 a prose phrase is useless."
+                },
+                establisherAliases: { type: "array", items: { type: "string" }, description: "Other tokens that also establish it." }
+              },
+              required: ["mechanism", "target", "establisherToken"]
+            },
+            securityRelevance: {
+              type: "string",
+              enum: ["lifetime", "bounds", "authz", "type", "other"],
+              description: "Which security dimension the precondition protects."
+            }
+          },
+          required: ["kind", "subject", "predicate", "provenance", "oracle", "securityRelevance"]
+        }
+      },
+      notes: { type: "string", description: "Free-form provenance notes." }
+    },
+    required: ["assumptions"]
+  }
+};
+var MINE_SYSTEM = "You are a world-class kernel auditor performing ASSUMPTION MINING. You are given a subsystem's source. Your job is NOT to find bugs \u2014 it is to make the code's IMPLICIT contract EXPLICIT: for each key function, state a precondition it RELIES ON but does NOT itself establish, and name the exact TOKEN a caller, a lock, or another API uses to establish that precondition. A separate deterministic checker will then hunt reachable contexts where that token is ABSENT.\n\nThink about the deepest bug classes and state the assumption whose violation WOULD be one \u2014 these archetypes are the shape to emit (not patterns to grep):\n  - " + ASSUMPTION_ARCHETYPE_FEWSHOTS.join("\n  - ") + "\n\nRULES:\n  1. establisherToken MUST be a real identifier that appears verbatim in the source (a function/macro call, a lock acquire, a validator). NEVER a prose phrase \u2014 the checker matches it literally.\n  2. Use provenance 'enforced-local' ONLY when the subject establishes the precondition itself; otherwise pick the relied-on-* class that says WHO establishes it (caller / subsystem / cross-api / concurrency).\n  3. Prefer preconditions on objects reachable from UNPRIVILEGED syscalls, and prefer lifetime / bounds / authz / type relevance (a race on a lifetime pointer, a skipped bounds/authz check) over cosmetic ones.\n  4. 'subject' must be an exact function name as defined in the source.\n  5. establisherAliases \u2014 CRITICAL for precision. When the precondition can be established through a FAMILY of tokens (sibling macros like CMSG_LEN/CMSG_SPACE/CMSG_ALIGN, a helper that WRAPS the raw primitive such as unix_table_double_lock() wrapping spin_lock(), or several equivalent validators), put the establisherToken as the one you consider primary and list EVERY other token that also establishes it in establisherAliases. The deterministic checker treats a caller that uses the token OR any alias (directly or through a wrapper) as having established the precondition \u2014 a missing alias/wrapper is the #1 false-positive source, so be generous here.\n  6. Prefer the WRAPPER identifier the surrounding code actually calls (e.g. unix_state_lock, unix_table_double_lock) as the establisherToken when one exists, and list the raw primitive it bottoms out in as an alias.\n  7. HIGHEST PRIORITY \u2014 DUAL-VIEW / CROSS-PHASE seams. The deepest LPEs (DirtyPipe, DirtyCred, fuse request-vs-reply, io_uring submit-vs-completion, SCM_RIGHTS install-vs-consume) are NOT single-caller preconditions \u2014 they are one LONG-LIVED OBJECT reached by TWO DISTINCT APIs/phases where the second phase does not re-establish what the first set up. When you see an object that OUTLIVES a single call and is reached from MULTIPLE entry points or lifecycle phases (create/open vs release; request/submit vs reply/completion; install vs consume), EMIT a relied-on-cross-api assumption for it: set provenance='relied-on-cross-api' (or 'relied-on-concurrency' for a race), name the STRUCT TYPE in 'object' verbatim (e.g. 'struct fuse_req' \u2014 the type name is the mechanical join the dual-view checker greps), and pick kind ownership-exclusive / state-precondition / called-once / field-initialized / revalidated. Prefer these cross-phase assumptions over plain caller-precondition ones. Emit via emit_assumption_set.";
+function readSource2(sourceRoot, file) {
+  const path = resolveContainedSourcePath(sourceRoot, file);
+  if (!path)
+    return null;
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function mineAssumptions(input) {
+  const log = input.log ?? (() => {
+  });
+  if (!input.subsystemFiles || input.subsystemFiles.length === 0) {
+    throw new Error("assumption mining needs at least one subsystemFile");
+  }
+  const sources = [];
+  for (const file of input.subsystemFiles) {
+    const text = readSource2(input.sourceRoot, file);
+    if (text == null) {
+      log(`[assumption-mine] could not read ${file}`);
+      continue;
+    }
+    sources.push({ file, text });
+  }
+  if (sources.length === 0)
+    throw new Error("assumption mining could not read any subsystemFile under sourceRoot");
+  const out = await extractInvariantSpec({
+    sources,
+    system: MINE_SYSTEM,
+    tool: MINE_TOOL,
+    ...input.model ? { model: input.model } : {},
+    ...input.maxCharsPerFile !== void 0 ? { maxCharsPerFile: input.maxCharsPerFile } : {},
+    errorLabel: "assumption-mine"
+  });
+  const raw = Array.isArray(out?.assumptions) ? out.assumptions : [];
+  const assumptions = normalizeAssumptions(raw);
+  if (assumptions.length === 0)
+    throw new Error("assumption mine emitted no well-formed assumptions");
+  log(`[assumption-mine] mined ${assumptions.length} relied-on assumption(s) in ${input.subsystem}`);
+  return {
+    modelVersion: ASSUMPTION_MODEL_VERSION,
+    subsystem: input.subsystem,
+    subsystemFiles: sources.map((s) => s.file),
+    assumptions,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...out?.notes ? { notes: out.notes } : {}
+  };
+}
+function normalizeAssumptions(raw) {
+  const perSubject = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const a of raw) {
+    if (!a || typeof a.subject !== "string" || !a.subject)
+      continue;
+    if (!a.oracle || typeof a.oracle.establisherToken !== "string" || !a.oracle.establisherToken)
+      continue;
+    if (typeof a.predicate !== "string" || !a.predicate)
+      continue;
+    const n = (perSubject.get(a.subject) ?? 0) + 1;
+    perSubject.set(a.subject, n);
+    out.push({
+      id: `${a.subject}#${n}`,
+      kind: a.kind,
+      ...a.object ? { object: a.object } : {},
+      subject: a.subject,
+      predicate: a.predicate,
+      location: typeof a.location === "string" ? a.location : a.subject,
+      provenance: a.provenance,
+      ...a.establishedBy ? { establishedBy: a.establishedBy } : {},
+      oracle: {
+        mechanism: a.oracle.mechanism,
+        target: typeof a.oracle.target === "string" && a.oracle.target ? a.oracle.target : a.subject,
+        establisherToken: a.oracle.establisherToken,
+        ...Array.isArray(a.oracle.establisherAliases) ? { establisherAliases: a.oracle.establisherAliases } : {}
+      },
+      securityRelevance: a.securityRelevance
+    });
+  }
+  return out;
+}
+function storeAssumptionModel(model, path) {
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(model, null, 2) + "\n", "utf8");
+  return path;
+}
+function loadAssumptionModel(path) {
+  const model = JSON.parse(readFileSync3(path, "utf8"));
+  if (model.modelVersion !== ASSUMPTION_MODEL_VERSION) {
+    throw new Error(`stored assumption model is v${model.modelVersion}, checker is v${ASSUMPTION_MODEL_VERSION} \u2014 re-mine`);
+  }
+  if (!Array.isArray(model.assumptions))
+    throw new Error("stored assumption model has no assumptions array");
+  return model;
+}
+var KEEP_RELEVANCE = /* @__PURE__ */ new Set(["lifetime", "bounds", "authz", "type"]);
+var NON_MECHANIZABLE = /* @__PURE__ */ new Set([
+  "n/a",
+  "na",
+  "none",
+  "the",
+  "a",
+  "caller",
+  "user",
+  "userspace",
+  "unknown",
+  "somewhere",
+  "before",
+  "after",
+  "valid",
+  "check",
+  "checked",
+  "the_caller",
+  "todo",
+  "tbd"
+]);
+function isMechanizableEstablisher(token) {
+  const t = (token ?? "").trim();
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(t))
+    return false;
+  if (t.length < 3)
+    return false;
+  if (NON_MECHANIZABLE.has(t.toLowerCase()))
+    return false;
+  return true;
+}
+function bodyCallsToken(fnBody, token) {
+  const esc = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${esc}\\s*\\(`).test(fnBody);
+}
+function leadingIdent(expr) {
+  const m = (expr ?? "").trim().match(/^([A-Za-z_]\w*)/);
+  return m ? m[1] : "";
+}
+function trailingIdent(expr) {
+  const m = (expr ?? "").trim().match(/([A-Za-z_]\w*)\s*$/);
+  return m ? m[1] : "";
+}
+function guardConditions(body) {
+  const out = [];
+  const re = /\b(?:if|while)\s*\(/g;
+  let m;
+  while (m = re.exec(body)) {
+    let i = m.index + m[0].length - 1;
+    let depth = 0;
+    const start = i + 1;
+    for (; i < body.length; i++) {
+      if (body[i] === "(")
+        depth++;
+      else if (body[i] === ")") {
+        depth--;
+        if (depth === 0)
+          break;
+      }
+    }
+    out.push(body.slice(start, i));
+    re.lastIndex = i + 1;
+  }
+  return out;
+}
+function callArgsOf(body, name) {
+  const re = new RegExp(`\\b${escapeReStr(name)}\\s*\\(`);
+  const m = re.exec(body);
+  if (!m)
+    return null;
+  let i = m.index + m[0].length - 1;
+  let depth = 0;
+  const start = i + 1;
+  for (; i < body.length; i++) {
+    if (body[i] === "(")
+      depth++;
+    else if (body[i] === ")") {
+      depth--;
+      if (depth === 0)
+        break;
+    }
+  }
+  return body.slice(start, i);
+}
+function escapeReStr(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var SELF_ASSERT_FAMILY = ["lockdep_assert_held", "assert_spin_locked", "WARN_ON_ONCE", "WARN_ON", "BUG_ON", "VM_BUG_ON_PAGE", "VM_BUG_ON"];
+function subjectSelfEnforces(body, a) {
+  const tokens = [a.oracle.establisherToken, ...a.oracle.establisherAliases ?? []].filter(isMechanizableEstablisher);
+  const target = a.oracle.target || a.object || "";
+  const tvar = leadingIdent(target);
+  const tfield = trailingIdent(target);
+  const refs = [tvar, tfield, ...tokens].filter((r) => r && r.length >= 2);
+  const wordIn = (hay, w) => new RegExp(`\\b${escapeReStr(w)}\\b`).test(hay);
+  if (a.kind === "lock-held" && /\b(?:lockdep_assert_held|\w*_assert_held|assert_spin_locked)\s*\(/.test(body)) {
+    return "subject asserts its lock is caller-held (lockdep_assert_held/*_assert_held) \u2014 self-enforcing (external contract asserted, not a silent violator)";
+  }
+  for (const fam of SELF_ASSERT_FAMILY) {
+    const arg = callArgsOf(body, fam);
+    if (arg && refs.some((r) => wordIn(arg, r))) {
+      return `subject guards its contract with ${fam}(\u2026${refs.find((r) => wordIn(arg, r))}\u2026) \u2014 self-enforcing`;
+    }
+  }
+  for (const cond of guardConditions(body)) {
+    const tokHit = tokens.find((t) => wordIn(cond, t));
+    if (tokHit)
+      return `subject tests establisher '${tokHit}' in an if/while guard \u2014 self-enforcing`;
+    for (const v of [tvar, tfield].filter((x) => x && x.length >= 2)) {
+      if (new RegExp(`\\b${escapeReStr(v)}\\b[^;{}]*&\\s*[A-Z_][A-Z0-9_]{2,}`).test(cond)) {
+        return `subject flag-tests '${v}' against a FLAG in a guard \u2014 self-enforcing`;
+      }
+    }
+  }
+  return null;
+}
+function crossCheckAssumptions(model, bodies) {
+  const kept = [];
+  const dropped = [];
+  const reclassified = [];
+  for (const a of model.assumptions) {
+    if (!isMechanizableEstablisher(a.oracle.establisherToken)) {
+      dropped.push({ assumption: a, reason: `non-mechanizable establisher token "${a.oracle.establisherToken}" (prose-only)` });
+      continue;
+    }
+    const sbody = bodies.get(a.subject);
+    if (sbody != null) {
+      const selfReason = subjectSelfEnforces(sbody, a);
+      if (selfReason) {
+        dropped.push({ assumption: a, reason: selfReason });
+        continue;
+      }
+    }
+    let effective = a;
+    if (a.provenance === "enforced-local") {
+      const body = bodies.get(a.subject);
+      if (body == null) {
+        dropped.push({ assumption: a, reason: `enforced-local but ${a.subject}() body unreadable \u2014 cannot confirm a violator (safe drop)` });
+        continue;
+      }
+      const establishes = bodyCallsToken(body, a.oracle.establisherToken) || (a.oracle.establisherAliases ?? []).some((alias) => isMechanizableEstablisher(alias) && bodyCallsToken(body, alias));
+      if (establishes) {
+        dropped.push({ assumption: a, reason: `enforced-local verified \u2014 ${a.subject}() establishes ${a.oracle.establisherToken} itself (no external violator)` });
+        continue;
+      }
+      effective = { ...a, provenance: "relied-on-caller" };
+      reclassified.push(effective);
+    }
+    if (!KEEP_RELEVANCE.has(effective.securityRelevance)) {
+      dropped.push({ assumption: a, reason: `securityRelevance '${effective.securityRelevance}' not in {lifetime,bounds,authz,type}` });
+      continue;
+    }
+    kept.push(effective);
+  }
+  return { kept, dropped, reclassified };
+}
+function buildFunctionBodyIndex(sources) {
+  const out = /* @__PURE__ */ new Map();
+  for (const { text } of sources) {
+    for (const fn of splitTopLevelFunctions(text)) {
+      if (!out.has(fn.name))
+        out.set(fn.name, fn.text);
+    }
+  }
+  return out;
+}
+function splitTopLevelFunctions(src) {
+  const blanked = blankCommentsAndStrings2(src);
+  const out = [];
+  const n = blanked.length;
+  let depth = 0;
+  const CONTROL = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "do", "else", "return", "sizeof", "typeof", "__attribute__", "case", "default", "goto", "asm", "__asm__", "static_assert"]);
+  for (let i = 0; i < n; i++) {
+    const ch = blanked[i];
+    if (ch === "{") {
+      if (depth === 0) {
+        let j = i - 1;
+        while (j >= 0 && /\s/.test(blanked[j]))
+          j--;
+        if (j >= 0 && blanked[j] === ")") {
+          let pd = 0;
+          let k = j;
+          for (; k >= 0; k--) {
+            if (blanked[k] === ")")
+              pd++;
+            else if (blanked[k] === "(") {
+              pd--;
+              if (pd === 0)
+                break;
+            }
+          }
+          if (k >= 0) {
+            let m = k - 1;
+            while (m >= 0 && /\s/.test(blanked[m]))
+              m--;
+            let e = m;
+            while (e >= 0 && /[A-Za-z0-9_]/.test(blanked[e]))
+              e--;
+            const name = blanked.slice(e + 1, m + 1).trim();
+            if (name && /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !CONTROL.has(name)) {
+              let bd = 0;
+              let end = i;
+              for (; end < n; end++) {
+                if (blanked[end] === "{")
+                  bd++;
+                else if (blanked[end] === "}") {
+                  bd--;
+                  if (bd === 0)
+                    break;
+                }
+              }
+              let sigStart = e + 1;
+              while (sigStart > 0 && blanked[sigStart - 1] !== "\n")
+                sigStart--;
+              out.push({ name, text: src.slice(sigStart, Math.min(n, end + 1)) });
+              i = end;
+              depth = 0;
+              continue;
+            }
+          }
+        }
+      }
+      depth++;
+    } else if (ch === "}") {
+      if (depth > 0)
+        depth--;
+    }
+  }
+  return out;
+}
+function blankCommentsAndStrings2(src) {
+  const out = src.split("");
+  let i = 0;
+  const n = src.length;
+  const blank = (a, b) => {
+    for (let k = a; k < b && k < n; k++)
+      if (out[k] !== "\n")
+        out[k] = " ";
+  };
+  while (i < n) {
+    const c = src[i];
+    const c2 = src[i + 1];
+    if (c === "/" && c2 === "/") {
+      let j = i + 2;
+      while (j < n && src[j] !== "\n")
+        j++;
+      blank(i, j);
+      i = j;
+    } else if (c === "/" && c2 === "*") {
+      let j = i + 2;
+      while (j < n && !(src[j] === "*" && src[j + 1] === "/"))
+        j++;
+      j = Math.min(n, j + 2);
+      blank(i, j);
+      i = j;
+    } else if (c === '"' || c === "'") {
+      const q = c;
+      let j = i + 1;
+      while (j < n) {
+        if (src[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (src[j] === q) {
+          j++;
+          break;
+        }
+        if (src[j] === "\n")
+          break;
+        j++;
+      }
+      blank(i, j);
+      i = j;
+    } else
+      i++;
+  }
+  return out.join("");
+}
+var UNPRIV_ENTRY_RE = /(^__?sys_|^__do_sys_|_ioctl$|_recvmsg$|_sendmsg$|_recvmmsg$|_sendmmsg$|_setsockopt$|_getsockopt$|_read$|_write$|_poll$|_mmap$|_release$|_connect$|_bind$|_listen$|_accept)/;
+var escapeRe3 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function computeEstablisherWrappers(cg, establisherTokens, maxRounds = 4) {
+  const defined = new Set(cg.fns.map((f) => f.name));
+  const establishes = /* @__PURE__ */ new Map();
+  for (const fn of cg.fns) {
+    const s = /* @__PURE__ */ new Set();
+    for (const call of fn.calls)
+      if (establisherTokens.has(call.callee))
+        s.add(call.callee);
+    establishes.set(fn.name, s);
+  }
+  for (let round = 0; round < Math.max(1, maxRounds); round++) {
+    let changed = false;
+    for (const fn of cg.fns) {
+      const cur = establishes.get(fn.name);
+      for (const call of fn.calls) {
+        if (!defined.has(call.callee))
+          continue;
+        const via = establishes.get(call.callee);
+        if (!via)
+          continue;
+        for (const t of via)
+          if (!cur.has(t)) {
+            cur.add(t);
+            changed = true;
+          }
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return establishes;
+}
+function computeEstablisherSets(cg, establisherTokens, exported, maxRounds = 8, wrappers) {
+  const local = /* @__PURE__ */ new Map();
+  for (const fn of cg.fns) {
+    const s = wrappers?.get(fn.name) ? new Set(wrappers.get(fn.name)) : /* @__PURE__ */ new Set();
+    for (const call of fn.calls)
+      if (establisherTokens.has(call.callee))
+        s.add(call.callee);
+    local.set(fn.name, s);
+  }
+  const callersOf = /* @__PURE__ */ new Map();
+  const defined = new Set(cg.fns.map((f) => f.name));
+  for (const fn of cg.fns) {
+    for (const call of fn.calls) {
+      if (!defined.has(call.callee))
+        continue;
+      const set = callersOf.get(call.callee) ?? /* @__PURE__ */ new Set();
+      set.add(fn.name);
+      callersOf.set(call.callee, set);
+    }
+  }
+  const est = /* @__PURE__ */ new Map();
+  for (const fn of cg.fns)
+    est.set(fn.name, new Set(local.get(fn.name)));
+  for (let round = 0; round < Math.max(1, maxRounds); round++) {
+    let changed = false;
+    for (const fn of cg.fns) {
+      const callers = callersOf.get(fn.name);
+      if (!callers || callers.size === 0 || exported.has(fn.name))
+        continue;
+      let inter = null;
+      for (const c of callers) {
+        const cs = est.get(c) ?? /* @__PURE__ */ new Set();
+        if (inter === null)
+          inter = new Set(cs);
+        else
+          for (const t of [...inter])
+            if (!cs.has(t))
+              inter.delete(t);
+        if (inter.size === 0)
+          break;
+      }
+      if (!inter || inter.size === 0)
+        continue;
+      const cur = est.get(fn.name);
+      for (const t of inter) {
+        if (!cur.has(t)) {
+          cur.add(t);
+          changed = true;
+        }
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return est;
+}
+function collectExportedSymbols(sources) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /EXPORT_SYMBOL(?:_GPL|_NS|_NS_GPL)?\s*\(\s*([A-Za-z_]\w*)/g;
+  for (const { text } of sources) {
+    let m;
+    while (m = re.exec(text))
+      out.add(m[1]);
+  }
+  return out;
+}
+function callLineInBody(callerBody, callerStartLine, callee) {
+  const re = new RegExp(`\\b${escapeRe3(callee)}\\s*\\(`);
+  const m = re.exec(callerBody);
+  if (!m)
+    return callerStartLine;
+  let nl = 0;
+  for (let k = 0; k < m.index; k++)
+    if (callerBody[k] === "\n")
+      nl++;
+  return callerStartLine + nl;
+}
+function scanViolatingContexts(kept, cg, sources, bodies, opts = {}) {
+  const log = opts.log ?? (() => {
+  });
+  const maxContexts = opts.maxContexts ?? 60;
+  const establisherTokens = /* @__PURE__ */ new Set();
+  for (const a of kept) {
+    establisherTokens.add(a.oracle.establisherToken);
+    for (const alias of a.oracle.establisherAliases ?? [])
+      if (isMechanizableEstablisher(alias))
+        establisherTokens.add(alias);
+  }
+  const exported = collectExportedSymbols(sources);
+  const wrappers = opts.resolveWrappers === false ? void 0 : computeEstablisherWrappers(cg, establisherTokens, opts.wrapperRounds ?? 4);
+  const est = computeEstablisherSets(cg, establisherTokens, exported, opts.maxPropagationRounds ?? 8, wrappers);
+  const callersOf = /* @__PURE__ */ new Map();
+  const defined = new Set(cg.fns.map((f) => f.name));
+  for (const fn of cg.fns) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const call of fn.calls) {
+      if (!defined.has(call.callee) || seen.has(call.callee))
+        continue;
+      seen.add(call.callee);
+      const arr = callersOf.get(call.callee) ?? [];
+      arr.push(fn);
+      callersOf.set(call.callee, arr);
+    }
+  }
+  const contexts = [];
+  for (const a of kept) {
+    const subject = a.subject;
+    const token = a.oracle.establisherToken;
+    const aliases = (a.oracle.establisherAliases ?? []).filter(isMechanizableEstablisher);
+    const establishesToken = (fnName2) => {
+      const set = est.get(fnName2);
+      if (!set)
+        return false;
+      if (set.has(token))
+        return true;
+      return aliases.some((al) => set.has(al));
+    };
+    const callers = callersOf.get(subject);
+    if (!callers || callers.length === 0)
+      continue;
+    for (const c of callers) {
+      if (c.name === subject)
+        continue;
+      if (establishesToken(c.name))
+        continue;
+      const body = bodies.get(c.name) ?? "";
+      const line = callLineInBody(body, c.startLine, subject);
+      const unpriv = UNPRIV_ENTRY_RE.test(c.name) || !callersOf.get(c.name)?.length;
+      contexts.push({
+        assumptionId: a.id,
+        subject,
+        caller: c.name,
+        callerFile: c.file,
+        callLine: line,
+        establisherToken: token,
+        unprivEntry: unpriv,
+        detail: `${c.name}() calls ${subject}() at ${c.file}:${line} but never establishes ${token}${aliases.length ? ` (nor ${aliases.join("/")})` : ""}, and does not inherit it from its callers. ${subject}() RELIES ON: ${a.predicate} (${a.kind}, ${a.securityRelevance}). If this path is attacker-reachable and the precondition is genuinely required, the assumption is VIOLATED here. CANDIDATE to DISPROVE \u2014 coarse establisher-anywhere + name-based call graph; confirm ${token} is truly absent on THIS path.`
+      });
+    }
+  }
+  contexts.sort((x, y) => Number(y.unprivEntry) - Number(x.unprivEntry) || x.subject.localeCompare(y.subject) || x.caller.localeCompare(y.caller));
+  const capped = contexts.slice(0, maxContexts);
+  log(`[assumption-scan] ${contexts.length} violating context(s)${capped.length < contexts.length ? ` (capped to ${capped.length})` : ""}`);
+  return capped;
+}
+var DEFAULT_CROSS_API_KINDS = /* @__PURE__ */ new Set([
+  "ownership-exclusive",
+  "called-once",
+  "field-initialized",
+  "revalidated",
+  "state-precondition"
+]);
+var UBIQUITOUS_OBJECT_TYPES = /* @__PURE__ */ new Set([
+  "file",
+  "inode",
+  "dentry",
+  "page",
+  "folio",
+  "sk_buff",
+  "sock",
+  "task_struct",
+  "mm_struct",
+  "vm_area_struct",
+  "kiocb",
+  "address_space",
+  "super_block",
+  "vfsmount",
+  "path",
+  "kobject",
+  "device",
+  "list_head",
+  "work_struct",
+  "timer_list",
+  "pid",
+  "cred",
+  "seq_file",
+  "kmem_cache",
+  "nameidata",
+  "kstat",
+  "iov_iter",
+  "bio",
+  "request"
+]);
+function isCrossApiAssumption(a, kinds = DEFAULT_CROSS_API_KINDS) {
+  return a.provenance === "relied-on-cross-api" || a.provenance === "relied-on-concurrency" || kinds.has(a.kind);
+}
+function objectTypeToken(a) {
+  const raw = (a.object ?? a.oracle.target ?? "").trim();
+  const sm = raw.match(/struct\s+([A-Za-z_]\w*)/);
+  if (sm)
+    return sm[1];
+  const bm = raw.match(/^([A-Za-z_]\w*)$/);
+  if (bm && bm[1].length >= 4)
+    return bm[1];
+  return null;
+}
+function buildAdjacency(cg) {
+  const defined = new Set(cg.fns.map((f) => f.name));
+  const adj = /* @__PURE__ */ new Map();
+  for (const fn of cg.fns) {
+    const s = adj.get(fn.name) ?? /* @__PURE__ */ new Set();
+    for (const call of fn.calls)
+      if (defined.has(call.callee))
+        s.add(call.callee);
+    adj.set(fn.name, s);
+  }
+  return adj;
+}
+function reachesFn(adj, from, to, maxDepth = 12) {
+  if (from === to)
+    return true;
+  const seen = /* @__PURE__ */ new Set([from]);
+  let frontier = [from];
+  let depth = 0;
+  while (frontier.length && depth++ < maxDepth) {
+    const next = [];
+    for (const f of frontier) {
+      for (const c of adj.get(f) ?? []) {
+        if (c === to)
+          return true;
+        if (!seen.has(c)) {
+          seen.add(c);
+          next.push(c);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return false;
+}
+function lockCallArgRanges(blanked) {
+  const ranges = [];
+  const push = (openParen) => {
+    let depth = 0;
+    for (let i = openParen; i < blanked.length; i++) {
+      if (blanked[i] === "(")
+        depth++;
+      else if (blanked[i] === ")") {
+        depth--;
+        if (depth === 0) {
+          ranges.push([openParen, i]);
+          return;
+        }
+      }
+    }
+  };
+  LOCK_CALL_RE.lastIndex = 0;
+  let m;
+  while (m = LOCK_CALL_RE.exec(blanked))
+    push(m.index + m[0].length - 1);
+  const guardRe = /\b(?:guard|scoped_guard)\s*\(/g;
+  let g;
+  while (g = guardRe.exec(blanked))
+    push(g.index + g[0].length - 1);
+  return ranges;
+}
+function objectFieldAccesses(body, typeToken) {
+  const out = /* @__PURE__ */ new Map();
+  if (!body || !typeToken)
+    return out;
+  const blanked = blankCommentsAndStrings2(body);
+  const lockRanges = lockCallArgRanges(blanked);
+  const insideLockArg = (idx) => lockRanges.some(([s, e]) => idx > s && idx < e);
+  const vars = /* @__PURE__ */ new Set();
+  const declRe = new RegExp(`(?:struct\\s+)?\\b${escapeRe3(typeToken)}\\b\\s*\\**\\s*([A-Za-z_]\\w*)`, "g");
+  let dm;
+  while (dm = declRe.exec(blanked)) {
+    const name = dm[1];
+    if (name && name !== "struct")
+      vars.add(name);
+  }
+  if (vars.size === 0)
+    return out;
+  for (const v of vars) {
+    const accRe = new RegExp(`\\b${escapeRe3(v)}\\s*(?:->|\\.)\\s*([A-Za-z_]\\w*)`, "g");
+    let am;
+    while (am = accRe.exec(blanked)) {
+      if (insideLockArg(am.index))
+        continue;
+      const field = am[1];
+      const arr = out.get(field) ?? [];
+      arr.push(am.index);
+      out.set(field, arr);
+    }
+  }
+  return out;
+}
+var LOCK_CALL_RE = /\b(lock_sock_nested|lock_sock|bh_lock_sock|bh_unlock_sock|release_sock|mutex_lock_interruptible|mutex_lock_nested|mutex_lock_killable|mutex_lock|mutex_unlock|spin_lock_irqsave|spin_lock_irq|spin_lock_bh|spin_lock|spin_unlock_irqrestore|spin_unlock_irq|spin_unlock_bh|spin_unlock|read_lock_bh|read_lock|read_unlock_bh|read_unlock|write_lock_bh|write_lock|write_unlock_bh|write_unlock|rcu_read_lock|rcu_read_unlock)\s*\(/g;
+function firstCallArgNorm(body, openParen) {
+  let depth = 0;
+  let i = openParen;
+  const start = openParen + 1;
+  let end = start;
+  for (; i < body.length; i++) {
+    const c = body[i];
+    if (c === "(")
+      depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    } else if (c === "," && depth === 1) {
+      end = i;
+      break;
+    }
+  }
+  return body.slice(start, end).replace(/\s+/g, "").replace(/^&/, "");
+}
+function lockEvents(body) {
+  const blanked = blankCommentsAndStrings2(body);
+  const events = [];
+  LOCK_CALL_RE.lastIndex = 0;
+  let m;
+  while (m = LOCK_CALL_RE.exec(blanked)) {
+    const name = m[1];
+    const openParen = m.index + m[0].length - 1;
+    const arg = firstCallArgNorm(blanked, openParen);
+    let id;
+    let acquire;
+    if (name === "lock_sock" || name === "lock_sock_nested" || name === "bh_lock_sock") {
+      id = "sock";
+      acquire = true;
+    } else if (name === "release_sock" || name === "bh_unlock_sock") {
+      id = "sock";
+      acquire = false;
+    } else if (name === "rcu_read_lock") {
+      id = "rcu";
+      acquire = true;
+    } else if (name === "rcu_read_unlock") {
+      id = "rcu";
+      acquire = false;
+    } else if (name.startsWith("mutex_lock")) {
+      id = `mutex:${arg}`;
+      acquire = true;
+    } else if (name === "mutex_unlock") {
+      id = `mutex:${arg}`;
+      acquire = false;
+    } else if (name.startsWith("spin_lock")) {
+      id = `spin:${arg}`;
+      acquire = true;
+    } else if (name.startsWith("spin_unlock")) {
+      id = `spin:${arg}`;
+      acquire = false;
+    } else if (name.startsWith("read_lock") || name.startsWith("write_lock")) {
+      id = `rw:${arg}`;
+      acquire = true;
+    } else if (name.startsWith("read_unlock") || name.startsWith("write_unlock")) {
+      id = `rw:${arg}`;
+      acquire = false;
+    } else
+      continue;
+    events.push({ index: m.index, acquire, id });
+  }
+  const guardRe = /\b(?:guard|scoped_guard)\s*\(\s*\w+\s*(?:\)\s*\(|,)\s*([^),]+)/g;
+  let g;
+  while (g = guardRe.exec(blanked)) {
+    const arg = g[1].replace(/\s+/g, "").replace(/^&/, "");
+    events.push({ index: g.index, acquire: true, id: `guard:${arg}` });
+  }
+  events.sort((a, b) => a.index - b.index);
+  return events;
+}
+function heldLockIdsAt(events, at) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.index >= at)
+      break;
+    const c = counts.get(e.id) ?? 0;
+    counts.set(e.id, e.acquire ? c + 1 : Math.max(0, c - 1));
+  }
+  const held = /* @__PURE__ */ new Set();
+  for (const [id, c] of counts)
+    if (c > 0)
+      held.add(id);
+  return held;
+}
+function fieldCoveringLocks(events, offsets) {
+  let inter = null;
+  for (const off of offsets) {
+    const held = heldLockIdsAt(events, off);
+    if (inter === null)
+      inter = new Set(held);
+    else
+      for (const id of [...inter])
+        if (!held.has(id))
+          inter.delete(id);
+    if (inter.size === 0)
+      break;
+  }
+  return inter ?? /* @__PURE__ */ new Set();
+}
+function dualViewSeamDecision(bodyA, bodyB, typeToken) {
+  const fieldsA = objectFieldAccesses(bodyA, typeToken);
+  const fieldsB = objectFieldAccesses(bodyB, typeToken);
+  if (fieldsA.size === 0 || fieldsB.size === 0) {
+    return { keep: true, reason: "field info unavailable on a phase \u2014 degraded to object-granular (kept)" };
+  }
+  const shared = [...fieldsA.keys()].filter((f) => fieldsB.has(f));
+  if (shared.length === 0) {
+    return { keep: false, reason: `disjoint fields (A:{${[...fieldsA.keys()].join(",")}} vs B:{${[...fieldsB.keys()].join(",")}}) \u2014 not a same-field seam` };
+  }
+  const eventsA = lockEvents(bodyA);
+  const eventsB = lockEvents(bodyB);
+  for (const f of shared) {
+    const covA = fieldCoveringLocks(eventsA, fieldsA.get(f));
+    const covB = fieldCoveringLocks(eventsB, fieldsB.get(f));
+    const common = [...covA].filter((id) => covB.has(id));
+    if (common.length === 0) {
+      const lockNote = covA.size === 0 || covB.size === 0 ? `field '${f}' is accessed LOCKLESS in at least one phase` : `field '${f}' is held under DIFFERENT locks ({${[...covA].join(",")}} vs {${[...covB].join(",")}})`;
+      return { keep: true, sharedField: f, reason: `same-field seam on '${f}' \u2014 ${lockNote}` };
+    }
+  }
+  return {
+    keep: false,
+    reason: `all shared field(s) {${shared.join(",")}} are covered by a common lock in BOTH phases \u2014 serialized, not a seam`
+  };
+}
+var RELEVANCE_RANK = {
+  lifetime: 5,
+  type: 4,
+  bounds: 3,
+  authz: 2,
+  other: 1
+};
+var KIND_RANK = {
+  "ownership-exclusive": 3,
+  "refcount-positive": 3,
+  "called-once": 3,
+  "state-precondition": 3,
+  revalidated: 2,
+  "field-initialized": 2,
+  "size-consistent": 2,
+  "lock-held": 2,
+  "validated-range": 1,
+  "non-null": 1
+};
+var GEOMETRY_BONUS_CAP = 90;
+function assumptionGeometryBonus(a) {
+  const object = (a.object ?? a.oracle.target ?? "").trim();
+  if (!object)
+    return 0;
+  const synthetic = {
+    title: object,
+    description: `${a.predicate} ${a.kind} ${a.securityRelevance}`,
+    evidence: { analysis: `${object} ${a.oracle.target ?? ""}` },
+    category: ""
+  };
+  const g = scoreGeometry(synthetic);
+  return g.geometryScore > 0 ? Math.min(g.geometryScore, GEOMETRY_BONUS_CAP) : 0;
+}
+function scoreDualViewWeaponizability(a) {
+  const rel = RELEVANCE_RANK[a.securityRelevance] ?? 0;
+  const kind = KIND_RANK[a.kind] ?? 0;
+  const geom = assumptionGeometryBonus(a);
+  const score = rel * 1e3 + kind * 100 + geom;
+  const rationale = [
+    `securityRelevance=${a.securityRelevance} (rank ${rel}/5)`,
+    `kind=${a.kind} (rank ${kind}/3)`,
+    ...geom > 0 ? [`+${geom} object-on-weaponizable-slab geometry ('${a.object ?? a.oracle.target}')`] : []
+  ];
+  return { score, rationale };
+}
+function scanDualViewContexts(kept, cg, sources, bodies, opts = {}) {
+  const log = opts.log ?? (() => {
+  });
+  const maxContexts = opts.maxContexts ?? 60;
+  const kinds = opts.crossApiKinds ?? DEFAULT_CROSS_API_KINDS;
+  const reachDepth = opts.reachDepth ?? 12;
+  const maxTouchers = opts.maxTouchers ?? Infinity;
+  const maxPairsPerObject = opts.maxPairsPerObject ?? 6;
+  const denylist = opts.objectDenylist ?? UBIQUITOUS_OBJECT_TYPES;
+  const fieldGranular = opts.fieldGranular !== false;
+  const crossApi = kept.filter((a) => isCrossApiAssumption(a, kinds) && objectTypeToken(a));
+  if (crossApi.length === 0) {
+    log("[dual-view] no cross-api/cross-phase assumptions with a typed object to enumerate");
+    return [];
+  }
+  const establisherTokens = /* @__PURE__ */ new Set();
+  for (const a of crossApi) {
+    establisherTokens.add(a.oracle.establisherToken);
+    for (const alias of a.oracle.establisherAliases ?? [])
+      if (isMechanizableEstablisher(alias))
+        establisherTokens.add(alias);
+  }
+  const exported = collectExportedSymbols(sources);
+  const wrappers = opts.resolveWrappers === false ? void 0 : computeEstablisherWrappers(cg, establisherTokens, opts.wrapperRounds ?? 4);
+  const est = computeEstablisherSets(cg, establisherTokens, exported, opts.maxPropagationRounds ?? 8, wrappers);
+  const adj = buildAdjacency(cg);
+  const defined = new Set(cg.fns.map((f) => f.name));
+  const hasInternalCaller = /* @__PURE__ */ new Set();
+  for (const fn of cg.fns)
+    for (const call of fn.calls)
+      if (defined.has(call.callee))
+        hasInternalCaller.add(call.callee);
+  const isEntry = (n) => UNPRIV_ENTRY_RE.test(n) || exported.has(n) || !hasInternalCaller.has(n);
+  const contexts = [];
+  const seenPair = /* @__PURE__ */ new Set();
+  const suppressed = /* @__PURE__ */ new Map();
+  for (const a of crossApi) {
+    const type = objectTypeToken(a);
+    if (denylist.has(type)) {
+      suppressed.set(type, "ubiquitous type (needs per-instance aliasing, not a static type grep)");
+      continue;
+    }
+    const token = a.oracle.establisherToken;
+    const aliases = (a.oracle.establisherAliases ?? []).filter(isMechanizableEstablisher);
+    const establishesE = (fn) => {
+      const s = est.get(fn);
+      return !!s && (s.has(token) || aliases.some((al) => s.has(al)));
+    };
+    const typeRe = new RegExp(`\\b${escapeRe3(type)}\\b`);
+    const touchers = cg.fns.filter((f) => {
+      const b = bodies.get(f.name);
+      return b != null && typeRe.test(b);
+    }).map((f) => f.name);
+    if (touchers.length < 2)
+      continue;
+    if (touchers.length > maxTouchers) {
+      suppressed.set(type, `${touchers.length} touchers > ${maxTouchers} (pervasive in-subsystem type, not a focused seam)`);
+      continue;
+    }
+    const establishing = touchers.filter(establishesE);
+    const skipping = touchers.filter((t) => !establishesE(t));
+    if (establishing.length === 0 || skipping.length === 0)
+      continue;
+    let emittedForObject = 0;
+    for (const tB of skipping) {
+      if (emittedForObject >= maxPairsPerObject)
+        break;
+      let tA;
+      let seam;
+      for (const x of establishing) {
+        if (x === tB || reachesFn(adj, x, tB, reachDepth) || reachesFn(adj, tB, x, reachDepth))
+          continue;
+        if (fieldGranular) {
+          const d = dualViewSeamDecision(bodies.get(x) ?? "", bodies.get(tB) ?? "", type);
+          if (!d.keep) {
+            seam = seam ?? d;
+            continue;
+          }
+          tA = x;
+          seam = d;
+          break;
+        }
+        tA = x;
+        break;
+      }
+      if (!tA) {
+        if (fieldGranular && seam)
+          log(`[dual-view] dropped ${tB}() on 'struct ${type}': ${seam.reason}`);
+        continue;
+      }
+      const key = `${a.id}|${tA}|${tB}`;
+      if (seenPair.has(key))
+        continue;
+      seenPair.add(key);
+      const sharedField = seam?.sharedField;
+      const fnB = cg.byName.get(tB);
+      const b = bodies.get(tB) ?? "";
+      const mm = typeRe.exec(b);
+      let line = fnB.startLine;
+      if (mm) {
+        let nl = 0;
+        for (let k = 0; k < mm.index; k++)
+          if (b[k] === "\n")
+            nl++;
+        line = fnB.startLine + nl;
+      }
+      contexts.push({
+        assumptionId: a.id,
+        subject: a.subject,
+        caller: tB,
+        callerFile: fnB.file,
+        callLine: line,
+        establisherToken: token,
+        unprivEntry: isEntry(tB),
+        dualView: true,
+        pairedEntry: tA,
+        object: type,
+        ...sharedField ? { field: sharedField } : {},
+        detail: `DUAL-VIEW (cross-api/cross-phase): ${tA}() and ${tB}() both operate on 'struct ${type}'${sharedField ? `.${sharedField}` : ""}, reached via DISTINCT call-trees (neither calls the other). ${tA}() ESTABLISHES ${token}${aliases.length ? `/${aliases.join("/")}` : ""} on the object; ${tB}() reaches the SAME object type WITHOUT it. ${sharedField ? `Both contend on field '${sharedField}' (${seam?.reason}). ` : ""}${a.subject}() RELIES ON: ${a.predicate} (${a.kind}, ${a.securityRelevance}). If ${tB}() can run on the SAME ${type} INSTANCE concurrently with, or after, ${tA}()'s guarantee, the cross-api assumption is VIOLATED. CANDIDATE to DISPROVE \u2014 type-name toucher grep + field-match + name-based establisher set: confirm (1) both paths reach the SAME instance (aliasing / a shared table / an fd), and (2) ${token} is genuinely absent on ${tB}()'s path.`
+      });
+      emittedForObject++;
+    }
+  }
+  if (suppressed.size > 0) {
+    log(`[dual-view] suppressed ${suppressed.size} pervasive object type(s): ${[...suppressed.entries()].map(([t, r]) => `${t} (${r})`).join("; ")}`);
+  }
+  const scoreById = /* @__PURE__ */ new Map();
+  for (const a of kept)
+    scoreById.set(a.id, scoreDualViewWeaponizability(a).score);
+  contexts.sort((x, y) => Number(y.unprivEntry) - Number(x.unprivEntry) || (scoreById.get(y.assumptionId) ?? 0) - (scoreById.get(x.assumptionId) ?? 0) || (x.object ?? "").localeCompare(y.object ?? "") || x.caller.localeCompare(y.caller));
+  const capped = contexts.slice(0, maxContexts);
+  log(`[dual-view] ${contexts.length} dual-view context(s)${capped.length < contexts.length ? ` (capped to ${capped.length})` : ""}`);
+  return capped;
+}
+function assumptionsToHuntPlan(model, kept, contexts) {
+  const bySite = /* @__PURE__ */ new Map();
+  for (const ctx of contexts) {
+    const hint = `ASSUMPTION-VIOLATION candidate (seedless, from mined assumption model). Subject ${ctx.subject}() relies on an establisher (${ctx.establisherToken}) that caller ${ctx.caller}() reaches it without. ${ctx.detail}`;
+    const existing = bySite.get(ctx.callerFile);
+    if (existing)
+      existing.hint = `${existing.hint}
+---
+${hint}`;
+    else
+      bySite.set(ctx.callerFile, { path: ctx.callerFile, hint });
+  }
+  const kinds = [...new Set(kept.map((a) => a.kind))].join(", ");
+  const brief = {
+    bugClass: `relied-on-assumption violation (seedless, assumption-mining): ${kinds || "precondition not established on a reachable path"}`,
+    pattern: `A function in ${model.subsystem} RELIES ON a precondition it does not itself establish (a validated ref, a held lock, a re-checked value, a once-only init, an exclusive owner, a caller-side capability check), and a reachable context reaches the same object/function WITHOUT establishing it. The candidate sites below are callers found (deterministically) to reach the relied-on subject without the establisher token and without inheriting it from their own callers. Verify each is a real, attacker-reachable violation \u2014 confirm the establisher is genuinely absent on THIS path (not present under a different name, not established by an unfollowed indirect caller) before trusting it.`,
+    fixReference: void 0
+  };
+  return { model, kept, contexts, brief, candidates: [...bySite.values()] };
+}
+function buildFocusedCandidates(kept, contexts, bodies, excerptDir) {
+  const predById = new Map(kept.map((a) => [a.id, a.predicate]));
+  const byCaller = /* @__PURE__ */ new Map();
+  for (const ctx of contexts) {
+    const arr = byCaller.get(ctx.caller) ?? [];
+    arr.push(ctx);
+    byCaller.set(ctx.caller, arr);
+  }
+  const candidates = [];
+  const missedCallers = [];
+  let wrote = false;
+  for (const [caller, ctxs] of byCaller) {
+    const callerBody = bodies.get(caller);
+    if (!callerBody) {
+      missedCallers.push(caller);
+      continue;
+    }
+    if (!wrote) {
+      mkdirSync3(excerptDir, { recursive: true });
+      wrote = true;
+    }
+    const subjects = [...new Set(ctxs.map((c) => c.subject))];
+    const header = `/* FOCUSED EXCERPT \u2014 seedless assumption-violation candidate(s) to DISPROVE.
+ * Caller ${caller}() at ${ctxs[0].callerFile}:${ctxs[0].callLine} reaches, WITHOUT establishing the precondition:
+` + ctxs.map((c) => ` *   ${c.subject}()  \u2014 relies on establisher '${c.establisherToken}': ${predById.get(c.assumptionId) ?? ""}`).join("\n") + `
+ * Confirm the establisher is GENUINELY ABSENT on the reachable path: not present under a
+ * wrapper/alias, not established by an unfollowed indirect (fn-pointer/macro) caller. If it is
+ * present under any name, this is a FALSE POSITIVE. Original tree lines are in the headers below. */
+`;
+    const label = ctxs.some((c) => c.dualView) ? "skipping view (entryB)" : "violating caller";
+    const parts = [header, `/* --- ${label}: ${caller}() (${ctxs[0].callerFile}) --- */
+${callerBody}
+`];
+    const pairedEntries = [...new Set(ctxs.map((c) => c.pairedEntry).filter((p) => !!p))];
+    for (const p of pairedEntries) {
+      const b = bodies.get(p);
+      if (b)
+        parts.push(`/* --- paired establishing view (entryA): ${p}() --- */
+${b}
+`);
+    }
+    for (const s of subjects) {
+      if (pairedEntries.includes(s))
+        continue;
+      const b = bodies.get(s);
+      if (b)
+        parts.push(`/* --- relied-on subject: ${s}() --- */
+${b}
+`);
+    }
+    const safe = caller.replace(/[^A-Za-z0-9_]/g, "_") || "caller";
+    const path = join(excerptDir, `${safe}.c`);
+    writeFileSync3(path, parts.join("\n"), "utf8");
+    const hint = `ASSUMPTION-VIOLATION candidate (focused excerpt: ${caller}() + its relied-on subject(s)). ` + ctxs.map((c) => c.detail).join("\n---\n");
+    candidates.push({ path, hint });
+  }
+  return { candidates, missedCallers };
+}
+async function runAssumptionHunt(input) {
+  const log = input.log ?? (() => {
+  });
+  let model;
+  let modelLoaded = false;
+  if (!input.remine) {
+    try {
+      model = loadAssumptionModel(input.modelPath);
+      modelLoaded = true;
+      log(`[assumption] loaded stored model ${input.modelPath} (${model.assumptions.length} assumption(s)) \u2014 no LLM call`);
+    } catch {
+      model = await mineAssumptions(input);
+      storeAssumptionModel(model, input.modelPath);
+      log(`[assumption] mined + stored model ${input.modelPath}`);
+    }
+  } else {
+    model = await mineAssumptions(input);
+    storeAssumptionModel(model, input.modelPath);
+    log(`[assumption] re-mined + stored model ${input.modelPath}`);
+  }
+  const sources = [];
+  for (const file of input.subsystemFiles) {
+    const text = readSource2(input.sourceRoot, file);
+    if (text != null)
+      sources.push({ file, text });
+  }
+  if (sources.length === 0)
+    throw new Error("assumption hunt could not read any subsystemFile under sourceRoot");
+  const cg = buildCallGraph(sources);
+  const bodies = buildFunctionBodyIndex(sources);
+  const crossCheck = crossCheckAssumptions(model, bodies);
+  log(`[assumption] 1b: ${crossCheck.kept.length} kept, ${crossCheck.dropped.length} dropped, ${crossCheck.reclassified.length} reclassified enforced\u2192relied`);
+  const contexts = scanViolatingContexts(crossCheck.kept, cg, sources, bodies, { ...input.scanOptions, log });
+  const dualViewContexts = input.dualView === false ? [] : scanDualViewContexts(crossCheck.kept, cg, sources, bodies, { ...input.dualViewOptions, log });
+  const allContexts = [...contexts, ...dualViewContexts];
+  const plan = assumptionsToHuntPlan(model, crossCheck.kept, allContexts);
+  let witness;
+  if (input.dynamicWitness && dualViewContexts.length > 0) {
+    const { maxCandidates, rotationStatePath, now, ...deps } = input.dynamicWitness;
+    witness = await witnessDualViewContexts({
+      contexts: dualViewContexts,
+      kept: crossCheck.kept,
+      bodies,
+      subsystem: input.subsystem,
+      ...maxCandidates !== void 0 ? { maxCandidates } : {},
+      ...rotationStatePath !== void 0 ? { rotationStatePath } : {},
+      ...now !== void 0 ? { now } : {},
+      deps,
+      log
+    });
+    log(`[assumption] dynamic-witness: ${witness.confirmed.length} confirmed, ${witness.refuted.length} refuted, ${witness.inconclusive.length} inconclusive`);
+  }
+  if (input.skipHunt || plan.candidates.length === 0) {
+    return { model, modelPath: input.modelPath, modelLoaded, crossCheck, contexts, dualViewContexts, plan, ...witness ? { witness } : {} };
+  }
+  let candidates = plan.candidates;
+  if (input.finderTargeting !== false) {
+    const excerptDir = input.excerptDir ?? join(tmpdir(), `0sec-assumption-excerpts-${process.pid}`);
+    const focused = buildFocusedCandidates(crossCheck.kept, allContexts, bodies, excerptDir);
+    const missed = new Set(focused.missedCallers);
+    const fallback = plan.candidates.filter((c) => allContexts.some((ctx) => missed.has(ctx.caller) && ctx.callerFile === c.path));
+    candidates = [...focused.candidates, ...fallback];
+    log(`[assumption] finder-targeting: ${focused.candidates.length} focused excerpt(s) in ${excerptDir}${fallback.length ? ` + ${fallback.length} per-file fallback (unreadable caller bodies)` : ""}`);
+  }
+  const verify = input.verify ?? makeSkepticVerifier({ sourceRoot: input.sourceRoot, runtime: input.runtime });
+  const hunt = await runHuntScan({
+    sourceRoot: input.sourceRoot,
+    candidates,
+    brief: plan.brief,
+    runtime: input.runtime,
+    ...input.finderModels && input.finderModels.length > 0 ? { models: input.finderModels } : {},
+    verify,
+    ...input.exploitability ? { exploitability: input.exploitability } : {},
+    log
+  });
+  return { model, modelPath: input.modelPath, modelLoaded, crossCheck, contexts, dualViewContexts, plan, hunt, ...witness ? { witness } : {} };
+}
+
+export {
+  parseC,
+  DEFAULT_ACQUIRE_FNS,
+  DEFAULT_RELEASE_FNS,
+  releaseFnsFor,
+  canon,
+  normalizeLockToken,
+  collectFunctions,
+  findViolationsDataflow,
+  findInterprocRefcountCouplings,
+  couplingsToHuntPlan,
+  extractInvariantSpec,
+  INVARIANT_MODEL_VERSION,
+  resolveContainedSourcePath,
+  buildInvariantModel,
+  storeInvariantModel,
+  loadInvariantModel,
+  findInvariantViolations,
+  findInvariantViolationsTokenLevel,
+  violationsToHuntPlan,
+  runSubsystemInvariantHunt,
+  dualViewCandidateFromContext,
+  buildSynthesisPrompt,
+  extractCFromLlmOutput,
+  makeDefaultSynthesizePoc,
+  defaultBootPoc,
+  candidateReferenceTokens,
+  extractSplatRegion,
+  pocFabricatesSplat,
+  checkWitness,
+  witnessAssumptionViolation,
+  witnessDualViewContexts,
+  ASSUMPTION_MODEL_VERSION,
+  mineAssumptions,
+  normalizeAssumptions,
+  storeAssumptionModel,
+  loadAssumptionModel,
+  isMechanizableEstablisher,
+  subjectSelfEnforces,
+  crossCheckAssumptions,
+  buildFunctionBodyIndex,
+  computeEstablisherWrappers,
+  computeEstablisherSets,
+  scanViolatingContexts,
+  isCrossApiAssumption,
+  objectTypeToken,
+  objectFieldAccesses,
+  heldLockIdsAt,
+  dualViewSeamDecision,
+  scoreDualViewWeaponizability,
+  scanDualViewContexts,
+  assumptionsToHuntPlan,
+  buildFocusedCandidates,
+  runAssumptionHunt
+};