@afokapu/atdd-bun 0.1.0

package/detectors/bun_interlocking_infrastructure/checks/interlocking_resolution_model.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env bun
+// Check: coder.bun.interlocking-resolution-model-exists  (disposition: strict)
+//
+// When an InterlockingRunner exposes `resolveTrain(...)`, it MUST resolve a structured
+// `InterlockingResolution` model carrying the route metadata — not a bare `trainId` string. The
+// model MUST define interlockingId, routeId, trainId, trainPath, category, guardId, resolutionStrategy,
+// reason (Bun mirror of core coder.train.interlocking-resolution-model-exists / #1251).
+import {
+  parseJsonEnv,
+  readText,
+  findConsumerRoots,
+  runtimeFiles,
+  hasRunnerClass,
+  hasResolveTrain,
+  resolutionModelFields,
+  runnerClassLine,
+  REQUIRED_RESOLUTION_FIELDS,
+  rel,
+  lineAt,
+  mk,
+  writeReport,
+} from "../_shared/interlocking.mjs";
+
+const RULE = "coder.bun.interlocking-resolution-model-exists";
+const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
+const violations = [];
+
+for (const scanRoot of roots) {
+  for (const croot of findConsumerRoots(scanRoot)) {
+    const files = runtimeFiles(croot).map((f) => ({ file: f, text: readText(f) }));
+    const runnerFiles = files.filter((x) => hasRunnerClass(x.text));
+    if (runnerFiles.length === 0) continue; // resolution-model is a runner concern only.
+
+    const hasResolve = runnerFiles.some((x) => hasResolveTrain(x.text));
+    if (!hasResolve) continue; // missing resolveTrain is the runner-exists concern.
+
+    // Merge resolution-model fields across the runtime (model may live in a sibling module).
+    let fields = null;
+    for (const { text } of files) {
+      const f = resolutionModelFields(text);
+      if (f !== null) fields = fields ? new Set([...fields, ...f]) : f;
+    }
+
+    const missing = REQUIRED_RESOLUTION_FIELDS.filter((k) => !(fields && fields.has(k)));
+    if (missing.length > 0) {
+      const target = runnerFiles[0];
+      const line = runnerClassLine(target.text);
+      violations.push(
+        mk(
+          RULE,
+          rel(target.file, croot),
+          line,
+          0,
+          "bare-train-id-resolution: resolveTrain resolves a bare trainId; a structured " +
+            "InterlockingResolution model is missing required field(s): " +
+            missing.join(", "),
+          lineAt(target.text, line),
+        ),
+      );
+    }
+  }
+}
+
+writeReport(violations);

package/detectors/bun_interlocking_infrastructure/checks/interlocking_runner_exists.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env bun
+// Check: coder.bun.interlocking-runner-exists  (disposition: strict)
+//
+// A consumer whose Station Master JOURNEY_MAP declares an interlocking route MUST ship an
+// `InterlockingRunner` route-control layer under src/trains/**, exposing a `resolveTrain(...)`
+// entry point (Bun mirror of core coder.train.interlocking-runner-exists / afokapu/atdd#1251).
+// A pure direct-train consumer carries no obligation.
+import {
+  parseJsonEnv,
+  readText,
+  findConsumerRoots,
+  runtimeFiles,
+  appFile,
+  journeyMap,
+  hasRunnerClass,
+  hasResolveTrain,
+  runnerClassLine,
+  rel,
+  lineAt,
+  mk,
+  writeReport,
+} from "../_shared/interlocking.mjs";
+
+const RULE = "coder.bun.interlocking-runner-exists";
+const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
+const violations = [];
+
+for (const scanRoot of roots) {
+  for (const croot of findConsumerRoots(scanRoot)) {
+    const app = appFile(croot);
+    const appText = app ? readText(app) : "";
+    const jm = journeyMap(appText);
+    const runnerFiles = runtimeFiles(croot)
+      .map((f) => ({ file: f, text: readText(f) }))
+      .filter((x) => hasRunnerClass(x.text));
+
+    const enabled = jm.hasInterlocking || runnerFiles.length > 0;
+    if (!enabled) continue;
+
+    if (jm.hasInterlocking && runnerFiles.length === 0 && app) {
+      const line = jm.interlockingLine || 1;
+      violations.push(
+        mk(
+          RULE,
+          rel(app, croot),
+          line,
+          0,
+          "missing-interlocking-runner: JOURNEY_MAP declares an interlocking route but no " +
+            "InterlockingRunner class exists under src/trains/ (core afokapu/atdd#1251)",
+          lineAt(appText, line),
+        ),
+      );
+    }
+
+    for (const { file, text } of runnerFiles) {
+      if (!hasResolveTrain(text)) {
+        const line = runnerClassLine(text);
+        violations.push(
+          mk(
+            RULE,
+            rel(file, croot),
+            line,
+            0,
+            "missing-resolve-train: InterlockingRunner has no resolveTrain(...) entry point",
+            lineAt(text, line),
+          ),
+        );
+      }
+    }
+  }
+}
+
+writeReport(violations);

package/detectors/bun_interlocking_infrastructure/checks/interlocking_station_routing.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env bun
+// Check: coder.bun.station-master-interlocking-routing  (disposition: strict)
+//
+// When the Station Master composition root (server.ts) declares an interlocking route object in
+// its JOURNEY_MAP, it MUST reference `InterlockingRunner` (else unlinked) and `TrainRunner` (else no
+// delegation). Bun mirror of core coder.train.station-master-interlocking-routing (#1251).
+import {
+  parseJsonEnv,
+  readText,
+  findConsumerRoots,
+  appFile,
+  journeyMap,
+  referencesToken,
+  rel,
+  lineAt,
+  mk,
+  writeReport,
+} from "../_shared/interlocking.mjs";
+
+const RULE = "coder.bun.station-master-interlocking-routing";
+const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
+const violations = [];
+
+for (const scanRoot of roots) {
+  for (const croot of findConsumerRoots(scanRoot)) {
+    const app = appFile(croot);
+    if (!app) continue;
+    const text = readText(app);
+    const jm = journeyMap(text);
+    if (!jm.hasInterlocking) continue; // pure direct-train Station Master carries no obligation.
+
+    const line = jm.interlockingLine || 1;
+    if (!referencesToken(text, "InterlockingRunner")) {
+      violations.push(
+        mk(
+          RULE,
+          rel(app, croot),
+          line,
+          0,
+          "station-master-unlinked: Station Master declares an interlocking route but never " +
+            "references InterlockingRunner",
+          lineAt(text, line),
+        ),
+      );
+    }
+    if (!referencesToken(text, "TrainRunner")) {
+      violations.push(
+        mk(
+          RULE,
+          rel(app, croot),
+          line,
+          0,
+          "station-master-no-trainrunner-delegation: Station Master never references TrainRunner; " +
+            "the selected train must be executed by TrainRunner",
+          lineAt(text, line),
+        ),
+      );
+    }
+  }
+}
+
+writeReport(violations);

package/detectors/bun_interlocking_infrastructure/checks/journey_runner_boundary.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+// Check: coder.bun.journey-runner-boundary (disposition: strict)
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import {
+  parseJsonEnv,
+  readText,
+  findConsumerRoots,
+  runtimeFiles,
+  referencesToken,
+  importsWagon,
+  runTrainCalls,
+  sequenceLoops,
+  cargoUses,
+  rel,
+  lineOfIndex,
+  lineAt,
+  mk,
+  writeReport,
+  maskComments,
+} from "../_shared/interlocking.mjs";
+
+const RULE = "coder.bun.journey-runner-boundary";
+const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
+const violations = [];
+
+function hasJourneyTopology(root) {
+  const base = join(root, "plan", "_journeys");
+  if (!existsSync(base)) return false;
+  const stack = [base];
+  while (stack.length) {
+    const dir = stack.pop();
+    for (const name of readdirSync(dir)) {
+      const path = join(dir, name);
+      const st = statSync(path);
+      if (st.isDirectory()) stack.push(path);
+      else if (/\.ya?ml$/.test(name)) return true;
+    }
+  }
+  return false;
+}
+
+function journeyRunnerLine(text) {
+  const match = /\bclass\s+JourneyRunner\b/.exec(maskComments(text));
+  return match ? lineOfIndex(text, match.index) : 1;
+}
+
+function loadsJourneyDeclaration(text) {
+  const masked = maskComments(text);
+  const readsJourneyPath =
+    /Bun\.file\s*\(\s*[^)]*(?:journey|_journeys)/i.test(masked) ||
+    /\breadFile(?:Sync)?\s*\(\s*[^,)]*(?:journey|_journeys)/i.test(masked);
+  const parsesDeclaration = /Bun\.YAML\.parse\s*\(|JSON\.parse\s*\(/.test(masked);
+  return readsJourneyPath && parsesDeclaration;
+}
+
+function hiddenTopologyLiterals(text) {
+  const masked = maskComments(text);
+  const hits = [];
+  const re = /(["'`])((?:plan\/_trains\/_interlockings\/[a-z][a-z0-9-]*\.ya?ml)|(?:interlocking:[a-z][a-z0-9-]+))\1/g;
+  let match;
+  while ((match = re.exec(masked)) !== null) {
+    const line = lineOfIndex(masked, match.index);
+    hits.push({ line, value: match[2], src: lineAt(text, line) });
+  }
+  return hits;
+}
+
+function hardcodedInterlockingConstruction(text) {
+  const masked = maskComments(text);
+  const hits = [];
+  const re = /new\s+InterlockingRunner\s*\(\s*(["'`])([^"'`]+)\1/g;
+  let match;
+  while ((match = re.exec(masked)) !== null) {
+    const line = lineOfIndex(masked, match.index);
+    hits.push({ line, value: match[2], src: lineAt(text, line) });
+  }
+  return hits;
+}
+
+for (const scanRoot of roots) {
+  for (const croot of findConsumerRoots(scanRoot)) {
+    if (!hasJourneyTopology(croot)) continue;
+    const modules = runtimeFiles(croot)
+      .map(file => ({ file, text: readText(file) }))
+      .filter(item => /\bclass\s+JourneyRunner\b/.test(maskComments(item.text)));
+
+    if (modules.length === 0) {
+      violations.push(mk(
+        RULE,
+        "plan/_journeys",
+        1,
+        0,
+        "missing-journey-runner: journey topology is declared but no JourneyRunner class exists under src/trains/",
+        "",
+      ));
+      continue;
+    }
+
+    const runtimeSurface = runtimeFiles(croot).map(readText).join("\n");
+    const loadsDeclaration = loadsJourneyDeclaration(runtimeSurface);
+
+    for (const { file, text } of modules) {
+      const line = journeyRunnerLine(text);
+      if (!loadsDeclaration) violations.push(mk(
+        RULE,
+        rel(file, croot),
+        line,
+        0,
+        "journey-runtime-transcription: JourneyRunner does not read and parse a journey declaration; topology may be hardcoded",
+        lineAt(text, line),
+      ));
+      for (const hit of hardcodedInterlockingConstruction(text)) violations.push(mk(
+        RULE,
+        rel(file, croot),
+        hit.line,
+        0,
+        "journey-runtime-hidden-topology: JourneyRunner constructs InterlockingRunner from literal " + hit.value + " instead of declared continuation data",
+        hit.src,
+      ));
+      for (const hit of hiddenTopologyLiterals(text)) violations.push(mk(
+        RULE,
+        rel(file, croot),
+        hit.line,
+        0,
+        "journey-runtime-hidden-topology: JourneyRunner contains static topology literal " + hit.value + " instead of deriving it from the journey declaration",
+        hit.src,
+      ));
+      if (!referencesToken(text, "InterlockingRunner")) violations.push(mk(
+        RULE,
+        rel(file, croot),
+        line,
+        0,
+        "journey-runner-bypasses-interlocking: JourneyRunner must delegate routing decisions to InterlockingRunner",
+        lineAt(text, line),
+      ));
+      if (referencesToken(text, "TrainRunner")) violations.push(mk(
+        RULE,
+        rel(file, croot),
+        line,
+        0,
+        "journey-runner-executes-train: JourneyRunner references TrainRunner directly; train execution belongs behind InterlockingRunner",
+        lineAt(text, line),
+      ));
+      for (const hit of importsWagon(text)) violations.push(mk(RULE, rel(file, croot), hit.line, 0, "journey-runner-executes-wagon: JourneyRunner imports a wagon module", hit.src));
+      for (const hit of runTrainCalls(text)) violations.push(mk(RULE, rel(file, croot), hit.line, 0, "journey-runner-executes-wagon: JourneyRunner calls runTrain(...) directly", hit.src));
+      for (const hit of sequenceLoops(text)) violations.push(mk(RULE, rel(file, croot), hit.line, 0, "journey-runner-executes-sequence: JourneyRunner loops over train.sequence", hit.src));
+      for (const hit of cargoUses(text)) violations.push(mk(RULE, rel(file, croot), hit.line, 0, "journey-runner-carries-cargo: JourneyRunner " + hit.detail, hit.src));
+    }
+  }
+}
+
+writeReport(violations);

package/detectors/bun_interlocking_infrastructure/checks/journey_station_routing.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env bun
+// Check: coder.bun.station-master-journey-routing (disposition: strict)
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import {
+  parseJsonEnv,
+  readText,
+  findConsumerRoots,
+  appFile,
+  referencesToken,
+  lineAt,
+  lineOfIndex,
+  mk,
+  writeReport,
+  maskComments,
+} from "../_shared/interlocking.mjs";
+
+const RULE = "coder.bun.station-master-journey-routing";
+const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
+const violations = [];
+
+function escapeRegExp(value) {
+  return value.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+
+function journeyDocuments(croot) {
+  const base = join(croot, "plan", "_journeys");
+  if (!existsSync(base)) return [];
+  const out = [], stack = [base];
+  while (stack.length) {
+    const dir = stack.pop();
+    for (const name of readdirSync(dir)) {
+      const path = join(dir, name), st = statSync(path);
+      if (st.isDirectory()) stack.push(path);
+      else if (/\.ya?ml$/.test(name)) {
+        try {
+          const data = Bun.YAML.parse(readText(path));
+          if (data && typeof data === "object") out.push({
+            file: relative(croot, path).replaceAll("\\", "/"),
+            data,
+          });
+        } catch {}
+      }
+    }
+  }
+  return out;
+}
+
+function actionMapping(text, action) {
+  const masked = maskComments(text);
+  const key = escapeRegExp(action);
+  const re = new RegExp("(?:[\\\"']" + key + "[\\\"']|\\b" + key + "\\b)\\s*:\\s*\\{([\\s\\S]*?)\\}", "m");
+  const match = re.exec(masked);
+  if (!match) return null;
+  return { body: match[1], line: lineOfIndex(masked, match.index) };
+}
+
+for (const scanRoot of roots) {
+  for (const croot of findConsumerRoots(scanRoot)) {
+    const journeys = journeyDocuments(croot).filter(item => item.data?.entrypoint?.exposed === true);
+    if (journeys.length === 0) continue;
+
+    const app = appFile(croot);
+    if (!app) {
+      for (const journey of journeys) violations.push(mk(
+        RULE,
+        journey.file,
+        1,
+        0,
+        "journey-station-missing: exposed journey has no server.ts Station Master composition root",
+        "",
+      ));
+      continue;
+    }
+
+    const text = readText(app);
+    const appPath = relative(croot, app).replaceAll("\\", "/");
+    if (!referencesToken(text, "JourneyRunner")) violations.push(mk(
+      RULE,
+      appPath,
+      1,
+      0,
+      "journey-station-unlinked: exposed journeys exist but Station Master never references JourneyRunner",
+      lineAt(text, 1),
+    ));
+
+    for (const journey of journeys) {
+      const id = String(journey.data.journey_id ?? "");
+      const actions = Array.isArray(journey.data?.entrypoint?.actions) ? journey.data.entrypoint.actions : [];
+      for (const action of actions) {
+        const mapping = actionMapping(text, String(action));
+        if (!mapping) {
+          violations.push(mk(
+            RULE,
+            appPath,
+            1,
+            0,
+            "journey-station-action-missing: action " + action + " does not appear in JOURNEY_MAP for " + id,
+            lineAt(text, 1),
+          ));
+          continue;
+        }
+        const hasId = mapping.body.includes(id);
+        const hasPath = mapping.body.includes(journey.file);
+        const hasJourneyKey = /\bjourney(?:Id|_id)\b/.test(mapping.body);
+        if (!hasId || !hasPath || !hasJourneyKey) violations.push(mk(
+          RULE,
+          appPath,
+          mapping.line,
+          0,
+          "journey-station-binding-mismatch: action " + action + " must map to {journeyId: " + id + ", path: " + journey.file + "}",
+          lineAt(text, mapping.line),
+        ));
+      }
+    }
+  }
+}
+
+writeReport(violations);

package/detectors/bun_interlocking_infrastructure/checks/wagon_contract_honoured.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env bun
+// Member check: coder.bun.wagon-honours-its-contract  (interlocking infrastructure family)
+//
+// A wagon's plan document declares a DATA CONTRACT — `produce[]` are the artifacts it
+// owns and `consume[]` the ones it takes from other wagons (core's wagon.schema.json
+// requires both). The implementation must actually move those artifacts through Cargo.
+//
+// Nothing checked that. A wagon declaring `produce: [{name: orders:confirmed-order}]`
+// and `consume: [{name: orders:priced-basket}]` whose code mentions neither passed
+// every gated rule in this workspace. The declaration and the code were free to drift
+// apart, which is the same class as a runtime that transcribes its route space instead
+// of executing it.
+//
+// Core owns the SHAPE — wagon.schema.json validates that produce/consume exist and are
+// well formed, wherever the plan lives. It cannot know whether a Bun module puts those
+// artifacts into Cargo, because that means reading Bun source and this stack's Cargo
+// idiom. Shape is core's; binding is this extension's.
+//
+// NOT_APPLICABLE, deliberately, when the consumer declares no wagon contract, or when
+// no wagon implementation exists at all. A plan with no wagons has nothing to honour,
+// and a declared-but-unwritten wagon is an unimplemented feature, not a broken
+// contract — reporting it here would fire on every freshly planned repo.
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW violations to
+// ATDD_VIOLATIONS_REPORT, exits 0 regardless of count.
+import { readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
+import { join, sep } from "node:path";
+
+const RULE = "coder.bun.wagon-honours-its-contract";
+const EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+const TS = /\.(ts|tsx|mjs|js)$/;
+const TEST = /\.(test|spec)\.[cm]?[jt]sx?$/;
+
+const read = (p) => { try { return readFileSync(p, "utf8"); } catch { return ""; } };
+
+function parseJsonEnv(name, fallback) {
+  try { const v = JSON.parse(process.env[name] || ""); return Array.isArray(v) ? v : fallback; }
+  catch { return fallback; }
+}
+
+function walk(dir, pred, excludes) {
+  const out = [];
+  (function rec(d) {
+    let entries;
+    try { entries = readdirSync(d).sort(); } catch { return; }
+    for (const n of entries) {
+      if (excludes.includes(n)) continue;
+      const full = join(d, n);
+      let st;
+      try { st = statSync(full); } catch { continue; }
+      if (st.isDirectory()) rec(full);
+      else if (pred(full)) out.push(full);
+    }
+  })(dir);
+  return out;
+}
+
+function consumerRoots(root, excludes) {
+  const roots = [];
+  (function rec(d) {
+    let st;
+    try { st = statSync(d); } catch { return; }
+    if (!st.isDirectory()) return;
+    try { if (statSync(join(d, "plan")).isDirectory()) { roots.push(d); return; } } catch {}
+    let entries;
+    try { entries = readdirSync(d).sort(); } catch { return; }
+    for (const n of entries) if (!excludes.includes(n)) rec(join(d, n));
+  })(root);
+  return roots;
+}
+
+// Artifact names under `produce:` / `consume:` in a wagon document. Read line-wise
+// rather than with a YAML parser so this check carries no dependency the rest of the
+// family does not already have; the shape it reads is the one core's schema requires.
+export function wagonContract(text) {
+  if (!/^wagon:\s*\S/m.test(text)) return null;
+  const out = { produce: [], consume: [] };
+  let section = null;
+  for (const line of text.split(/\r?\n/)) {
+    const top = line.match(/^(\w+):\s*$/);
+    if (top) { section = top[1] === "produce" || top[1] === "consume" ? top[1] : null; continue; }
+    if (/^\S/.test(line)) { section = null; continue; }
+    if (!section) continue;
+    const name = line.match(/^\s*-?\s*name:\s*["']?([^"'#\s]+)["']?/);
+    if (name) out[section].push(name[1]);
+  }
+  return out.produce.length || out.consume.length ? out : null;
+}
+
+// Blank out COMMENTS, keeping string literals intact.
+//
+// The artifact name legitimately appears as a literal — `cargo.put("orders:confirmed-order")`
+// — so the usual mask-literals-and-comments helper cannot be used here; it would erase the
+// very evidence this rule looks for. Comments alone are masked, because a wagon must not be
+// able to honour its contract by MENTIONING the artifact in prose. Caught by a dirty fixture
+// whose explanatory comment named both artifacts and silenced the rule.
+export function maskComments(text) {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
+    .replace(/(^|[^:\\])\/\/[^\n]*/g, (m, p1) => p1 + " ".repeat(m.length - p1.length));
+}
+
+const reportPath = process.env.ATDD_VIOLATIONS_REPORT;
+if (!reportPath) {
+  process.stderr.write("bun-infra: ATDD_VIOLATIONS_REPORT not set\n");
+  process.exit(2);
+}
+const excludes = [...EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+const violations = [];
+
+for (const root of parseJsonEnv("ATDD_SCAN_ROOTS", [])) {
+  for (const croot of consumerRoots(root, excludes)) {
+    const contracts = [];
+    for (const f of walk(join(croot, "plan"), (p) => /\.ya?ml$/.test(p), excludes)) {
+      const c = wagonContract(read(f));
+      if (c) contracts.push({ file: f, ...c });
+    }
+    if (!contracts.length) continue;                     // no declared contract
+
+    const sources = walk(croot, (p) => TS.test(p) && !TEST.test(p), excludes)
+      .map((f) => ({ file: f, text: read(f) }));
+    // A wagon implementation is one that moves artifacts through Cargo. Detected by
+    // that behaviour rather than by filename — a `wagon.ts` naming heuristic is the
+    // kind of fitted check this hub has had to unpick more than once.
+    const wagonCode = sources.filter((s) => /\bCargo\b|\bcargo\s*\.\s*(?:put|get)\s*\(/.test(s.text));
+    if (!wagonCode.length) continue;                     // nothing implemented to judge
+
+    const blob = wagonCode.map((s) => maskComments(s.text)).join("\n");
+    for (const c of contracts) {
+      for (const [kind, names] of [["produce", c.produce], ["consume", c.consume]]) {
+        for (const name of names) {
+          if (blob.includes(name)) continue;
+          const rel = c.file.startsWith(croot + sep) ? c.file.slice(croot.length + 1) : c.file;
+          violations.push({
+            rule_id: RULE, file: rel, line: 1, col: 0,
+            evidence:
+              `the wagon declares it ${kind === "produce" ? "produces" : "consumes"} ` +
+              `"${name}", and no wagon implementation names it; the declared contract and ` +
+              `the Cargo it actually moves are free to disagree`,
+            source_line: "",
+          });
+        }
+      }
+    }
+  }
+}
+writeFileSync(reportPath, JSON.stringify({ violations }, null, 2), "utf8");
+process.stderr.write(`bun-infra[wagon-contract]: ${violations.length} violation(s)\n`);
+process.exit(0);

package/detectors/bun_interlocking_infrastructure/detect.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+// FAMILY validator: bun_interlocking_infrastructure
+// Runs each member check (checks/*.mjs) VERBATIM as a subprocess and merges their
+// RAW v1.1 reports into one — ONE implementation realizing a family of rule_ids
+// (the Core pattern; see frontend.workspace.runtime's families).
+//
+// Members are spawned with `process.execPath`, which under this provider IS the
+// bun binary, so a member may be authored as .mjs OR .ts with no build step.
+// Files whose name begins with `_` are skipped: they are shared helpers, not
+// checks. (The node-runtime families have no such convention because each of
+// their checks re-implements its own walker; this provider factors the walk into
+// lib/scan.mjs instead.)
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync, mkdtempSync, readdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const reportPath = process.env.ATDD_VIOLATIONS_REPORT;
+if (!reportPath) {
+  process.stderr.write("family: ATDD_VIOLATIONS_REPORT not set\n");
+  process.exit(2);
+}
+const checks = readdirSync(join(here, "checks"))
+  .filter((f) => (f.endsWith(".mjs") || f.endsWith(".ts")) && !f.startsWith("_"))
+  .sort();
+const td = mkdtempSync(join(tmpdir(), "atdd-bun-il-"));
+const out = [];
+for (const c of checks) {
+  const rep = join(td, c + ".json");
+  try {
+    execFileSync(process.execPath, [join(here, "checks", c)], {
+      env: { ...process.env, ATDD_VIOLATIONS_REPORT: rep },
+      stdio: ["ignore", "ignore", "inherit"],
+    });
+  } catch {
+    /* a member may exit non-zero; still try to read its report */
+  }
+  try {
+    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
+  } catch {}
+}
+writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
+process.stderr.write("family bun_interlocking_infrastructure: " + out.length + " violation(s)\n");
+process.exit(0);