@afokapu/atdd-bun 0.1.0

package/lib/imports.mjs

@@ -0,0 +1,83 @@
+// imports.mjs — module import graph + architectural layer resolution, shared by
+// every detector in this provider that reasons about structure rather than text.
+//
+// Extracted from bun_ts_metrics_detector/ts_metrics.mjs when the clean-architecture
+// family needed the same graph: two copies of an import resolver is precisely what
+// `coder.bun.duplication-intra-layer` exists to refuse, and a detector suite that
+// violates its own rules has no standing.
+import { extname, dirname, resolve as resolvePath, basename, sep } from "node:path";
+
+// Bun ships a real TypeScript parser in-process, so the graph omits type-only
+// imports — erased at compile time, therefore not runtime edges. The regex set is
+// the fallback for a file the parser cannot read, matching what a Python detector
+// would see.
+const FALLBACK_IMPORT_RES = [
+  /(?:^|\n)\s*import\s+(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g,
+  /(?:^|\n)\s*export\s+(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g,
+  /(?:^|\n)\s*import\s+['"]([^'"]+)['"]/g,
+  /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+];
+
+export function moduleImports(source, file) {
+  try {
+    const loader = extname(file) === ".tsx" ? "tsx" : "ts";
+    return new Bun.Transpiler({ loader }).scan(source).imports.map((i) => i.path);
+  } catch {
+    const found = new Set();
+    for (const re of FALLBACK_IMPORT_RES) {
+      for (const m of source.matchAll(re)) found.add(m[1]);
+    }
+    return [...found];
+  }
+}
+
+// Import records INCLUDING type-only ones. The clean-architecture rules need these:
+// a layering violation is a violation even when the import is erased, because the
+// dependency it encodes is a real design coupling that a reader must follow.
+export function allImportSpecifiers(source) {
+  const found = new Set();
+  for (const re of FALLBACK_IMPORT_RES) {
+    for (const m of source.matchAll(re)) found.add(m[1]);
+  }
+  return [...found];
+}
+
+export const LAYERS = ["domain", "application", "integration", "presentation", "assembly"];
+
+// The layer a path belongs to, read from its directory segments. Returns null when
+// the path carries no layer segment — an unlayered file is outside these rules
+// rather than in violation of them.
+export function layerOf(path) {
+  const segs = path.toLowerCase().split(/[\\/]/);
+  for (const l of LAYERS) if (segs.includes(l)) return l;
+  return null;
+}
+
+// The commons/shared root a path sits under, or null.
+export function commonsRootOf(path) {
+  const segs = path.toLowerCase().split(/[\\/]/);
+  const i = segs.findIndex((s) => s === "commons" || s === "shared");
+  return i === -1 ? null : segs[i];
+}
+
+// The feature subdirectory directly under `commons/<layer>/`, or null.
+export function commonsFeatureOf(path) {
+  const segs = path.toLowerCase().split(/[\\/]/);
+  const i = segs.findIndex((s) => s === "commons" || s === "shared");
+  if (i === -1) return null;
+  const layer = segs[i + 1];
+  if (!LAYERS.includes(layer)) return null;
+  return segs[i + 2] && !/\.[cm]?[jt]sx?$/.test(segs[i + 2]) ? segs[i + 2] : null;
+}
+
+// Resolve a relative or `@/`-aliased specifier against a file, WITHOUT requiring
+// the target to exist: the layering rules judge the declared dependency, and a
+// broken import is `dead-code-reachability`'s finding, not theirs.
+export function resolveSpecifier(specifier, sourceFile, root) {
+  if (specifier.startsWith(".")) return resolvePath(dirname(sourceFile), specifier);
+  if (specifier.startsWith("@/")) return resolvePath(root, specifier.slice(2));
+  return null;   // bare npm specifier — outside the project graph
+}
+
+export { basename, sep, extname };

package/lib/scan.mjs

@@ -0,0 +1,246 @@
+// Shared scan-mount plumbing for every atdd.workspace.bun detector.
+//
+// The v1.1 provider contract is an ENV CHANNEL plus a JSON REPORT FILE:
+//
+//   INPUT   ATDD_SCAN_ROOTS      JSON array — the code-under-inspection roots.
+//           ATDD_SCAN_EXCLUDES   JSON array — exclusion path fragments.
+//           ATDD_VIOLATIONS_REPORT  path to write the JSON report to.
+//   OUTPUT  {"violations": [{rule_id,file,line,col,evidence,source_line}, ...]}
+//
+// Every check obeys the mount: it walks ONLY the declared roots and never
+// discovers the repo on its own. Factoring the walk here (rather than copying it
+// into each check, as the node-runtime detectors do) keeps the nine checks to
+// their actual detection logic — and keeps them under the duplication convention
+// the coder extension itself enforces.
+import { readFileSync, writeFileSync, statSync, readdirSync } from "node:fs";
+import { join, extname, sep } from "node:path";
+
+// Build output and vendored trees are never source-under-inspection. `.atdd` is
+// excluded by the adapter, not here, because a consumer's `.atdd/config.yaml` is
+// legitimate input for config-reading checks.
+export const DEFAULT_EXCLUDES = ["node_modules", "dist", "build", ".next", ".git", "_generated"];
+
+// Bun runs TS and ESM natively, so a full-stack Bun repo's source surface is
+// exactly these; `.html` is included because htmx templates ARE the source.
+export const SOURCE_EXT = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts"]);
+export const TEMPLATE_EXT = new Set([".html", ".htm"]);
+export const TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+
+export function parseJsonEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  try {
+    const value = JSON.parse(raw);
+    return Array.isArray(value) ? value : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function isExcluded(path, excludes) {
+  const segments = path.split(sep);
+  return excludes.some((ex) => segments.includes(ex) || path.includes(ex));
+}
+
+// Yield every file under `root` whose extension is in `exts`. `includeTests`
+// defaults false: assertion code legitimately contains patterns the rules forbid
+// in production source, so a check must opt in to seeing it.
+export function* walk(root, excludes, exts, includeTests = false) {
+  let st;
+  try {
+    st = statSync(root);
+  } catch {
+    return;
+  }
+  if (st.isFile()) {
+    if (exts.has(extname(root)) && (includeTests || !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* walk(full, excludes, exts, includeTests);
+    } else if (exts.has(extname(full)) && (includeTests || !TEST_RE.test(full))) {
+      yield full;
+    }
+  }
+}
+
+export function readRoots() {
+  return parseJsonEnv("ATDD_SCAN_ROOTS", []);
+}
+
+export function readExcludes() {
+  return [...DEFAULT_EXCLUDES, ...parseJsonEnv("ATDD_SCAN_EXCLUDES", [])];
+}
+
+// Mask string literals, template literals and comments with spaces of equal
+// length, preserving every line and column offset. A check that greps raw source
+// otherwise fires on the rule's own name inside a comment or a doc string — the
+// classic detector false positive.
+export function maskLiteralsAndComments(text) {
+  const out = text.split("");
+  let i = 0;
+  const n = text.length;
+  const blank = (from, to) => {
+    for (let k = from; k < to && k < n; k++) if (out[k] !== "\n") out[k] = " ";
+  };
+  while (i < n) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (ch === "/" && next === "/") {
+      let j = i;
+      while (j < n && text[j] !== "\n") j++;
+      blank(i, j);
+      i = j;
+    } else if (ch === "/" && next === "*") {
+      let j = text.indexOf("*/", i + 2);
+      j = j === -1 ? n : j + 2;
+      blank(i, j);
+      i = j;
+    } else if (ch === '"' || ch === "'" || ch === "`") {
+      let j = i + 1;
+      while (j < n) {
+        if (text[j] === "\\") { j += 2; continue; }
+        if (text[j] === ch) { j++; break; }
+        j++;
+      }
+      blank(i + 1, j - 1 >= i + 1 ? j - 1 : i + 1);
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  return out.join("");
+}
+
+// A check reports RAW facts and exits 0 even when it finds violations: finding a
+// violation is not a run error, and the disposition verdict is the consumer's.
+export function emit(violations) {
+  const reportPath = process.env.ATDD_VIOLATIONS_REPORT;
+  if (!reportPath) {
+    process.stderr.write("bun-detector: ATDD_VIOLATIONS_REPORT not set\n");
+    process.exit(2);
+  }
+  writeFileSync(reportPath, JSON.stringify({ violations }, null, 2), "utf8");
+  process.exit(0);
+}
+
+export function readText(file) {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+// Turn a character offset into the {line, col, source_line} the v1.1 record needs.
+export function locate(text, offset) {
+  const before = text.slice(0, offset);
+  const line = before.split("\n").length;
+  const lineStart = before.lastIndexOf("\n") + 1;
+  const lineEnd = text.indexOf("\n", offset);
+  return {
+    line,
+    col: offset - lineStart + 1,
+    source_line: text.slice(lineStart, lineEnd === -1 ? text.length : lineEnd).trim(),
+  };
+}
+
+// Walk for files matched by BASENAME rather than extension — the shape a
+// repo-hygiene rule needs (lockfiles, config files), where the filename itself is
+// the fact being checked.
+export function* walkByName(root, excludes, names) {
+  let st;
+  try {
+    st = statSync(root);
+  } catch {
+    return;
+  }
+  if (st.isFile()) return;
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = join(root, name);
+    if (isExcluded(full, excludes)) continue;
+    let cst;
+    try {
+      cst = statSync(full);
+    } catch {
+      continue;
+    }
+    if (cst.isDirectory()) yield* walkByName(full, excludes, names);
+    else if (names.has(name)) yield full;
+  }
+}
+
+// Return the full source text of the markup tag enclosing `offset`, or null.
+// Attribute rules are per-ELEMENT ("this element carries hx-delete but no
+// hx-confirm"), so a check must see the whole opening tag, not the one attribute
+// it matched. Quote-aware so a `>` inside an attribute value does not end the tag.
+export function enclosingTag(text, offset) {
+  let start = -1;
+  for (let i = offset; i >= 0; i--) {
+    if (text[i] === "<") { start = i; break; }
+    if (text[i] === ">") return null; // ran out of the tag before finding its open
+  }
+  if (start === -1) return null;
+  let quote = null;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      return { start, end: i + 1, text: text.slice(start, i + 1) };
+    }
+  }
+  return null;
+}
+
+// Extract every backtick template literal as {start, text}. Used by the fragment
+// escaping rule: in a full-stack Bun app the HTML fragments htmx swaps in are
+// built as tagged/plain template literals, so THAT is where the injection risk
+// lives — and it is precisely what `maskLiteralsAndComments` blanks, hence a
+// dedicated extractor rather than reusing the mask.
+export function templateLiterals(text) {
+  const found = [];
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "`") {
+      const start = i;
+      let j = i + 1;
+      let depth = 0;
+      while (j < text.length) {
+        if (text[j] === "\\") { j += 2; continue; }
+        if (text[j] === "$" && text[j + 1] === "{") { depth++; j += 2; continue; }
+        if (text[j] === "}" && depth > 0) { depth--; j++; continue; }
+        if (text[j] === "`" && depth === 0) break;
+        j++;
+      }
+      found.push({ start, text: text.slice(start, Math.min(j + 1, text.length)) });
+      i = j + 1;
+    } else {
+      i++;
+    }
+  }
+  return found;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@afokapu/atdd-bun",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "atdd-bun": "./src/cli.ts"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./register": "./src/register.ts"
+  },
+  "files": [
+    "src",
+    "detectors",
+    "lib",
+    "conventions",
+    "planner-nodes",
+    "planner-schemas",
+    "bunfig.toml",
+    "PLANNER_PORT.md",
+    "HOOK_AUDIT.md",
+    "templates"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "atdd-bun": "bun src/cli.ts"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1"
+  }
+}

package/planner-nodes/ENFORCEMENT_SCOPE.yaml

@@ -0,0 +1,117 @@
+schema_version: "1.0.0"
+package: "@afokapu/atdd-bun"
+node_corpus:
+  source: "src/atdd/planner/conventions/nodes/"
+  count: 195
+  policy: >-
+    Every node is shipped as canonical planner reference material. A node is not
+    represented as enforced merely because it is present in this corpus.
+
+# A provider implementation must name every canonical rule it realizes. `coverage`
+# describes the Bun predicate actually exercised, not an assertion that the entire
+# prose convention has been ported.
+canonical_bun_enforcement:
+  - rule_id: planner.train.naming
+    origin: schema-validator
+    coverage: complete
+    predicates:
+      - train definitions and interlocking route targets use train:<subject>:<slug>
+  - rule_id: planner.train.registry-coherence
+    origin: core-validator-port
+    coverage: complete
+    predicates:
+      - every registry path resolves to a train document
+      - every non-sidecar train document is registered
+  - rule_id: planner.journey.continuation-closure
+    origin: bun-custom-validator
+    coverage: complete
+    predicates:
+      - every route reachable from a journey entrypoint has exactly one continuation or terminal
+      - continuation route references resolve
+      - continuation artifacts occur in the selected train sequence
+      - continuation destinations resolve to interlockings
+      - disconnected continuation or terminal sources are rejected
+  - rule_id: planner.wagon.no-consume-cycle
+    origin: core-validator-port
+    coverage: partial
+    predicates:
+      - a wagon may not consume from itself
+    unported:
+      - multi-wagon strongly-connected-component detection
+  - rule_id: planner.contract.registry-coherence
+    origin: core-validator-port
+    coverage: complete
+    predicates:
+      - duplicate contract producers are reported
+      - every contract reference resolves in contracts/_contracts.yaml
+      - null cross-wagon contracts are reported
+      - unconsumed internal contract producers are reported
+      - registry identity theme matches its identity namespace
+      - registry paths resolve to contract documents
+  - rule_id: planner.theme.must-be-canonical
+    origin: bun-custom-validator
+    coverage: complete
+    predicates:
+      - every declared theme belongs to plan/_themes.yaml
+      - the package supplies no taxonomy besides reserved index 0
+  - rule_id: planner.theme.theme-zero-mandatory
+    origin: bun-custom-validator
+    coverage: complete
+    predicates:
+      - plan/_themes.yaml index 0 is commons
+  - rule_id: planner.theme.urn-namespace-matches
+    origin: bun-custom-validator
+    coverage: complete
+    predicates:
+      - a themed wagon's produced identities begin with that theme
+  - rule_id: planner.artifact-naming.theme-first-identity
+    origin: bun-custom-validator
+    coverage: complete
+    predicates:
+      - artifact identity themes are declared in plan/_themes.yaml
+  - rule_id: planner.wagon.urn
+    origin: bun-custom-validator
+    coverage: partial
+    predicates:
+      - duplicate wagon slugs are reported
+    unported:
+      - documented directory and file layout
+  - rule_id: planner.wagon.urn-naming
+    origin: bun-custom-validator
+    coverage: partial
+    predicates:
+      - wagon identity equals wagon:<slug>
+    unported:
+      - verb-object preference
+  - rule_id: planner.wagon.produce-consume-artifacts
+    origin: bun-custom-validator
+    coverage: partial
+    predicates:
+      - duplicate produced names and invalid declared wagon endpoints are reported
+    unported:
+      - complete required-field and URN-shape validation
+  - rule_id: planner.wagon.features
+    origin: bun-custom-validator
+    coverage: partial
+    predicates:
+      - duplicate feature references are reported
+    unported:
+      - complete feature-manifest coverage
+  - rule_id: planner.wagon.telemetry-filesystem
+    origin: bun-custom-validator
+    coverage: partial
+    predicates:
+      - duplicate telemetry producers are reported
+    unported:
+      - telemetry URN-to-filesystem mapping
+
+reference_only:
+  selection: "every canonical planner node not named in canonical_bun_enforcement"
+  count: 181
+
+package_integrity_guard:
+  implementation_id: planner.plan-integrity.bun
+  rule_namespace: atdd-bun.planner
+  policy: >-
+    Parse and graph-closure diagnostics are package safety guards, not claims to
+    realize canonical ATdd planner conventions. They run before canonical rules.

package/planner-nodes/nodes/planner.acceptance.abstract-fields-required.convention.yaml

@@ -0,0 +1,44 @@
+schema_version: 1.1.0
+rule_id: planner.acceptance.abstract-fields-required
+kind: constraint
+status: active
+name: Abstract Gherkin fields required
+statement: Each acceptance section declares an abstract Gherkin narrative (given.abstract, when.abstract,
+  then.abstract) — all three are REQUIRED.
+source:
+  legacy_path: src/atdd/planner/conventions/acceptance.convention.yaml
+  legacy_section: abstract_fields
+  legacy_sha: 027e2d86ff127550
+  extraction_mode: high_fidelity
+content:
+  summary: Gherkin-style abstract narrative within given/when/then sections for human readability.
+  operational_guidance: 'Abstract fields coexist with structured fields in the same section: abstract
+    for stakeholders (Gherkin), structured for machines (test generation). identity.purpose serves as
+    the scenario name — no separate top-level name needed.'
+  constraints:
+  - 'given.abstract: array[str], minItems 1, REQUIRED — each item a single precondition/setup state.'
+  - 'when.abstract: str, minLength 5, REQUIRED — present tense, clear actor and action.'
+  - 'then.abstract: array[str], minItems 1, REQUIRED — each item a single observable outcome.'
+  examples:
+  - given.abstract:
+    - appendix.convention.yaml defines manifest structure
+    - User account exists in the database
+  - when.abstract: User submits login form with credentials
+  - then.abstract:
+    - 'Wagon manifest includes appendices: [] at root level'
+    - Resolver can resolve appendix paths using URN pattern
+parity:
+  source_fragments_preserved: true
+  examples_preserved: true
+  implementation_preserved: false
+  fix_hint_preserved: false
+  reviewed_at: '2026-06-16'
+terms:
+- term_id: abstract_field
+  text: a Gherkin narrative line within a given/when/then section, for stakeholder readability alongside
+    the structured machine fields.
+  values:
+    locations:
+    - given.abstract
+    - when.abstract
+    - then.abstract

package/planner-nodes/nodes/planner.acceptance.authoring-guidelines.convention.yaml

@@ -0,0 +1,29 @@
+schema_version: 1.1.0
+rule_id: planner.acceptance.authoring-guidelines
+kind: principle
+status: active
+name: Acceptance authoring guidelines
+statement: Bind each acceptance to one metric, respect the parent WMBT's single dimension/lens, and collocate
+  WMBT + acceptances + tests + artifacts.
+source:
+  legacy_path: src/atdd/planner/conventions/acceptance.convention.yaml
+  legacy_section: guidelines + related_resources
+  legacy_sha: 027e2d86ff127550
+  extraction_mode: high_fidelity
+content:
+  operational_guidance: 'metric_binding: one metric_id from planner.criteria.metric-mapping (no mixed
+    measures). lens_dimension_dependency: one dimension and one lens_ref per WMBT. collocation: keep WMBT/acceptances/tests/artifacts
+    together for cohesive history/review.'
+  constraints:
+  - 'related: metrics_catalog=conventions:criteria:metrics'
+  - template_registry=.claude/templates/tester/templates.manifest.yaml
+parity:
+  source_fragments_preserved: true
+  examples_preserved: false
+  implementation_preserved: false
+  fix_hint_preserved: false
+  reviewed_at: '2026-06-16'
+terms:
+- term_id: metric_binding
+  text: each acceptance maps to exactly one metric_id, drawn from the
+    dimension->metric_id table in planner.criteria.metric-mapping.

package/planner-nodes/nodes/planner.acceptance.boundary-kind-vocabulary.convention.yaml

@@ -0,0 +1,38 @@
+schema_version: 1.1.0
+rule_id: planner.acceptance.boundary-kind-vocabulary
+kind: family
+status: active
+name: Boundary kinds
+statement: Controlled vocabulary of named integration surfaces an acceptance exercises; unknown values
+  are rejected.
+implementation:
+  type: validator
+  ref: tester.acceptance-violation.hermetic-fake-must-declare-contract
+source:
+  legacy_path: src/atdd/planner/conventions/acceptance.convention.yaml
+  legacy_section: boundary_kinds
+  legacy_sha: 027e2d86ff127550
+  extraction_mode: high_fidelity
+content:
+  normative_text: 'Unknown boundary_kind values are rejected by tester.acceptance-violation.hermetic-fake-must-declare-contract.
+    Note: `golden` is a harness_code, NOT a boundary_kind (Decision #7).'
+parity:
+  source_fragments_preserved: true
+  examples_preserved: false
+  implementation_preserved: true
+  fix_hint_preserved: false
+  reviewed_at: '2026-06-16'
+terms:
+- term_id: boundary_kind
+  text: a named integration surface exercised by an acceptance.
+  values:
+    argv: Command-line argument vector passed to a process.
+    subprocess: A child process spawned and observed.
+    filesystem: Files and directories read or written.
+    git: A local git repository's objects, refs, and config.
+    http_wire: HTTP request/response envelopes (cassette when hermetic).
+    llm_wire: LLM prompt/response envelopes (recorded/deterministic when hermetic).
+    cmux_rpc: cmux RPC request/response messages.
+    env_config: Environment variables and configuration inputs.
+    db_wire: Database query/response envelopes.
+    event_wire: Event-bus publish/consume envelopes.

package/planner-nodes/nodes/planner.acceptance.execution-kind.convention.yaml

@@ -0,0 +1,30 @@
+schema_version: 1.1.0
+rule_id: planner.acceptance.execution-kind
+kind: family
+status: active
+name: Execution kind (runtime-environment axis)
+statement: execution_kind is an orthogonal runtime-environment classifier (live infrastructure vs hermetic),
+  separate from harness/category.
+source:
+  legacy_path: src/atdd/planner/conventions/acceptance.convention.yaml
+  legacy_section: execution_kinds
+  legacy_sha: 027e2d86ff127550
+  extraction_mode: high_fidelity
+content:
+  normative_text: 'A NEW orthogonal axis added per issue #690; harness_codes/harness_types/category enums
+    are unchanged. Authors select those as today and ADD execution_kind.'
+parity:
+  source_fragments_preserved: true
+  examples_preserved: false
+  implementation_preserved: false
+  fix_hint_preserved: false
+  reviewed_at: '2026-06-16'
+terms:
+- term_id: execution_kind
+  text: the runtime-environment classifier for an acceptance.
+  values:
+    hermetic_integration: Real subject, real boundary shape, real integration sequence — NO live external
+      infrastructure. Fakes (cassettes, recorded LLM responses) permitted only with a declared fidelity
+      contract.
+    live_smoke: Verification against real live infrastructure (HTTP, DB, auth, deployment). SMOKE remains
+      the live-infrastructure confidence tier.

package/planner-nodes/nodes/planner.acceptance.extraction-no-inference.convention.yaml

@@ -0,0 +1,23 @@
+schema_version: 1.1.0
+rule_id: planner.acceptance.extraction-no-inference
+kind: principle
+status: active
+name: Extraction by asking, not inferring
+statement: Missing context is obtained by asking the user directly — no inference, no suggestions.
+source:
+  legacy_path: src/atdd/planner/conventions/acceptance.convention.yaml
+  legacy_section: extraction
+  legacy_sha: 027e2d86ff127550
+  extraction_mode: high_fidelity
+content:
+  operational_guidance: 'Pure conversational approach. e.g. wagon_inference prompt: ''Which wagon should
+    this acceptance belong to?'''
+parity:
+  source_fragments_preserved: true
+  examples_preserved: false
+  implementation_preserved: false
+  fix_hint_preserved: false
+  reviewed_at: '2026-06-16'
+terms:
+- term_id: no_inference
+  text: the policy of asking rather than guessing missing acceptance context.

package/planner-nodes/nodes/planner.acceptance.generator-prompts.convention.yaml

@@ -0,0 +1,34 @@
+schema_version: 1.1.0
+rule_id: planner.acceptance.generator-prompts
+kind: family
+status: active
+name: Acceptance generator prompts
+statement: The authoring prompt for composing each acceptance field (id, urn, harness, route, given, when,
+  then).
+source:
+  legacy_path: src/atdd/planner/conventions/acceptance.convention.yaml
+  legacy_section: generators
+  legacy_sha: 027e2d86ff127550
+  extraction_mode: high_fidelity
+content:
+  operational_guidance: One prompt per field; each sources the relevant section of this convention.
+parity:
+  source_fragments_preserved: true
+  examples_preserved: false
+  implementation_preserved: false
+  fix_hint_preserved: false
+  reviewed_at: '2026-06-16'
+terms:
+- term_id: generator_prompt
+  text: the LLM authoring prompt for an acceptance field.
+  values:
+    id: Compose the acceptance id with the step code and a zero-padded index (AC-{STEP}-{NNN}).
+    urn: Derive the URN from wagon slug, WMBT ID, harness code, and sequence using URNBuilder.acceptance.
+    harness: Select the harness that best exercises the outcome (unit/http/event/ws/e2e/...).
+    route: Populate route.layers and route.sequence so actions flow presentation -> application -> domain
+      -> integration.
+    given: Declare only the preconditions needed (auth, builders, time, stubbing, knobs) before the action
+      runs.
+    when: Describe the trigger using the harness-specific shape (http request, unit target, event topic,
+      etc.).
+    then: List assertions that prove the outcome (status, body, headers, error, metrics, etc.).