@afokapu/atdd-bun 0.6.2 → 0.7.0

package/detectors/bun_telemetry_code/fixtures/dirty/telemetry/commons/response-invocation-accepted/event.be.json

@@ -0,0 +1,16 @@
+{
+  "id": "telemetry:event:be:commons:response-invocation-accepted",
+  "version": "1.0.0",
+  "logical_artifact": "telemetry:commons:response-invocation-accepted",
+  "kind": "event",
+  "plane": "be",
+  "owner": "commons",
+  "purpose": "Records that a response invocation passed acceptance so ingress health can be audited.",
+  "acceptances": ["acc:commons:E001-UNIT-001"],
+  "properties": {
+    "response_id": { "type": "string", "classification": "internal", "cardinality": "high" },
+    "outcome": { "type": "string", "allowed_values": ["accepted"] }
+  },
+  "required": ["response_id", "outcome"],
+  "forbidden_properties": ["raw_payload", "secret", "prompt"]
+}

package/detectors/bun_telemetry_code/fixtures/dirty/tests/wagons/commons/features/ingress/unit/probe.test.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "bun:test";
+
+test("a test file may reference undeclared names without tripping the coder rules", () => {
+  const sink = { emit: (_id: string) => {} };
+  sink.emit("fixture_undeclared_event");
+  expect(sink).toBeDefined();
+});

package/detectors/bun_telemetry_code/registry.mjs

@@ -0,0 +1,34 @@
+// registry.mjs — the tracking-plan registry as the code-side checks see it.
+//
+// Shared by every member check so all four judge the SAME registry: the concrete
+// item ids declared under the telemetry root, and each item's forbidden-property
+// list (normalized, so a plan's raw_payload meets code's rawPayload). Loaded once
+// per detector run from the package's own loader, which also carries the adoption
+// gate: until the repository adopts the capability, every check emits nothing.
+import { loadTelemetryFiles, CONCRETE_URN } from "../../src/telemetry-plan.ts";
+
+/** Property names cross vocabulary boundaries: the plan writes snake_case, code writes camelCase. */
+export const normalizeName = (name) => name.replace(/[_-]/g, "").toLowerCase();
+
+let cache = null;
+export async function registry() {
+  if (cache) return cache;
+  const roots = JSON.parse(process.env.ATDD_SCAN_ROOTS ?? "[]");
+  const loaded = await Promise.all(roots.map((root) => loadTelemetryFiles(root)));
+  const ids = new Set();
+  const forbidden = new Map();
+  const itemFileById = new Map();
+  for (const { files } of loaded) {
+    for (const file of files) {
+      if (!file.data) continue;
+      const id = typeof file.data.id === "string" ? file.data.id : "";
+      if (!id) continue;
+      ids.add(id);
+      itemFileById.set(id, file.file);
+      const names = Array.isArray(file.data.forbidden_properties) ? file.data.forbidden_properties.filter((name) => typeof name === "string") : [];
+      forbidden.set(id, new Set(names.map(normalizeName)));
+    }
+  }
+  cache = { adopted: loaded.some((result) => result.adopted), ids, forbidden, requiredIds: new Set(loaded.flatMap((result) => [...result.requiredIds])), itemFileById, concreteUrn: CONCRETE_URN };
+  return cache;
+}

package/detectors/bun_telemetry_test/_shared.mjs

@@ -0,0 +1,92 @@
+// _shared.mjs — registry view, test-file walking and header parsing for the
+// telemetry test family. Never spawned as a check (the runner skips _-prefixed
+// files in checks/; this lives at the implementation root).
+//
+// A TELEMETRY TEST is a test file identified by a `// Telemetry:` header, by a URN
+// kind segment (-TELEMETRY- / -EVENT- / -METRIC-), or by *.telemetry.test.*
+// colocation — the same identification tester.bun.telemetry-emit uses, plus the
+// binding header this profile adds.
+import { readFileSync, statSync, readdirSync } from "node:fs";
+import { join, extname, sep } from "node:path";
+import { loadTelemetryFiles, CONCRETE_URN } from "../../src/telemetry-plan.ts";
+
+const TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+
+function isExcluded(path, excludes) {
+  const segs = path.split(sep);
+  return excludes.some((ex) => segs.includes(ex) || path.includes(ex));
+}
+
+export function* walkTests(root, excludes) {
+  let st;
+  try { st = statSync(root); } catch { return; }
+  if (st.isFile()) { if (TEST_RE.test(root)) yield root; return; }
+  let names;
+  try { names = readdirSync(root); } catch { return; }
+  for (const name of names) {
+    const full = join(root, name);
+    if (isExcluded(full, excludes)) continue;
+    let cst;
+    try { cst = statSync(full); } catch { continue; }
+    if (cst.isDirectory()) yield* walkTests(full, excludes);
+    else if (TEST_RE.test(full)) yield full;
+  }
+}
+
+const STRING_ON_LINE = /(["'`])(?:\\.|(?!\1)[^\n\\])*\1/g;
+const TELEMETRY_HEADER = /^[ \t]*\/\/[ \t]*Telemetry:[ \t]*(\S+)[ \t]*$/;
+const URN_HEADER = /^[ \t]*\/\/[ \t]*URN:[ \t]*(\S+)[ \t]*$/;
+const ACCEPTANCE_HEADER = /^[ \t]*\/\/[ \t]*Acceptance:[ \t]*(\S+)[ \t]*$/;
+
+/** The header facts a telemetry test is judged on: its URN, EVERY acceptance binding (a spec
+ * file legitimately covers many acceptances — the two-level @covers model), and every Telemetry:
+ * reference (with line numbers, judged one per line). String literals are stripped first: a
+ * header inside a string is not a header. */
+export function parseTestHeader(text) {
+  const lines = text.split("\n");
+  const header = { urn: null, acceptances: [], telemetry: [] };
+  for (let no = 0; no < lines.length; no++) {
+    const line = lines[no].replace(STRING_ON_LINE, '""');
+    const asTelemetry = TELEMETRY_HEADER.exec(line);
+    if (asTelemetry) { header.telemetry.push({ no: no + 1, value: asTelemetry[1], raw: lines[no].trim() }); continue; }
+    if (!header.urn) { const m = URN_HEADER.exec(line); if (m) { header.urn = { no: no + 1, value: m[1], raw: lines[no].trim() }; continue; } }
+    const asAcceptance = ACCEPTANCE_HEADER.exec(line);
+    if (asAcceptance) header.acceptances.push({ no: no + 1, value: asAcceptance[1], raw: lines[no].trim() });
+  }
+  return header;
+}
+
+const IS_TELEMETRY_URN = /-(?:TELEMETRY|EVENT|METRIC)-\d+/i;
+
+/** Is this test file a telemetry test? */
+export function isTelemetryTest(file, header) {
+  if (header.telemetry.length) return true;
+  if (/\.telemetry\.(?:test|spec)\.[cm]?[jt]sx?$/.test(file)) return true;
+  return Boolean(header.urn && IS_TELEMETRY_URN.test(header.urn.value));
+}
+
+export function readText(file) {
+  try { return readFileSync(file, "utf8"); } catch { return null; }
+}
+
+let cache = null;
+export async function registry() {
+  if (cache) return cache;
+  const roots = JSON.parse(process.env.ATDD_SCAN_ROOTS ?? "[]");
+  const loaded = await Promise.all(roots.map((root) => loadTelemetryFiles(root)));
+  const ids = new Set(), itemFileById = new Map(), timingById = new Map();
+  const requiredIds = new Set(), decisions = new Map();
+  for (const result of loaded) {
+    for (const id of result.requiredIds) requiredIds.add(id);
+    for (const [id, decision] of result.decisions) decisions.set(id, decision);
+    for (const file of result.files) {
+      if (!file.data || typeof file.data.id !== "string" || !file.data.id) continue;
+      ids.add(file.data.id);
+      itemFileById.set(file.data.id, file.file);
+      timingById.set(file.data.id, Array.isArray(file.data.timing) ? file.data.timing.filter((t) => typeof t === "string") : []);
+    }
+  }
+  cache = { adopted: loaded.some((result) => result.adopted), ids, itemFileById, timingById, requiredIds, decisions, concreteUrn: CONCRETE_URN };
+  return cache;
+}

package/detectors/bun_telemetry_test/atdd.implementation.yaml

@@ -0,0 +1,24 @@
+schema_version: "1.0.0"
+kind: implementation
+subtype: validator
+implementation_id: tester.telemetry.impl
+targets_workspace: atdd.workspace.bun
+contract_version: "1.0.0"
+# The test-side half of the telemetry profile: telemetry tests bind the acceptance
+# AND the telemetry item they prove, assert the exact identity on a captured sink,
+# every required item has at least one telemetry test, and declared timing
+# semantics are exercised. Inert until the repository adopts the capability.
+emits_rule_ids:
+  - tester.bun.telemetry-test-binding
+  - tester.bun.telemetry-captured-sink
+  - tester.bun.telemetry-identity-assertion
+  - tester.bun.telemetry-required-item-coverage
+  - tester.bun.telemetry-timing-semantics
+realizes_convention:
+  - tester.bun.telemetry-test-binding
+  - tester.bun.telemetry-captured-sink
+  - tester.bun.telemetry-identity-assertion
+  - tester.bun.telemetry-required-item-coverage
+  - tester.bun.telemetry-timing-semantics
+entrypoint: detect.mjs
+report: detect.mjs

package/detectors/bun_telemetry_test/checks/t_captured_sink.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.telemetry-captured-sink  (telemetry test family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW violations
+// to ATDD_VIOLATIONS_REPORT, exits 0 regardless of count.
+import { readRoots, parseJsonEnv, emit } from "../../../lib/scan.mjs";
+import { registry, walkTests, parseTestHeader, isTelemetryTest, readText } from "../_shared.mjs";
+
+// A telemetry test asserts on the SINK, not the return value: toHaveBeenCalled*
+// on the emitted spy, or an expectation on .emit/.emitted/.capture/.track/.record.
+// Same predicate family as tester.bun.telemetry-emit, scoped to this profile and
+// joined with the exact-identity requirement of tester.bun.telemetry-identity-assertion.
+const RULE = "tester.bun.telemetry-captured-sink";
+const EMISSION_ASSERTION = /toHaveBeenCalled(?:With|Times)?\s*\(|expect[\s\S]{0,160}?\.\s*(?:emit|emitted|capture|track|record)\b/;
+const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+
+const { adopted } = await registry();
+const violations = [];
+if (adopted) {
+  const excludes = [...DEFAULT_EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+  for (const root of readRoots()) {
+    for (const file of walkTests(root, excludes)) {
+      const text = readText(file);
+      if (!text) continue;
+      const header = parseTestHeader(text);
+      if (!isTelemetryTest(file, header)) continue;
+      if (EMISSION_ASSERTION.test(text)) continue;
+      violations.push({ rule_id: RULE, file, line: header.urn ? header.urn.no : 1, col: 1,
+        evidence: "telemetry test asserts no emission (toHaveBeenCalled / expect on .emit/.capture/.track); a return-value check proves the function ran, not that the item fired",
+        source_line: header.urn ? header.urn.raw : "" });
+    }
+  }
+}
+process.stderr.write(`bun-telemetry-test[captured-sink]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_telemetry_test/checks/t_identity_assertion.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.telemetry-identity-assertion  (telemetry test family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW violations
+// to ATDD_VIOLATIONS_REPORT, exits 0 regardless of count.
+import { readRoots, parseJsonEnv, emit, maskComments } from "../../../lib/scan.mjs";
+import { registry, walkTests, parseTestHeader, isTelemetryTest, readText } from "../_shared.mjs";
+
+// Exact identity: the concrete URN the test claims to prove must appear in the
+// test's CODE (a string literal in an assertion), not only in its header. A test
+// that mocks an emitter and asserts "called with anything" proves emission
+// happened, not that the planned item is the one that fired.
+const RULE = "tester.bun.telemetry-identity-assertion";
+const ANY_URN_STRING = /["'`]telemetry:[^"'`\n]+["'`]/;
+const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+
+const { adopted } = await registry();
+const violations = [];
+if (adopted) {
+  const excludes = [...DEFAULT_EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+  for (const root of readRoots()) {
+    for (const file of walkTests(root, excludes)) {
+      const text = readText(file);
+      if (!text) continue;
+      const header = parseTestHeader(text);
+      if (!isTelemetryTest(file, header)) continue;
+      const code = maskComments(text); // comments do not assert; string literals do
+      const claimed = header.telemetry.map((reference) => reference.value);
+      if (claimed.length) {
+        for (const urn of claimed) {
+          if (code.includes(`"${urn}"`) || code.includes(`'${urn}'`) || code.includes("`" + urn + "`")) continue;
+          violations.push({ rule_id: RULE, file, line: 1, col: 1,
+            evidence: `never asserts the exact identity ${urn}; the URN must appear in an assertion string, not only in the header`,
+            source_line: "" });
+        }
+      } else if (!ANY_URN_STRING.test(code)) {
+        violations.push({ rule_id: RULE, file, line: header.urn ? header.urn.no : 1, col: 1,
+          evidence: "telemetry test asserts no concrete telemetry identity; assert the exact telemetry: URN the test claims to prove",
+          source_line: header.urn ? header.urn.raw : "" });
+      }
+    }
+  }
+}
+process.stderr.write(`bun-telemetry-test[identity-assertion]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_telemetry_test/checks/t_required_item_coverage.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.telemetry-required-item-coverage  (telemetry test family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW violations
+// to ATDD_VIOLATIONS_REPORT, exits 0 regardless of count.
+import { readRoots, parseJsonEnv, emit } from "../../../lib/scan.mjs";
+import { registry, walkTests, parseTestHeader, readText } from "../_shared.mjs";
+
+// The closure from the other side: every item an acceptance REQUIRES must have at
+// least one telemetry test bound to it by a Telemetry: header. The implementation
+// binding is the coder rule's concern; this is the evidence side — planned telemetry
+// that no test proves is a plan nobody can rely on.
+const RULE = "tester.bun.telemetry-required-item-coverage";
+const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+
+const { adopted, ids, requiredIds, itemFileById } = await registry();
+const violations = [];
+if (adopted) {
+  const excludes = [...DEFAULT_EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+  const bound = new Set();
+  for (const root of readRoots()) {
+    for (const file of walkTests(root, excludes)) {
+      const text = readText(file);
+      if (!text) continue;
+      for (const reference of parseTestHeader(text).telemetry) bound.add(reference.value);
+    }
+  }
+  for (const id of [...requiredIds].sort()) {
+    // An unresolvable required URN is the acceptance-decision rule's finding; judge only declared items.
+    if (!ids.has(id) || bound.has(id)) continue;
+    violations.push({ rule_id: RULE, file: itemFileById.get(id) ?? "telemetry/", line: 1, col: 1,
+      evidence: `${id} is required by an acceptance but no telemetry test binds it with a // Telemetry: header`,
+      source_line: "" });
+  }
+}
+process.stderr.write(`bun-telemetry-test[required-item-coverage]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_telemetry_test/checks/t_test_binding.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.telemetry-test-binding  (telemetry test family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW violations
+// to ATDD_VIOLATIONS_REPORT, exits 0 regardless of count.
+import { readRoots, parseJsonEnv, emit } from "../../../lib/scan.mjs";
+import { registry, walkTests, parseTestHeader, readText } from "../_shared.mjs";
+
+// A telemetry test proves an acceptance's required item, and says so in its header:
+// the Telemetry: URN must resolve into the tracking plan, and at least ONE of the test's
+// Acceptance: bindings must be an acceptance whose decision requires that item — a spec
+// file legitimately covers many acceptances, and any of them may be the requiring one.
+const RULE = "tester.bun.telemetry-test-binding";
+const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+
+const { adopted, ids, decisions, concreteUrn } = await registry();
+const violations = [];
+if (adopted) {
+  const excludes = [...DEFAULT_EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+  for (const root of readRoots()) {
+    for (const file of walkTests(root, excludes)) {
+      const text = readText(file);
+      if (!text) continue;
+      const header = parseTestHeader(text);
+      for (const reference of header.telemetry) {
+        const at = { line: reference.no, col: 1, source_line: reference.raw };
+        if (!concreteUrn.test(reference.value)) {
+          violations.push({ rule_id: RULE, file, ...at, evidence: `${reference.value} is not a concrete telemetry URN telemetry:{kind}:{plane}:{theme}:{artifact}[:{measure}]` });
+          continue;
+        }
+        if (!ids.has(reference.value)) {
+          violations.push({ rule_id: RULE, file, ...at, evidence: `${reference.value} does not resolve to a tracking-plan item under telemetry/` });
+          continue;
+        }
+        if (!header.acceptances.length) {
+          violations.push({ rule_id: RULE, file, ...at, evidence: `binds telemetry but no Acceptance: a telemetry test proves an acceptance's required item` });
+          continue;
+        }
+        const names = header.acceptances.map((binding) => binding.value);
+        const declared = header.acceptances.filter((binding) => decisions.has(binding.value));
+        if (!declared.length) {
+          violations.push({ rule_id: RULE, file, line: header.acceptances[0].no, col: 1, source_line: header.acceptances[0].raw, evidence: `${names.join(", ")} — none is a declared acceptance in the plan` });
+          continue;
+        }
+        if (!declared.some((binding) => {
+          const decision = decisions.get(binding.value);
+          return decision.disposition === "required" && decision.urns.includes(reference.value);
+        })) {
+          violations.push({ rule_id: RULE, file, ...at, evidence: `${names.join(", ")} — none requires ${reference.value}; bind a test to an acceptance whose telemetry decision lists the item` });
+        }
+      }
+    }
+  }
+}
+process.stderr.write(`bun-telemetry-test[test-binding]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_telemetry_test/checks/t_timing_semantics.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env bun
+// Member check: tester.bun.telemetry-timing-semantics  (telemetry test family)
+//
+// CONTRACT (v1.1): reads ATDD_SCAN_ROOTS / ATDD_SCAN_EXCLUDES, writes RAW violations
+// to ATDD_VIOLATIONS_REPORT, exits 0 regardless of count.
+import { readRoots, parseJsonEnv, emit, maskComments } from "../../../lib/scan.mjs";
+import { registry, walkTests, parseTestHeader, readText } from "../_shared.mjs";
+
+// Critical timing semantics are DECLARED on the tracking-plan item (timing:) and
+// exercised by the tests bound to it: post-commit, absent-after-rollback,
+// correlation-across-async. This is deliberately plan-driven: the check cannot
+// prove ordering statically, so it requires the plan to say when ordering matters
+// and the bound tests to reference the behaviour — in code or a test title, never
+// in a comment. Diagnostic logs and internal spans that declare no timing are not
+// judged.
+const RULE = "tester.bun.telemetry-timing-semantics";
+const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+const SEMANTIC_PROBES = {
+  "post-commit": /\bcommits?\b/i,
+  "absent-after-rollback": /\brollback\b|\brolled\s+back\b/i,
+  "correlation-across-async": /\bcorrelation\b|\bcontext\b/i,
+};
+
+const { adopted, ids, timingById, itemFileById } = await registry();
+const violations = [];
+if (adopted) {
+  const excludes = [...DEFAULT_EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+  const testsByItem = new Map();
+  for (const root of readRoots()) {
+    for (const file of walkTests(root, excludes)) {
+      const text = readText(file);
+      if (!text) continue;
+      for (const reference of parseTestHeader(text).telemetry) {
+        testsByItem.set(reference.value, [...(testsByItem.get(reference.value) ?? []), maskComments(text)]);
+      }
+    }
+  }
+  for (const [id, semantics] of [...timingById].sort(([left], [right]) => left.localeCompare(right))) {
+    if (!ids.has(id) || !semantics.length) continue;
+    const boundTests = testsByItem.get(id) ?? [];
+    for (const semantic of semantics) {
+      const probe = SEMANTIC_PROBES[semantic];
+      if (probe && boundTests.some((text) => probe.test(text))) continue;
+      violations.push({ rule_id: RULE, file: itemFileById.get(id) ?? "telemetry/", line: 1, col: 1,
+        evidence: `${id} declares timing semantic '${semantic}' but no bound telemetry test exercises it; assert the emission happens ${semantic === "post-commit" ? "only after commit" : semantic === "absent-after-rollback" ? "never after rollback" : "with correlation context carried across the async handoff"}`,
+        source_line: "" });
+    }
+  }
+}
+process.stderr.write(`bun-telemetry-test[timing-semantics]: ${violations.length} violation(s)\n`);
+emit(violations);

package/detectors/bun_telemetry_test/detect.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+// FAMILY validator: bun_telemetry_test
+// 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.
+// 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 { 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 is 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-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_test: member ${c} crashed without a violation report\n`);
+    crashed = true;
+  }
+}
+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_test: " + out.length + " violation(s)\n");
+process.exit(0);

package/detectors/bun_telemetry_test/fixtures/clean/plan/commons/E001.yaml

@@ -0,0 +1,10 @@
+urn: wmbt:commons:E001
+acceptances:
+  - identity:
+      urn: acc:commons:E001-UNIT-001
+    telemetry:
+      disposition: required
+      events:
+        - telemetry:event:be:commons:response-invocation-accepted
+      metrics:
+        - telemetry:metric:be:commons:response-invocation-accepted:duration

package/detectors/bun_telemetry_test/fixtures/clean/plan/commons/E002.yaml

@@ -0,0 +1,7 @@
+urn: wmbt:commons:E002
+acceptances:
+  - identity:
+      urn: acc:commons:E002-UNIT-001
+    telemetry:
+      disposition: not-applicable
+      rationale: No externally useful observable outcome beyond the tested return value.

package/detectors/bun_telemetry_test/fixtures/clean/plan/commons/_commons.yaml

@@ -0,0 +1,6 @@
+urn: wagon:commons
+wagon: commons
+produce:
+  - name: commons:response-invocation
+    contract: null
+    telemetry: telemetry:commons:response-invocation-accepted

package/detectors/bun_telemetry_test/fixtures/clean/src/wagons/commons/features/ingress/domain/accept-response.ts

@@ -0,0 +1,8 @@
+// Telemetry: telemetry:event:be:commons:response-invocation-accepted
+// Telemetry: telemetry:metric:be:commons:response-invocation-accepted:duration
+export type TelemetryPort = { emit(id: string, properties: Record<string, unknown>): void };
+
+export function acceptResponse(response: { id: string }, telemetry: TelemetryPort): void {
+  telemetry.emit("telemetry:event:be:commons:response-invocation-accepted", { response_id: response.id, outcome: "accepted" });
+  telemetry.emit("telemetry:metric:be:commons:response-invocation-accepted:duration", { outcome: "accepted" });
+}

package/detectors/bun_telemetry_test/fixtures/clean/telemetry/commons/response-invocation-accepted/event.be.json

@@ -0,0 +1,16 @@
+{
+  "id": "telemetry:event:be:commons:response-invocation-accepted",
+  "version": "1.0.0",
+  "logical_artifact": "telemetry:commons:response-invocation-accepted",
+  "kind": "event",
+  "plane": "be",
+  "owner": "commons",
+  "purpose": "Records that a response invocation passed acceptance so ingress health can be audited.",
+  "acceptances": ["acc:commons:E001-UNIT-001"],
+  "properties": {
+    "response_id": { "type": "string", "classification": "internal", "cardinality": "high" },
+    "outcome": { "type": "string", "allowed_values": ["accepted"] }
+  },
+  "required": ["response_id", "outcome"],
+  "forbidden_properties": ["raw_payload", "secret", "prompt"]
+}

package/detectors/bun_telemetry_test/fixtures/clean/telemetry/commons/response-invocation-accepted/metric.be.duration.json

@@ -0,0 +1,19 @@
+{
+  "id": "telemetry:metric:be:commons:response-invocation-accepted:duration",
+  "version": "1.0.0",
+  "logical_artifact": "telemetry:commons:response-invocation-accepted",
+  "kind": "metric",
+  "plane": "be",
+  "measure": "duration",
+  "instrument": "histogram",
+  "unit": "ms",
+  "owner": "commons",
+  "purpose": "Bounds how long an accepted response invocation takes to complete end to end.",
+  "acceptances": ["acc:commons:E001-UNIT-001"],
+  "properties": {
+    "outcome": { "type": "string", "classification": "internal", "cardinality": "low" }
+  },
+  "required": ["outcome"],
+  "dimensions": [{ "name": "outcome", "cardinality": "low" }],
+  "timing": ["post-commit"]
+}

package/detectors/bun_telemetry_test/fixtures/clean/tests/wagons/commons/features/ingress/unit/accept-response.telemetry.test.ts

@@ -0,0 +1,13 @@
+// URN: test:commons:ingress:E001-UNIT-001
+// Acceptance: acc:commons:E001-UNIT-001
+// Telemetry: telemetry:event:be:commons:response-invocation-accepted
+// Telemetry: telemetry:metric:be:commons:response-invocation-accepted:duration
+import { expect, mock, test } from "bun:test";
+import { acceptResponse } from "../../../../../src/wagons/commons/features/ingress/domain/accept-response";
+
+test("emits the planned event once the invocation commits", () => {
+  const emit = mock(() => {});
+  acceptResponse({ id: "r-1" }, { emit });
+  expect(emit).toHaveBeenCalledWith("telemetry:event:be:commons:response-invocation-accepted", { response_id: "r-1", outcome: "accepted" });
+  expect(emit).toHaveBeenCalledWith("telemetry:metric:be:commons:response-invocation-accepted:duration", { outcome: "accepted" });
+});

package/detectors/bun_telemetry_test/fixtures/clean/tests/wagons/commons/features/ingress/unit/accept-response.test.ts

@@ -0,0 +1,7 @@
+// URN: test:commons:ingress:E002-UNIT-001
+// Acceptance: acc:commons:E002-UNIT-001
+import { expect, test } from "bun:test";
+
+test("a plain non-telemetry test is not judged by the telemetry rules", () => {
+  expect(1 + 1).toBe(2);
+});

package/detectors/bun_telemetry_test/fixtures/dirty/plan/commons/E001.yaml

@@ -0,0 +1,10 @@
+urn: wmbt:commons:E001
+acceptances:
+  - identity:
+      urn: acc:commons:E001-UNIT-001
+    telemetry:
+      disposition: required
+      events:
+        - telemetry:event:be:commons:response-invocation-accepted
+      metrics:
+        - telemetry:metric:be:commons:response-invocation-accepted:duration

package/detectors/bun_telemetry_test/fixtures/dirty/plan/commons/E002.yaml

@@ -0,0 +1,7 @@
+urn: wmbt:commons:E002
+acceptances:
+  - identity:
+      urn: acc:commons:E002-UNIT-001
+    telemetry:
+      disposition: not-applicable
+      rationale: No externally useful observable outcome beyond the tested return value.

package/detectors/bun_telemetry_test/fixtures/dirty/plan/commons/_commons.yaml

@@ -0,0 +1,6 @@
+urn: wagon:commons
+wagon: commons
+produce:
+  - name: commons:response-invocation
+    contract: null
+    telemetry: telemetry:commons:response-invocation-accepted

package/detectors/bun_telemetry_test/fixtures/dirty/src/wagons/commons/features/ingress/domain/accept-response.ts

@@ -0,0 +1,8 @@
+// Telemetry: telemetry:event:be:commons:response-invocation-accepted
+// Telemetry: telemetry:metric:be:commons:response-invocation-accepted:duration
+export type TelemetryPort = { emit(id: string, properties: Record<string, unknown>): void };
+
+export function acceptResponse(response: { id: string }, telemetry: TelemetryPort): void {
+  telemetry.emit("telemetry:event:be:commons:response-invocation-accepted", { response_id: response.id, outcome: "accepted" });
+  telemetry.emit("telemetry:metric:be:commons:response-invocation-accepted:duration", { outcome: "accepted" });
+}

package/detectors/bun_telemetry_test/fixtures/dirty/telemetry/commons/response-invocation-accepted/event.be.json

@@ -0,0 +1,16 @@
+{
+  "id": "telemetry:event:be:commons:response-invocation-accepted",
+  "version": "1.0.0",
+  "logical_artifact": "telemetry:commons:response-invocation-accepted",
+  "kind": "event",
+  "plane": "be",
+  "owner": "commons",
+  "purpose": "Records that a response invocation passed acceptance so ingress health can be audited.",
+  "acceptances": ["acc:commons:E001-UNIT-001"],
+  "properties": {
+    "response_id": { "type": "string", "classification": "internal", "cardinality": "high" },
+    "outcome": { "type": "string", "allowed_values": ["accepted"] }
+  },
+  "required": ["response_id", "outcome"],
+  "forbidden_properties": ["raw_payload", "secret", "prompt"]
+}

package/detectors/bun_telemetry_test/fixtures/dirty/telemetry/commons/response-invocation-accepted/metric.be.duration.json

@@ -0,0 +1,19 @@
+{
+  "id": "telemetry:metric:be:commons:response-invocation-accepted:duration",
+  "version": "1.0.0",
+  "logical_artifact": "telemetry:commons:response-invocation-accepted",
+  "kind": "metric",
+  "plane": "be",
+  "measure": "duration",
+  "instrument": "histogram",
+  "unit": "ms",
+  "owner": "commons",
+  "purpose": "Bounds how long an accepted response invocation takes to complete end to end.",
+  "acceptances": ["acc:commons:E001-UNIT-001"],
+  "properties": {
+    "outcome": { "type": "string", "classification": "internal", "cardinality": "low" }
+  },
+  "required": ["outcome"],
+  "dimensions": [{ "name": "outcome", "cardinality": "low" }],
+  "timing": ["post-commit"]
+}