@afokapu/atdd-bun 0.10.54 → 0.10.55

package/detectors/bun_interlocking_binding/checks/interlocking_runtime_executes.mjs

@@ -29,6 +29,7 @@ export const RULE_EXECUTES = "coder.bun.runtime-executes-the-declaration";
 const LOADS_DECLARATION =
   /\breadFileSync\s*\(|\breadFile\s*\(|\bBun\s*\.\s*file\s*\(|\bcreateReadStream\s*\(|\bfs\s*\.\s*promises\s*\.\s*readFile\b/;
 const RESOLVES = /\bInterlockingResolution\b|\bresolveTrain\s*\(/;
+const TRAIN_RUNNER = /\bclass\s+TrainRunner\b/;
 const EXCLUDES = ["node_modules", "dist", "build", ".next", "_generated"];
 const PLAN_ROOT = process.env.ATDD_PLAN_ROOT || "plan";
 
@@ -159,10 +160,54 @@ export function scanExecution(scanRoot) {
   return violations;
 }
 
+// TrainRunner is the other half of declaration execution. A correctly data-driven
+// InterlockingRunner can select a train while its executor silently ignores that
+// train and returns a hand-written trace. Require the executor itself to read a
+// supplied train declaration, iterate its declared sequence, and feed each wagon's
+// production result into the next call. These deliberately structural checks admit
+// ordinary direct functions (executeWagon/runWagon/runTrain) without prescribing a
+// framework, while rejecting the no-op and literal-trace shapes they replace.
+export function scanTrainRunnerExecution(scanRoot) {
+  const violations = [];
+  for (const croot of findConsumerRoots(scanRoot)) {
+    const trainDeclarations = walk(join(croot, PLAN_ROOT, "_trains"), (f) => /train:.*\.ya?ml$/.test(f));
+    if (!trainDeclarations.length) continue;
+    const rtFiles = walk(join(croot, "src/trains"), (f) => /\.(ts|tsx|mjs|js)$/.test(f))
+      .map((f) => ({ file: f, text: readText(f) }));
+    for (const runner of rtFiles.filter((x) => TRAIN_RUNNER.test(x.text))) {
+      const readsDeclaration = LOADS_DECLARATION.test(runner.text);
+      const usesSuppliedDeclaration = /\b(?:parse|load)(?:Train|Declaration)\s*\(\s*this\.\w*(?:train|declaration|path)\w*\s*\)/i.test(runner.text) ||
+        /\b(?:readFileSync|readFile|Bun\s*\.\s*file)\s*\(\s*this\.\w*(?:train|declaration|path)\w*/i.test(runner.text);
+      const parsesSequence = /\bsequence\b/.test(runner.text);
+      const derivesOrder = /for\s*\(\s*const\s+\w+\s+of\s+\w+\.sequence\s*\)/.test(runner.text);
+      // The reassignment is the key data-flow proof: a production execution call
+      // receives the prior result and its output becomes the next result.
+      const carriesResults = /\b(\w+)\s*=\s*(?:await\s+)?(?:execute|run)\w*\s*\(\s*\w+\s*,\s*\1\s*\)/.test(runner.text);
+      const fabricatesTrace = /\b(?:trace|steps?|sequence)\s*:\s*\[\s*["'`]/.test(maskComments(runner.text));
+      if (readsDeclaration && usesSuppliedDeclaration && parsesSequence && derivesOrder && carriesResults && !fabricatesTrace) continue;
+      const missing = [
+        !readsDeclaration && "read the supplied train declaration",
+        !usesSuppliedDeclaration && "pass its supplied declaration into that parser or reader",
+        !parsesSequence && "parse its sequence",
+        !derivesOrder && "derive ordered iteration from train.sequence",
+        !carriesResults && "carry each production execution result into the next wagon",
+        fabricatesTrace && "avoid fabricating literal trace or step data",
+      ].filter(Boolean).join("; ");
+      const rel = runner.file.startsWith(croot + sep) ? runner.file.slice(croot.length + 1) : runner.file;
+      violations.push({
+        rule_id: RULE_EXECUTES, file: rel, line: 1, col: 0,
+        evidence: `TrainRunner must ${missing}; declaration-selected wagon execution cannot be satisfied by a no-op or transcribed trace`,
+        source_line: "",
+      });
+    }
+  }
+  return violations;
+}
+
 if (import.meta.main ?? process.argv[1]?.endsWith("interlocking_runtime_executes.mjs")) {
   let roots = [];
   try { roots = JSON.parse(process.env.ATDD_SCAN_ROOTS || "[]"); } catch {}
-  const out = roots.flatMap((r) => scanExecution(r));
+  const out = roots.flatMap((r) => [...scanExecution(r), ...scanTrainRunnerExecution(r)]);
   const rp = process.env.ATDD_VIOLATIONS_REPORT;
   if (rp) writeFileSync(rp, JSON.stringify({ violations: out }, null, 2), "utf8");
   process.stderr.write(`bun-executes: ${out.length} violation(s)\n`);

package/detectors/bun_interlocking_binding/detect.mjs

@@ -24,7 +24,7 @@
 import { excludedPath } from "../../lib/scan.mjs";
 import { parseInterlocking as parseInterlockingDoc } from "../../lib/interlocking.mjs";
 import { readFileSync, writeFileSync, statSync, readdirSync } from "node:fs";
-import { scanExecution } from "./checks/interlocking_runtime_executes.mjs";
+import { scanExecution, scanTrainRunnerExecution } from "./checks/interlocking_runtime_executes.mjs";
 import { join, sep, resolve } from "node:path";
 
 const RULE = "coder.bun.interlocking-bilateral-binding";
@@ -544,7 +544,7 @@ function main() {
     // coder.bun.runtime-executes-the-declaration — no longer staged. This family is
     // monolithic rather than checks/-collecting, so it is called here rather than
     // discovered.
-    violations.push(...scanExecution(scanRoot));
+    violations.push(...scanExecution(scanRoot), ...scanTrainRunnerExecution(scanRoot));
   }
   writeFileSync(reportPath, JSON.stringify({ violations }, null, 2), "utf8");
   process.stderr.write(`bun-interlocking-binding: ${violations.length} violation(s)\n`);

package/detectors/bun_interlocking_binding/fixtures/clean/server.ts

@@ -12,8 +12,8 @@ export const JOURNEY_MAP = {
 
 export function dispatch(action: string, inputs: Record<string, unknown>) {
   const mapping = (JOURNEY_MAP as Record<string, unknown>)[action];
-  if (typeof mapping === "string") return new TrainRunner(mapping).execute(inputs);
+  if (typeof mapping === "string") return new TrainRunner(`plan/_trains/${mapping}.yaml`, mapping).execute(inputs);
   const { path } = mapping as { interlockingId: string; path: string };
   const res = new InterlockingRunner(path).resolveTrain(action, inputs);
-  return new TrainRunner(res.trainId).execute(inputs);
+  return new TrainRunner(res.trainPath, res.trainId).execute(inputs);
 }

package/detectors/bun_interlocking_binding/fixtures/clean/src/trains/runner.ts

@@ -1,7 +1,25 @@
-// TrainRunner — the production linear executor the InterlockingRunner delegates to.
+// TrainRunner — reads the selected train declaration and executes its declared wagons in order.
+import { readFileSync } from "node:fs";
+
+type Result = Record<string, unknown>;
+
+function parseTrain(path: string): { sequence: string[] } {
+  const text = readFileSync(path, "utf8");
+  return { sequence: [...text.matchAll(/^\s*-\s*([^#\s]+)\s*$/gm)].map((match) => match[1]) };
+}
+
+function executeWagon(wagon: string, result: Result): Result {
+  return { ...result, [wagon]: "executed" };
+}
+
 export class TrainRunner {
-  constructor(private readonly trainId: string) {}
+  constructor(private readonly trainDeclarationPath: string, private readonly trainId?: string) {}
   execute(inputs: Record<string, unknown>) {
-    return { selectedTrainId: this.trainId, inputs };
+    const train = parseTrain(this.trainDeclarationPath);
+    let result: Result = inputs;
+    for (const wagon of train.sequence) {
+      result = executeWagon(wagon, result);
+    }
+    return { selectedTrainId: this.trainId, result };
   }
 }

package/detectors/bun_interlocking_binding/fixtures/clean_flow_style_actions/server.ts

@@ -12,8 +12,8 @@ export const JOURNEY_MAP = {
 
 export function dispatch(action: string, inputs: Record<string, unknown>) {
   const mapping = (JOURNEY_MAP as Record<string, unknown>)[action];
-  if (typeof mapping === "string") return new TrainRunner(mapping).execute(inputs);
+  if (typeof mapping === "string") return new TrainRunner(`plan/_trains/${mapping}.yaml`, mapping).execute(inputs);
   const { path } = mapping as { interlockingId: string; path: string };
   const res = new InterlockingRunner(path).resolveTrain(action, inputs);
-  return new TrainRunner(res.trainId).execute(inputs);
+  return new TrainRunner(res.trainPath, res.trainId).execute(inputs);
 }

package/detectors/bun_interlocking_binding/fixtures/clean_flow_style_actions/src/trains/runner.ts

@@ -1,7 +1,25 @@
-// TrainRunner — the production linear executor the InterlockingRunner delegates to.
+// TrainRunner — reads the selected train declaration and executes its declared wagons in order.
+import { readFileSync } from "node:fs";
+
+type Result = Record<string, unknown>;
+
+function parseTrain(path: string): { sequence: string[] } {
+  const text = readFileSync(path, "utf8");
+  return { sequence: [...text.matchAll(/^\s*-\s*([^#\s]+)\s*$/gm)].map((match) => match[1]) };
+}
+
+function executeWagon(wagon: string, result: Result): Result {
+  return { ...result, [wagon]: "executed" };
+}
+
 export class TrainRunner {
-  constructor(private readonly trainId: string) {}
+  constructor(private readonly trainDeclarationPath: string, private readonly trainId?: string) {}
   execute(inputs: Record<string, unknown>) {
-    return { selectedTrainId: this.trainId, inputs };
+    const train = parseTrain(this.trainDeclarationPath);
+    let result: Result = inputs;
+    for (const wagon of train.sequence) {
+      result = executeWagon(wagon, result);
+    }
+    return { selectedTrainId: this.trainId, result };
   }
 }

package/detectors/bun_interlocking_coverage/_shared/interlocking.mjs

@@ -7,8 +7,8 @@
 // data (snake_case, plan/_trains/_interlockings/**); the e2e tests are Bun/TS under e2e/**.
 
 import { excludedPath } from "../../../lib/scan.mjs";
-import { readFileSync, statSync, readdirSync, writeFileSync } from "node:fs";
-import { join, sep } from "node:path";
+import { existsSync, readFileSync, statSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
 
 export const DEFAULT_EXCLUDES = ["_generated", "node_modules", "dist", "build", ".next"];
 export const PLAN_ROOT = process.env.ATDD_PLAN_ROOT || "plan";
@@ -315,6 +315,136 @@ export function isInterlockingTest(text, tokens) {
   return tokens.some((t) => tokenCovered(t, text));
 }
 
+// Semantic witnesses for the production call model.  Tokens get us to a candidate test; these
+// small, deliberately conservative recognisers decide whether the candidate actually connects
+// `InterlockingRunner.resolveTrain()` to `TrainRunner.execute()` and asserts evidence from that
+// chain.  We keep this in the shared layer so route, runner, trace, smoke, and sequence checks
+// cannot quietly drift back to accepting a different descriptive proxy.
+const ident = "[A-Za-z_$][\\w$]*";
+
+function escaped(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function productionReceivers(text) {
+  const out = new Set();
+  const allocated = new RegExp(`\\b(?:const|let|var)\\s+(${ident})\\s*=\\s*new\\s+${PROD_INTERLOCKING}\\b`, "g");
+  for (const m of text.matchAll(allocated)) out.add(m[1]);
+  const factories = new RegExp(`\\bfunction\\s+(${ident})\\s*\\([^)]*\\)\\s*\\{[\\s\\S]{0,600}?\\breturn\\s+new\\s+${PROD_INTERLOCKING}\\b`, "g");
+  for (const m of text.matchAll(factories)) out.add(`${m[1]}()`);
+  return out;
+}
+
+// [{ resolution, execution }] means an actual resolution value feeds actual train execution.
+// `execution` is null for an unassigned execute result; route/runner proof may assert resolution,
+// while trace and sequence proof require the named execution result.
+export function hasResolvedProductionRunnerImports(text, file, croot) {
+  const imported = new Set();
+  const re = /^\s*import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/gm;
+  for (const match of text.matchAll(re)) {
+    if (!match[2].startsWith(".")) continue;
+    const names = match[1].split(",").map(name => name.trim().split(/\s+as\s+/)[0]);
+    const target = resolve(dirname(file), match[2]);
+    const candidates = [target, `${target}.ts`, `${target}.tsx`, `${target}.js`, `${target}.mjs`, join(target, "index.ts")];
+    const source = candidates.find(candidate => existsSync(candidate) && candidate.startsWith(resolve(croot) + sep) && !/\.(test|spec)\.[cm]?[jt]sx?$/.test(candidate));
+    if (!source) continue;
+    for (const name of names) if (name === PROD_INTERLOCKING || name === PROD_TRAIN) imported.add(name);
+  }
+  return imported.has(PROD_INTERLOCKING) && imported.has(PROD_TRAIN);
+}
+
+export function productionExecutionProofs(text, file, croot) {
+  if (file && croot && !hasResolvedProductionRunnerImports(text, file, croot)) return [];
+  const receivers = productionReceivers(text);
+  const proofs = [];
+  const resolutions = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*([^\\n]{0,240}?)\\.resolveTrain\\s*\\(`, "g");
+  for (const m of text.matchAll(resolutions)) {
+    const [whole, resolution, receiver] = m;
+    const direct = new RegExp(`new\\s+${PROD_INTERLOCKING}\\b`).test(receiver);
+    const named = [...receivers].some((name) => receiver.trim().endsWith(name));
+    if (!direct && !named) continue;
+    const after = text.slice((m.index ?? 0) + whole.length);
+    const execute = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*new\\s+${PROD_TRAIN}\\s*\\(\\s*${escaped(resolution)}\\.(?:trainId|selectedTrainId)\\s*\\)\\s*\\.execute\\s*\\(`).exec(after);
+    const anonymous = new RegExp(`new\\s+${PROD_TRAIN}\\s*\\(\\s*${escaped(resolution)}\\.(?:trainId|selectedTrainId)\\s*\\)\\s*\\.execute\\s*\\(`).test(after);
+    if (execute || anonymous) proofs.push({ resolution, execution: execute?.[1] ?? null });
+  }
+  return proofs;
+}
+
+export function assertsExpression(text, expression, expected = null) {
+  const pat = new RegExp(`\\bexpect\\s*\\(\\s*(?:await\\s+)?${expression}\\s*\\)\\s*\\.(?:to(?:Be|BeDefined|Equal|StrictEqual|Contain|ContainEqual|Match|BeTruthy)|not\\.to(?:Be|BeDefined|Equal|StrictEqual|Contain|ContainEqual|Match))\\b([\\s\\S]{0,220})`);
+  const m = pat.exec(text);
+  return Boolean(m && (!expected || tokenCovered(expected, m[0])));
+}
+
+export function hasProductionExecutionProof(text, file, croot) {
+  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
+    if (assertsExpression(text, `${escaped(resolution)}\\.(?:routeId|trainId|selectedTrainId)`) ||
+      (execution && assertsExpression(text, escaped(execution)))) return true;
+    if (!execution) return false;
+    const trace = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*(?:await\\s+)?${escaped(execution)}\\.trace\\b`).exec(text)?.[1];
+    return Boolean(trace && REQUIRED_TRACE_FIELDS.some(([field]) => assertsExpression(text, `${escaped(trace)}\\.${field}`)));
+  });
+}
+
+export function routeHasProductionProof(route, text, interlockingId = null, file, croot) {
+  const slug = interlockingId?.replace(/^interlocking:/, "");
+  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
+    const assertedRoute = assertsExpression(text, `${escaped(resolution)}\\.routeId`, route.routeId);
+    const assertedTrain = assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, route.trainId);
+    const scoped = !interlockingId || tokenCovered(interlockingId, text) || tokenCovered(slug, text);
+    return (assertedRoute && scoped) || assertedTrain || Boolean(scoped && execution && assertsExpression(text, escaped(execution)) && (tokenCovered(route.routeId, text) || tokenCovered(route.trainId, text)));
+  });
+}
+
+export function traceHasProductionProvenance(text, file, croot) {
+  return productionExecutionProofs(text, file, croot).some(({ execution }) => {
+    if (!execution) return false;
+    const trace = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*(?:await\\s+)?${escaped(execution)}\\.trace\\b`).exec(text)?.[1];
+    return Boolean(trace);
+  });
+}
+
+export function assertedTraceFields(text, traceName = "trace") {
+  return REQUIRED_TRACE_FIELDS.filter(([field]) => !assertsExpression(text, `${escaped(traceName)}\\.${field}`)).map(([field]) => field);
+}
+
+// A smoke path has a real Station Master call and observes that call's returned value; separately
+// requiring both production runner instances rules out imports used only as lexical decoration.
+export function stationMasterExecutionProof(text, action) {
+  const call = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*(?:await\\s+)?${ident}\\.(?:handleAction|dispatch|executeAction)\\s*\\(\\s*["']${escaped(action)}["']`).exec(text);
+  if (!call) return false;
+  const result = call[1];
+  const instanceProof = new RegExp(`\\bexpect\\s*\\(\\s*${ident}\\.(?:interlockingRunner|trainRunner)\\s*\\)\\s*\\.toBeInstanceOf\\s*\\(\\s*(?:${PROD_INTERLOCKING}|${PROD_TRAIN})\\s*\\)`, "g");
+  const seen = new Set([...text.matchAll(instanceProof)].map((m) => m[0].includes(PROD_INTERLOCKING) ? PROD_INTERLOCKING : PROD_TRAIN));
+  return seen.has(PROD_INTERLOCKING) && seen.has(PROD_TRAIN) && assertsExpression(text, `${escaped(result)}(?:\\.[A-Za-z_$][\\w$]*)?`);
+}
+
+// HTTP/module entrypoints do not expose a StationMaster instance to the test. Their equivalent
+// witness is an asserted dispatch result plus a module body that resolves and executes the selected
+// train; this keeps an end-to-end smoke from having to pierce the public boundary for private fields.
+export function stationModuleExecutionProof(text, stationText) {
+  if (!stationText || !new RegExp(`new\\s+${PROD_INTERLOCKING}\\b`).test(stationText) ||
+    !/\.resolveTrain\s*\(/.test(stationText) || !new RegExp(`new\\s+${PROD_TRAIN}\\b`).test(stationText) ||
+    !/\.execute\s*\(/.test(stationText)) return false;
+  const call = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*await\\s+(?:${ident}\\.)?(?:dispatch|handleAction|executeAction)\\s*\\(`).exec(text);
+  return Boolean(call && assertsExpression(text, escaped(call[1])));
+}
+
+// Bun's native `expect` vocabulary provides a compact mutation witness: exact ordered equality
+// kills reorder/removal mutants, objectContaining records a handoff edge, and at(-1) observes the
+// final wagon.  All three must be about the TrainRunner result, never a hand-built literal.
+export function hasSequenceMutationProof(text, trainId, file, croot) {
+  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
+    if (!execution || !assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, trainId)) return false;
+    const result = escaped(execution);
+    const ordered = new RegExp(`expect\\s*\\(\\s*${result}\\.(?:steps|sequence|wagons)\\s*\\)\\s*\\.to(?:Equal|StrictEqual)\\s*\\(\\s*\\[`, "s").test(text);
+    const handoff = new RegExp(`expect\\s*\\(\\s*${result}\\.(?:steps|sequence|wagons)\\s*\\)\\s*\\.toContainEqual\\s*\\(\\s*expect\\.objectContaining\\s*\\(\\s*\\{[\\s\\S]{0,240}?(?:from|to)\\s*:`, "s").test(text);
+    const finalWagon = new RegExp(`expect\\s*\\(\\s*${result}\\.(?:steps|sequence|wagons)\\s*\\.at\\(\\s*-1\\s*\\)\\s*\\)\\s*\\.to(?:Be|Equal|StrictEqual|Match)`, "s").test(text);
+    return ordered && handoff && finalWagon;
+  });
+}
+
 export function writeReport(violations) {
   const rp = process.env.ATDD_VIOLATIONS_REPORT;
   if (!rp) {

package/detectors/bun_interlocking_coverage/checks/interlocking_production_runner.mjs

@@ -22,6 +22,9 @@ import {
   PROD_INTERLOCKING,
   PROD_TRAIN,
   FORBIDDEN_PATTERNS,
+  hasProductionExecutionProof,
+  stationMasterExecutionProof,
+  stationModuleExecutionProof,
   rel,
   mk,
   writeReport,
@@ -67,16 +70,18 @@ for (const scanRoot of roots) {
         }
       }
 
-      const missing = drivesStationMaster(text) ? [] : [PROD_INTERLOCKING, PROD_TRAIN].filter((sym) => !tokenCovered(sym, text));
-      if (missing.length) {
+      const semantic = hasProductionExecutionProof(text, file, croot) ||
+        records.some((rec) => rec.actions.some((action) => stationMasterExecutionProof(text, action))) ||
+        (drivesStationMaster(text) && stationModuleExecutionProof(text, station));
+      if (!semantic) {
         violations.push(
           mk(
             RULE,
             r,
             1,
             0,
-            `interlocking test "${r}" does not reference the production runner(s) ${missing.join(", ")}; ` +
-              `it must exercise the real InterlockingRunner -> TrainRunner path (core afokapu/atdd#1251)`,
+            `interlocking test "${r}" has no asserted result flowing from production InterlockingRunner ` +
+              `resolution into TrainRunner execution; imports and route/train literals are discovery only`,
             "",
           ),
         );

package/detectors/bun_interlocking_coverage/checks/interlocking_route_coverage.mjs

@@ -13,7 +13,7 @@ import {
   interlockingFiles,
   e2eFiles,
   parseInterlocking,
-  isRouteCovered,
+  routeHasProductionProof,
   maskComments,
   rel,
   mk,
@@ -30,11 +30,11 @@ for (const scanRoot of roots) {
     const records = interlockingFiles(croot)
       .map((f) => ({ file: f, rec: parseInterlocking(readText(f)) }))
       .filter((x) => x.rec);
-    const e2eTexts = e2eFiles(croot).map((f) => maskComments(readText(f)));
+    const e2eTexts = e2eFiles(croot).map((file) => ({ file, text: maskComments(readText(file)) }));
 
     for (const { file, rec } of records) {
       for (const route of rec.routes) {
-        if (isRouteCovered(route, e2eTexts, rec.interlockingId)) continue;
+        if (e2eTexts.some(({ file, text }) => routeHasProductionProof(route, text, rec.interlockingId, file, croot))) continue;
         if (unbuiltWagons(croot, route.trainId).length) continue;   // pending: a wagon on its train has no source yet
         const cat =
           route.category !== null
@@ -48,7 +48,7 @@ for (const scanRoot of roots) {
             0,
             `admissible route "${route.routeId}" of interlocking "${rec.interlockingId}" (${cat}, ` +
               `resolves to train "${route.trainId}") has no e2e test exercising it; add an e2e/**/*.ts ` +
-              `test that references the routeId or trainId and drives it through InterlockingRunner -> TrainRunner`,
+              `test whose asserted resolution selects this route/train and flows through InterlockingRunner -> TrainRunner`,
             route.sourceLine.trim(),
           ),
         );

package/detectors/bun_interlocking_coverage/checks/interlocking_smoke_coverage.mjs

@@ -20,6 +20,7 @@ import {
   STATION_MASTER,
   PROD_INTERLOCKING,
   PROD_TRAIN,
+  stationMasterExecutionProof,
   rel,
   mk,
   writeReport,
@@ -36,7 +37,7 @@ const SMOKE_PHASE = /^\s*\/\/\s*Phase:\s*SMOKE\b/m;
 function actionSmokeCovered(action, e2eFiles) {
   return e2eFiles.some(
     ({ raw, text: t }) =>
-      SMOKE_PHASE.test(raw) && tokenCovered(action, t) && STATION_MASTER.test(t) && t.includes(PROD_INTERLOCKING) && t.includes(PROD_TRAIN),
+      SMOKE_PHASE.test(raw) && tokenCovered(action, t) && STATION_MASTER.test(t) && t.includes(PROD_INTERLOCKING) && t.includes(PROD_TRAIN) && stationMasterExecutionProof(t, action),
   );
 }
 

package/detectors/bun_interlocking_coverage/checks/interlocking_trace_binds.mjs

@@ -20,6 +20,8 @@ import {
   lineAt,
   TRACE_OBJECT,
   REQUIRED_TRACE_FIELDS,
+  assertedTraceFields,
+  traceHasProductionProvenance,
   rel,
   mk,
   writeReport,
@@ -42,8 +44,9 @@ for (const scanRoot of roots) {
       if (!isInterlockingTest(text, tokens)) continue;
       const m = TRACE_OBJECT.exec(text);
       if (!m) continue; // not a trace-binding test.
-      const missing = REQUIRED_TRACE_FIELDS.filter(([, pat]) => !pat.test(text)).map(([label]) => label);
-      if (!missing.length) continue;
+      const missing = assertedTraceFields(text);
+      const provenance = traceHasProductionProvenance(text, file, croot);
+      if (!missing.length && provenance) continue;
       const line = lineOfIndex(text, m.index);
       violations.push(
         mk(
@@ -51,9 +54,8 @@ for (const scanRoot of roots) {
           rel(file, croot),
           line,
           0,
-          `interlocking trace test "${rel(file, croot)}" does not bind the declared route: missing required ` +
-            `trace field(s) ${missing.join(", ")} (core afokapu/atdd#1251 trace must record interlockingId/` +
-            `routeId/selectedTrainId/routeCategory/routeCategoryDigit/guardId/resolutionStrategy/resolutionReason)`,
+          `interlocking trace test "${rel(file, croot)}" does not bind a production TrainRunner result to the ` +
+            `declared route${missing.length ? `: missing asserted trace field(s) ${missing.join(", ")}` : ""}${!provenance ? "; trace is not derived from InterlockingRunner -> TrainRunner execution" : ""}`,
           lineAt(raw, line),
         ),
       );

package/detectors/bun_interlocking_coverage/checks/interlocking_train_sequence.mjs

@@ -16,22 +16,17 @@
 // suite green. The runtime obeyed the new plan; no test looked.
 import {
   parseJsonEnv, readText, findConsumerRoots, interlockingFiles, e2eFiles,
-  parseInterlocking, tokenCovered, rel, mk, PLAN_ROOT, unbuiltWagons,
+  parseInterlocking, rel, mk, PLAN_ROOT, unbuiltWagons, hasSequenceMutationProof,
 } from "../_shared/interlocking.mjs";
 import { writeFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 export const RULE_SEQUENCE = "tester.bun.interlocking-train-sequence-is-exercised";
 
-// A line that ASSERTS AN ORDER: names the executed sequence AND compares it.
-// Merely touching the word is not asserting the order — `expect(trace.steps)` alone
-// says nothing about what ran, and counting it would repeat the over-broad trigger
-// that has now been fixed three times in this family.
-const SEQUENCE_ASSERTION =
-  /^[^\n]*\b(?:expect|assert)\b[^\n]*\b(?:steps|sequence|wagons)\b[^\n]*(?:==|toEqual|toStrictEqual|deepEqual)/m;
-
 export function assertsASequence(text) {
-  return SEQUENCE_ASSERTION.test(text);
+  // Retained as a narrow API for consumers of this module. The train id is intentionally
+  // unavailable here, so it cannot certify coverage; `trainSequenceCovered` below does.
+  return /\bexpect\s*\(\s*[A-Za-z_$][\w$]*\.(?:steps|sequence|wagons)\s*\)\s*\.to(?:Equal|StrictEqual)\s*\(/.test(text);
 }
 
 export function trainsReachableFromRoutes(records) {
@@ -45,8 +40,8 @@ export function trainsReachableFromRoutes(records) {
   return out;
 }
 
-export function trainSequenceCovered(trainId, texts) {
-  return texts.some((t) => tokenCovered(trainId, t) && assertsASequence(t));
+export function trainSequenceCovered(trainId, files, croot) {
+  return files.some(({ file, text }) => hasSequenceMutationProof(text, trainId, file, croot));
 }
 
 // Does the plan actually DECLARE a wagon sequence for this train?
@@ -85,13 +80,13 @@ export function scanExecution(scanRoot) {
     const records = interlockingFiles(croot).map((f) => parseInterlocking(readText(f))).filter(Boolean);
     if (!records.length) continue;
     const files = e2eFiles(croot).map((f) => ({ file: f, text: readText(f) }));
-    const texts = files.map((x) => x.text);
+
     for (const trainId of [...trainsReachableFromRoutes(records)].sort()) {
       // The finding points at the train's own document, where the sequence a test must assert is declared (FWS #fqUGvWHn25mq).
       const declared = declaresASequence(croot, trainId);
       if (!declared) continue;   // nothing declared to exercise
       if (unbuiltWagons(croot, trainId).length) continue;   // pending: a wagon on it has no source yet
-      if (trainSequenceCovered(trainId, texts)) continue;
+      if (trainSequenceCovered(trainId, files, croot)) continue;
       violations.push(
         mk(RULE_SEQUENCE, rel(declared, croot), 1, 0,
           `declared train "${trainId}" is selected by a route but no test asserts the wagon ` +

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_production_runner/convex/trains/interlocking.ts

@@ -0,0 +1 @@
+export class InterlockingRunner { resolveTrain() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_production_runner/convex/trains/runner.ts

@@ -0,0 +1 @@
+export class TrainRunner { execute() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_route_coverage/convex/trains/interlocking.ts

@@ -0,0 +1 @@
+export class InterlockingRunner { resolveTrain() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_route_coverage/convex/trains/runner.ts

@@ -0,0 +1 @@
+export class TrainRunner { execute() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_smoke_coverage/convex/trains/interlocking.ts

@@ -0,0 +1 @@
+export class InterlockingRunner { resolveTrain() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_smoke_coverage/convex/trains/runner.ts

@@ -0,0 +1 @@
+export class TrainRunner { execute() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_smoke_coverage_module/convex/trains/interlocking.ts

@@ -0,0 +1 @@
+export class InterlockingRunner { resolveTrain() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_smoke_coverage_module/convex/trains/runner.ts

@@ -0,0 +1 @@
+export class TrainRunner { execute() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_trace_binds/convex/trains/interlocking.ts

@@ -0,0 +1 @@
+export class InterlockingRunner { resolveTrain() { return {}; } }

package/detectors/bun_interlocking_coverage/fixtures/clean/interlocking_trace_binds/convex/trains/runner.ts

@@ -0,0 +1 @@
+export class TrainRunner { execute() { return {}; } }

package/detectors/bun_interlocking_infrastructure/checks/interlocking_station_routing.mjs

@@ -19,6 +19,15 @@ import {
 
 const RULE = "coder.bun.station-master-interlocking-routing";
 const roots = parseJsonEnv("ATDD_SCAN_ROOTS", []);
+
+function dispatchDelegatesThroughInterlocking(text) {
+  const match = /\b(?:export\s+)?function\s+dispatch\s*\([^)]*\)\s*\{([\s\S]*)\}\s*$/.exec(text);
+  if (!match) return false;
+  const body = match[1];
+  if (/\breturn\s+new\s+InterlockingRunner\s*\([^)]*\)\s*\.\s*execute\s*\(/.test(body)) return true;
+  const runner = /\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*new\s+InterlockingRunner\s*\(/.exec(body)?.[1];
+  return Boolean(runner && new RegExp(`\\breturn\\s+(?:await\\s+)?${runner}\\s*\\.\\s*execute\\s*\\(`).test(body));
+}
 const violations = [];
 
 for (const scanRoot of roots) {
@@ -56,6 +65,16 @@ for (const scanRoot of roots) {
         ),
       );
     }
+    if (!dispatchDelegatesThroughInterlocking(text)) {
+      violations.push(mk(
+        RULE,
+        rel(app, croot),
+        line,
+        0,
+        "station-master-dispatch-bypasses-runners: mapped interlocking dispatch must return InterlockingRunner execution; inert runner references or direct business data do not execute the selected train",
+        lineAt(text, line),
+      ));
+    }
   }
 }
 

package/detectors/bun_interlocking_infrastructure/checks/journey_runner_boundary.mjs

@@ -56,6 +56,25 @@ function loadsJourneyDeclaration(text) {
   return readsJourneyPath && parsesDeclaration;
 }
 
+function consumesDeclaredTopology(text) {
+  const masked = maskComments(text);
+  const declaration = /\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*Bun\.YAML\.parse\s*\(/.exec(masked);
+  if (!declaration) return false;
+  const name = declaration[1].replace(/[$]/g, "\\$");
+  const reads = (field) => new RegExp("\\b" + name + "\\s*\\.\\s*" + field + "\\s*\\.\\s*find\\s*\\(").test(masked);
+  // A runner must retain the interlocking result long enough to decide whether the
+  // declared route continues or terminates. Returning the first execute() directly
+  // is the characteristic skipped-continuation mutation.
+  const retainsResolution = /\b(?:const|let)\s+[A-Za-z_$][\w$]*\s*=\s*await\s+(?:new\s+InterlockingRunner\s*\([^)]*\)|[A-Za-z_$][\w$]*)\s*\.\s*execute\s*\(/.test(masked);
+  const readsEntrypoint = new RegExp("\\b" + name + "\\s*\\.\\s*entrypoint\\b").test(masked);
+  // Reading both lists is only discovery. A continuation must alter control flow to
+  // another declared interlocking and a terminal must decide the returned outcome;
+  // otherwise an early `return resolution` leaves the journey topology inert.
+  const followsContinuation = /\bif\s*\(\s*continuation\s*\)\s*\{[\s\S]{0,280}?\bcurrent\s*=\s*continuation\s*\.\s*to\s*\.\s*(?:interlocking_id|interlockingId)\b[\s\S]{0,280}?\bcontinue\b/.test(masked);
+  const returnsTerminal = /\bif\s*\(\s*terminal\s*\)\s*(?:\{[\s\S]{0,280}?)?\breturn\b[\s\S]{0,240}?\bterminal\s*\.\s*outcome\b/.test(masked);
+  return readsEntrypoint && reads("continuations") && reads("terminals") && retainsResolution && followsContinuation && returnsTerminal;
+}
+
 function hiddenTopologyLiterals(text) {
   const masked = maskComments(text);
   const hits = [];
@@ -114,6 +133,14 @@ for (const scanRoot of roots) {
         "journey-runtime-transcription: JourneyRunner does not read and parse a journey declaration; topology may be hardcoded",
         lineAt(text, line),
       ));
+      if (loadsDeclaration && !consumesDeclaredTopology(text)) violations.push(mk(
+        RULE,
+        rel(file, croot),
+        line,
+        0,
+        "journey-runtime-continuation-ignored: JourneyRunner reads a continuation-bearing declaration but returns the entrypoint InterlockingRunner result without consuming continuations and terminals",
+        lineAt(text, line),
+      ));
       for (const hit of hardcodedInterlockingConstruction(text)) violations.push(mk(
         RULE,
         rel(file, croot),