@afokapu/atdd-bun 0.10.67 → 0.10.69

package/detectors/atdd_traceability_closure/detect.mjs

@@ -62,7 +62,11 @@ for (const root of roots) {
       // EVERY binding header is judged, not only the first: a valid Acceptance: must not carry an unresolved Train:.
       const headers = [...head.matchAll(/^[ \t]*\/\/[ \t]*(Acceptance|WMBT|Train):[ \t]*(\S*)/gm)].map((m) => ({ kind: m[1], id: m[2], raw: m[0].trim(), line: lineAt(head, m.index) }));
       const bindings = headers.filter((h) => h.id.startsWith(PREFIX[h.kind]));
-      tests.set(urn[1], { path, bindings });
+      // A test identity may be reused by equivalent smoke harnesses. Preserve every
+      // independently declared binding: replacing the earlier record made a valid
+      // acceptance disappear solely because a later file had the same test URN.
+      const prior = tests.get(urn[1]);
+      tests.set(urn[1], { path, bindings: [...(prior?.bindings ?? []), ...bindings] });
       if (!headers.length) add("traceability.test.binding-resolves", path, lineOf(head, urn[0]), "test has a URN but no Acceptance:, WMBT:, or Train: binding", urn[0]);
       for (const h of headers) if (!bindings.includes(h)) add("traceability.test.binding-resolves", path, h.line, `${h.kind}: ${h.id || "<empty>"} is not a ${PREFIX[h.kind]} identity`, h.raw);
       return;

package/detectors/bun_clean_architecture_detector/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
 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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_clean_architecture_detector: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_clean_architecture_detector: " + out.length + " violation(s)\n");

package/detectors/bun_design_system_detector/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
 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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_design_system_detector: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_design_system_detector: " + out.length + " violation(s)\n");

package/detectors/bun_fullstack_detector/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
 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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_fullstack_detector: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_fullstack_detector: " + out.length + " violation(s)\n");

package/detectors/bun_green_traceability_detector/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
 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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_green_traceability_detector: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_green_traceability_detector: " + out.length + " violation(s)\n");

package/detectors/bun_interlocking_coverage/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-ilc-"));
 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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_interlocking_coverage: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_interlocking_coverage: " + out.length + " violation(s)\n");

package/detectors/bun_interlocking_infrastructure/checks/journey_runner_boundary.mjs

@@ -47,25 +47,56 @@ function journeyRunnerLine(text) {
   return match ? lineOfIndex(text, match.index) : 1;
 }
 
+// Declaration helpers that verifiably read AND parse the file named by their own parameter.
+function declarationHelpers(masked) {
+  const names = [];
+  const helper = /\b(?:async\s+)?function\s+((?=[A-Za-z_$\w]*(?:declaration|journey))[A-Za-z_$][\w$]*)\s*\(\s*([A-Za-z_$][\w$]*)?[^)]*\)\s*(?::[^\{]+)?\{([\s\S]*?)\n\}/gi;
+  for (const match of masked.matchAll(helper)) {
+    const [, name, param, body] = match;
+    if (!param || !/\b(?:Bun\.YAML\.parse|JSON\.parse)\s*\(/.test(body)) continue;
+    // The read argument must reference the helper's own parameter, not a fixed path.
+    const paramName = param.replace(/[$]/g, "\\$");
+    if (!new RegExp(`\\b(?:Bun\\.file|readFile(?:Sync)?)\\s*\\(\\s*[^)]*\\b${paramName}\\b`).test(body)) continue;
+    // JourneyRunner must pass its own declared path to that helper.
+    const callee = name.replace(/[$]/g, "\\$");
+    if (new RegExp(`\\b${callee}\\s*\\(\\s*this\\s*\\.\\s*journeyYamlPath\\s*\\)`).test(masked)) names.push(name);
+  }
+  return names;
+}
+
 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;
+  if (readsJourneyPath && parsesDeclaration) return true;
+  // Production runners may centralize parsing and validation in a declaration helper.
+  return declarationHelpers(masked).length > 0;
 }
 
 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, "\\$");
+  // The topology variable must come from the original parse or from the one verified helper
+  // called with this.journeyYamlPath; a topology from any other call is not the declaration.
+  const escape = (value) => value.replace(/[$]/g, "\\$");
+  const sources = ["Bun\\.YAML\\.parse\\s*\\(", ...declarationHelpers(masked).map(helper =>
+    `(?:await\\s+)?${escape(helper)}\\s*\\(\\s*this\\s*\\.\\s*journeyYamlPath\\s*\\)`)];
+  const declarations = [...masked.matchAll(new RegExp("\\b(?:const|let)\\s+([A-Za-z_$][\\w$]*)\\s*=\\s*(?:" + sources.join("|") + ")", "g"))];
+  return declarations.some(declaration => consumesTopologyFrom(masked, declaration[1]));
+}
+
+function consumesTopologyFrom(masked, variable) {
+  const name = variable.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 execution = "await\\s+(?:new\\s+InterlockingRunner\\s*\\([^)]*\\)|[A-Za-z_$][\\w$]*)\\s*\\.\\s*execute\\s*\\(";
+  // The result may also be declared first and assigned once inside a try that has a catch:
+  // `let run: T; try { run = await runner.execute(...) } catch { throw error }`.
+  const retainsResolution = new RegExp("\\b(?:const|let)\\s+[A-Za-z_$][\\w$]*\\s*=\\s*" + execution).test(masked) ||
+    new RegExp("\\blet\\s+([A-Za-z_$][\\w$]*)\\s*(?::[^=;]+)?;\\s*try\\s*\\{\\s*\\1\\s*=\\s*" + execution + "[\\s\\S]{0,400}?\\}\\s*catch\\s*(?:\\([^)]*\\))?\\s*\\{[^}]*\\b(?:throw|return)\\b").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;

package/detectors/bun_interlocking_infrastructure/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_interlocking_infrastructure: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_interlocking_infrastructure: " + out.length + " violation(s)\n");

package/detectors/bun_responsive_detector/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
 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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_responsive_detector: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_responsive_detector: " + out.length + " violation(s)\n");

package/detectors/bun_security_hygiene_detector/detect.mjs

@@ -11,7 +11,7 @@
 // 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 { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,19 +27,36 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
 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 */
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      failures.push(`member ${c} failed to run: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-  } catch {}
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_security_hygiene_detector: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_security_hygiene_detector: " + out.length + " violation(s)\n");

package/detectors/bun_telemetry_code/detect.mjs

@@ -4,7 +4,7 @@
 // RAW v1.1 reports into one — one implementation realizing a family of rule_ids.
 // Files whose name begins with `_` are skipped: they are shared helpers.
 import { execFileSync } from "node:child_process";
-import { readFileSync, writeFileSync, mkdtempSync, readdirSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -20,31 +20,41 @@ const checks = readdirSync(join(here, "checks"))
   .sort();
 const td = mkdtempSync(join(tmpdir(), "atdd-bun-fam-"));
 const out = [];
-let crashed = false;
-for (const c of checks) {
-  const rep = join(td, c + ".json");
-  let exitedCleanly = true;
-  try {
-    execFileSync(process.execPath, [join(here, "checks", c)], {
-      env: { ...process.env, ATDD_VIOLATIONS_REPORT: rep },
-      stdio: ["ignore", "ignore", "inherit"],
-    });
-  } catch {
-    exitedCleanly = false; /* a member may exit non-zero after writing its report */
-  }
-  let read = false;
-  try {
-    out.push(...JSON.parse(readFileSync(rep, "utf8")).violations);
-    read = true;
-  } catch {}
-  // A member that crashed WITHOUT a report is a detector bug, and swallowing it here is a silent
-  // pass — the exact failure that once hid a broken regex behind zero findings. Fail loudly.
-  if (!exitedCleanly && !read) {
-    process.stderr.write(`family bun_telemetry_code: member ${c} crashed without a violation report\n`);
-    crashed = true;
+// FAIL CLOSED. A member that cannot run (crash, non-zero exit) or leaves no usable report is a detector
+// failure, never "zero findings": in a ratchet a silent zero on the candidate side reads as resolved debt and
+// masks genuinely new findings. A member that ran and found nothing writes {"violations": []} and passes.
+const failures = [];
+try {
+  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 (error) {
+      const why = error instanceof Error ? error.message.split("\n")[0] : String(error);
+      // Keep the established wording for the crash-without-a-report case (tests/telemetry-review.test.ts #6).
+      let reported = true;
+      try { readFileSync(rep, "utf8"); } catch { reported = false; }
+      failures.push(reported ? `member ${c} failed to run: ${why}` : `member ${c} crashed without a violation report: ${why}`);
+      continue;
+    }
+    try {
+      const report = JSON.parse(readFileSync(rep, "utf8"));
+      if (!report || !Array.isArray(report.violations)) throw new Error("report has no violations array");
+      out.push(...report.violations);
+    } catch (error) {
+      failures.push(`member ${c} left no usable violation report: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
+} finally {
+  rmSync(td, { recursive: true, force: true });
+}
+if (failures.length) {
+  for (const failure of failures) process.stderr.write("family bun_telemetry_code: " + failure + "\n");
+  process.exit(2); // the run failed: the caller must report a failure, not a verdict
 }
-if (crashed) process.exit(2); // a crashed member is a detector bug: fail loudly, not silently
 writeFileSync(reportPath, JSON.stringify({ violations: out }, null, 2), "utf8");
 process.stderr.write("family bun_telemetry_code: " + out.length + " violation(s)\n");
 process.exit(0);