@afokapu/atdd-bun 0.10.30 → 0.10.32

package/relationships.yaml

@@ -95,17 +95,6 @@ nodes:
   - coder.htmx.verb-endpoint-is-routed
   - coder.htmx.verb-endpoint-same-origin
   - coder.htmx.verb-mutation-signals-progress
-  - delivery.approved-sha-resolves
-  - delivery.board
-  - delivery.config-schema
-  - delivery.evidence-schema
-  - delivery.findings-resolved
-  - delivery.merge-gate
-  - delivery.model-allowed
-  - delivery.operating-model
-  - delivery.review
-  - delivery.reviewer-independent
-  - delivery.stages-complete
   - planner.acceptance.abstract-fields-required
   - planner.acceptance.authoring-guidelines
   - planner.acceptance.boundary-kind-vocabulary
@@ -5208,143 +5197,3 @@ edges:
     target_ref: planner.telemetry.tracking-plan-schema
     type: requires
     origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: evidence is judged against the stages the policy configures
-    source_ref: delivery.evidence-schema
-    strength: important
-    target_ref: delivery.config-schema
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: allowed models and their preference order come from the policy
-    source_ref: delivery.model-allowed
-    strength: important
-    target_ref: delivery.config-schema
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: models are read from a well-formed review entry
-    source_ref: delivery.model-allowed
-    strength: important
-    target_ref: delivery.evidence-schema
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: independence is judged over the author and reviewer runs the record names
-    source_ref: delivery.reviewer-independent
-    strength: important
-    target_ref: delivery.evidence-schema
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: outcomes are read from well-formed findings
-    source_ref: delivery.findings-resolved
-    strength: important
-    target_ref: delivery.evidence-schema
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: a stage is approved only once its earlier findings are settled
-    source_ref: delivery.stages-complete
-    strength: important
-    target_ref: delivery.findings-resolved
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: start_to_start
-    reason: a reviewer works read-only in a fresh process, as the independence rule judges from the record
-    source_ref: delivery.review
-    strength: important
-    target_ref: delivery.reviewer-independent
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: start_to_start
-    reason: a reviewer settles a rebuttal in one round, as the findings rule judges from the record
-    source_ref: delivery.review
-    strength: important
-    target_ref: delivery.findings-resolved
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: start_to_start
-    reason: the driver runs every review as the review convention describes
-    source_ref: delivery.operating-model
-    strength: important
-    target_ref: delivery.review
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: the operating model leaves the record the evidence schema judges
-    source_ref: delivery.operating-model
-    strength: important
-    target_ref: delivery.evidence-schema
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: start_to_start
-    reason: the coordinator and drivers dispatch work and receive results through the board
-    source_ref: delivery.operating-model
-    strength: important
-    target_ref: delivery.board
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: the approved SHA is the one the closing review approved
-    source_ref: delivery.approved-sha-resolves
-    strength: important
-    target_ref: delivery.stages-complete
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: finish_to_start
-    reason: the gate compares the branch head with an approved SHA that exists
-    source_ref: delivery.merge-gate
-    strength: important
-    target_ref: delivery.approved-sha-resolves
-    type: requires
-    origin: "@afokapu/atdd-bun"
-  - confidence: 1
-    constraint: mandatory
-    control: internal
-    foundation: start_to_start
-    reason: the gate merges a tranche whose lifecycle closed its acceptances
-    source_ref: delivery.merge-gate
-    strength: important
-    target_ref: traceability.plan.executable-acceptance-has-test
-    type: requires
-    origin: "@afokapu/atdd-bun"

package/src/agent.ts

@@ -1,22 +1,12 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { deliveryAdopted } from "./delivery";
 
 const root = resolve(import.meta.dir, "..");
 const version = (await Bun.file(join(root, "package.json")).json() as { version: string }).version;
 const render = async (path: string) => (await readFile(join(root, "templates/agents", path), "utf8")).replace("{{VERSION}}", version);
 // .agents/skills is the vendor-neutral Agent Skills path (Codex, Copilot, Cursor, Gemini CLI, …); .claude/skills is Claude Code's.
 const skillPaths = [".agents/skills/atdd/SKILL.md", ".claude/skills/atdd/SKILL.md"];
-/** The delivery skill, installed only where the delivery profile is adopted: generated path → template. */
-export const deliverySkillFiles = [".agents/skills", ".claude/skills"].map(base => [`${base}/delivery/SKILL.md`, "delivery/SKILL.md"] as const);
-/** Generated files an earlier version installed and this one no longer ships: the review contract, now the skill's Reviewer section. */
-const retiredFiles = [".agents/skills/delivery/review.md", ".claude/skills/delivery/review.md"];
-/** Whether the repository's atdd-bun.yaml adopts the delivery profile. */
-export async function deliveryInstalled(repo: string): Promise<boolean> {
-  const file = join(repo, "atdd-bun.yaml");
-  try { return existsSync(file) && deliveryAdopted(Bun.YAML.parse(await readFile(file, "utf8"))); } catch { return false; }
-}
 // AGENTS.md is read by Codex, Cursor and most agents; CLAUDE.md by Claude Code. Both carry the same block.
 export const instructionPaths = ["AGENTS.md", "CLAUDE.md"];
 const block = /<!-- atdd-bun:start[\s\S]*?<!-- atdd-bun:end -->\n?/;
@@ -32,12 +22,6 @@ export async function agentInit(repo = process.cwd(), replace = false) {
     if (existsSync(output) && !replace) { kept.push(output); continue; }
     await mkdir(dirname(output), { recursive: true }); await writeFile(output, await render("atdd/SKILL.md")); written.push(output);
   }
-  if (await deliveryInstalled(repo)) for (const [path, template] of deliverySkillFiles) {
-    const output = join(repo, path);
-    if (existsSync(output) && !replace) { kept.push(output); continue; }
-    await mkdir(dirname(output), { recursive: true }); await writeFile(output, await render(template)); written.push(output);
-  }
-  for (const path of retiredFiles) if (existsSync(join(repo, path))) { await rm(join(repo, path)); written.push(`${join(repo, path)} (removed)`); }
   const managed = await render("AGENTS.block.md");
   for (const path of instructionPaths) {
     const file = join(repo, path), current = existsSync(file) ? await readFile(file, "utf8") : "";
@@ -48,7 +32,7 @@ export async function agentInit(repo = process.cwd(), replace = false) {
   return { ok: true, message: written.join("\n") };
 }
 export async function agentStatus(repo = process.cwd()) {
-  const expected = [...skillPaths, ...(await deliveryInstalled(repo) ? deliverySkillFiles.map(([path]) => path) : [])];
+  const expected = skillPaths;
   const missing = expected.map(path => join(repo, path)).filter(path => !existsSync(path));
   for (const path of instructionPaths) { const agents = join(repo, path); if (!existsSync(agents) || !block.test(await readFile(agents, "utf8"))) missing.push(`${agents} (atdd-bun block)`); }
   return { ok: !missing.length, message: missing.length ? `missing: ${missing.join(", ")}` : [...expected, ...instructionPaths].map(path => join(repo, path)).join("\n") };

package/src/cli.ts

@@ -8,7 +8,6 @@ import { journeyDocs } from "./journey-docs";
 import { adrRegister } from "./docs-capability";
 import { releaseCheck } from "./release";
 import { initializeRepository } from "./setup";
-import { chat } from "./board";
 
 const args = process.argv.slice(2);
 const usage = {
@@ -24,12 +23,6 @@ const usage = {
     "atdd-bun docs journeys [--out <dir>] [--check] [--force]",
     "atdd-bun docs adr-register [--check]",
     "atdd-bun release check",
-    "atdd-bun chat topic <program> [<tranche> [<stage> <round>]]",
-    "atdd-bun chat post <topic> --to <agent,...> [--kind K] [--stage S] [--reply-to ID] [--repo R] [--branch B] [--worktree W] [--goal G]  (body on stdin)",
-    "atdd-bun chat read <topic> [--mine] [--since ID]",
-    "atdd-bun chat wait <topic[,topic...]> [--since ID] [--skip KIND,...] [--timeout SECONDS]",
-    "atdd-bun chat follow <topic[,topic...]> [--since ID] [--skip KIND,...] [--timeout SECONDS]",
-    "atdd-bun chat                      (the board: every topic on the left, the conversation on the right)",
   ],
   profiles: profileNames,
   note: "Use a profile directly, for example: atdd-bun planner. --profile planner remains supported for compatibility.",
@@ -101,7 +94,6 @@ if (args[0] === "agent") {
   const result = args[1] === "init" ? await agentInit(process.cwd(), args.includes("--replace")) : args[1] === "status" ? await agentStatus() : fail("agent requires init or status");
   console[result.ok ? "log" : "error"](result.message); process.exit(result.ok ? 0 : 1);
 }
-if (args[0] === "chat") process.exit(await chat(args.slice(1)));
 if (args[0] === "release") {
   if (args[1] !== "check") fail("release requires check");
   const result = await releaseCheck(); console[result.ok ? "log" : "error"](result.message); process.exit(result.ok ? 0 : 1);

package/src/docs-capability.ts

@@ -1,6 +1,5 @@
 import { existsSync } from "node:fs";
 import { journeyDocs, journeyDocsApply } from "./journey-docs";
-import { DEFAULT_ROOT, deliveryAdopted, deliveryPolicy } from "./delivery";
 import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, isAbsolute, join, relative, resolve } from "node:path";
@@ -18,7 +17,7 @@ export type DocumentationRender = { findings: DocumentationViolation[]; couldNot
 
 const DOCS = "docs";
 const DIST = "docs/dist";
-const AREAS = ["docs", "docs/purpose", "docs/architecture", "docs/architecture/decisions", "docs/delivery", "docs/archive"];
+const AREAS = ["docs", "docs/purpose", "docs/architecture", "docs/architecture/decisions", "docs/archive"];
 const VERBS = ["decides", "supersedes", "implements", "depends-on"];
 const ADR_DIR = "docs/architecture/decisions";
 const ADR_INDEX = `${ADR_DIR}/index.adoc`;
@@ -51,23 +50,6 @@ export function parseAttributes(text: string): { attrs: Record<string, string>;
   return { attrs, lines };
 }
 
-/** The delivery profile's records folder, when it is adopted: tranche records and reports are YAML and data, judged by
- * that profile, never authored documentation. The docs profile leaves the folder (by default docs/delivery/tranches) to
- * it; the rest of docs/delivery, the program's reasoning, stays documentation. */
-async function deliveryRecords(root: string): Promise<(path: string) => boolean> {
-  const file = join(root, "atdd-bun.yaml");
-  try {
-    const data = existsSync(file) ? Bun.YAML.parse(await readFile(file, "utf8")) as Record<string, unknown> | null : null;
-    if (!deliveryAdopted(data)) return () => false;
-    // Only the one folder the delivery profile may use under docs/; a root configured anywhere else in docs/ is a delivery
-    // finding and exempts nothing here.
-    if (deliveryPolicy(data!.delivery).root !== DEFAULT_ROOT) return () => false;
-    // Records and data only: AsciiDoc there stays documentation, judged by every docs rule (the delivery profile also
-    // reports it as a file that does not belong in the records folder).
-    return path => path.startsWith(`${DEFAULT_ROOT}/`) && !path.endsWith(".adoc");
-  } catch { return () => false; }
-}
-
 async function documents(root: string): Promise<Document[]> {
   const paths = await walk(join(root, DOCS), ".adoc");
   return Promise.all(paths.filter(path => !generated(relative(root, path).replaceAll("\\", "/"))).map(async path => {
@@ -105,8 +87,8 @@ function adrViolations(docs: Document[]): DocumentationViolation[] {
 }
 
 export async function scanDocumentation(root: string): Promise<DocumentationViolation[]> {
-  const absolute = resolve(root), docs = await documents(absolute), output: DocumentationViolation[] = [], records = await deliveryRecords(absolute);
-  for (const path of await walk(join(absolute, DOCS), ".md")) { const file = relative(absolute, path).replaceAll("\\", "/"); if (!generated(file) && !records(file)) output.push(violation("planner.docs.asciidoc-only", file, 1, `authored markdown beneath docs/: ${file}. AsciiDoc is the only authored format; convert it, and convert a historical document INTO docs/archive/ rather than into a current area.`, lineAt(await readFile(path, "utf8"), 1))); }
+  const absolute = resolve(root), docs = await documents(absolute), output: DocumentationViolation[] = [];
+  for (const path of await walk(join(absolute, DOCS), ".md")) { const file = relative(absolute, path).replaceAll("\\", "/"); if (!generated(file)) output.push(violation("planner.docs.asciidoc-only", file, 1, `authored markdown beneath docs/: ${file}. AsciiDoc is the only authored format; convert it, and convert a historical document INTO docs/archive/ rather than into a current area.`, lineAt(await readFile(path, "utf8"), 1))); }
   for (const doc of docs) { const missing = ["doc-id", "status"].filter(name => !doc.attrs[name]); if (missing.length) output.push(violation("planner.docs.identity-required", doc.path, 1, `document declares no ${missing.map(name => `:${name}:`).join(" and no ")}. Identity and currency are both required: an id with no status is a node whose currency is unknown, a status with no id is a claim nothing can reference.`, lineAt(doc.text, 1))); }
   const byId = new Map<string, Document[]>(); for (const doc of docs) if (doc.attrs["doc-id"]) byId.set(doc.attrs["doc-id"], [...(byId.get(doc.attrs["doc-id"]) ?? []), doc]);
   for (const [id, group] of byId) if (group.length > 1) for (const doc of group) { const line = doc.lines["doc-id"] ?? 1; output.push(violation("planner.docs.doc-id-unique", doc.path, line, `doc-id ${JSON.stringify(id)} is declared by ${group.length} documents: ${group.map(d => d.path).join(", ")}. Resolution needs exactly one target per id.`, lineAt(doc.text, line))); }
@@ -124,12 +106,12 @@ async function journeyViewViolations(root: string): Promise<DocumentationViolati
   return result.stale.map(file => violation("planner.docs.journey-view-current", file, 1, `${file} does not match what plan/ generates, so the journey documentation no longer shows the plan. Regenerate it with \`atdd-bun docs journeys\` and commit the result; never edit it by hand.`));
 }
 
-export function declarationViolations(declaration: DocumentationDeclaration | null, changeSet?: string[], records: (path: string) => boolean = () => false): DocumentationViolation[] {
+export function declarationViolations(declaration: DocumentationDeclaration | null, changeSet?: string[]): DocumentationViolation[] {
   if (!declaration) return [];
   const artifacts = Array.isArray(declaration.artifacts) ? declaration.artifacts : []; const output: DocumentationViolation[] = [];
   if (declaration.impact !== "change" && declaration.impact !== "none") output.push(violation("planner.docs.artifact-path-shape", "<declaration>", 1, `declaration carries impact=${JSON.stringify(declaration.impact)}; the two total forms are ["change", "none"]. A malformed declaration is reported, never treated as nothing-to-check.`));
   for (const [index, artifact] of artifacts.entries()) { const path = artifact.path ?? "", problems: string[] = []; if (!path) problems.push("declares no path"); else { if (!path.startsWith("docs/")) problems.push(`path ${JSON.stringify(path)} is outside the canonical tree (must begin "docs/")`); if (!path.endsWith(".adoc")) problems.push(`path ${JSON.stringify(path)} is not AsciiDoc (must end ".adoc")`); if (artifact.action === "archive" && !path.startsWith("docs/archive/")) problems.push(`archive destination ${JSON.stringify(path)} is outside "docs/archive/" — archiving must preserve history, never promote it into a current area`); } if (problems.length) output.push(violation("planner.docs.artifact-path-shape", path || "<declaration>", 1, `declared artifact[${index}] (action: ${artifact.action || "unset"}): ${problems.join("; ")}`)); }
-  if (changeSet) { const covered = new Set(artifacts.flatMap(a => [a.path, a.from]).filter((p): p is string => Boolean(p))); for (const path of [...new Set(changeSet)].sort()) if (path.startsWith("docs/") && !generated(path) && !records(path) && !covered.has(path)) output.push(violation("planner.docs.undeclared-change", path, 1, `the change set touches ${path} and no declared artifact covers it. Declare it at RATIFY; if the change was not planned, the declaration was wrong at RATIFY and re-ratifying is the honest correction.`)); }
+  if (changeSet) { const covered = new Set(artifacts.flatMap(a => [a.path, a.from]).filter((p): p is string => Boolean(p))); for (const path of [...new Set(changeSet)].sort()) if (path.startsWith("docs/") && !generated(path) && !covered.has(path)) output.push(violation("planner.docs.undeclared-change", path, 1, `the change set touches ${path} and no declared artifact covers it. Declare it at RATIFY; if the change was not planned, the declaration was wrong at RATIFY and re-ratifying is the honest correction.`)); }
   return output;
 }
 
@@ -170,7 +152,7 @@ export async function renderDocumentation(root: string, timeoutMs = 120_000): Pr
 async function checkDocumentationInner(input: { root: string; declaration: DocumentationDeclaration | null; changeSet: string[] | null; render?: () => Promise<DocumentationRender> }): Promise<DocumentationCheck> {
   if (input.declaration?.impact === "none") return { verdict: "NOT_APPLICABLE", findings: [], checked: [] };
   const corpus = await scanDocumentation(input.root); const findings: DocumentationCheck["findings"] = [...corpus]; const checked = (await documents(resolve(input.root))).map(d => d.path); let definite = corpus.length > 0;
-  if (input.declaration) { const declarationFindings = declarationViolations(input.declaration, input.changeSet ?? undefined, await deliveryRecords(resolve(input.root))); findings.push(...declarationFindings); definite ||= declarationFindings.length > 0; checked.push("<declaration>"); if (input.declaration.impact === "change") for (const artifact of input.declaration.artifacts ?? []) if (["create", "modify"].includes(artifact.action ?? "") && artifact.path && !existsSync(join(input.root, artifact.path))) { findings.push(violation("planner.docs.artifact-path-shape", artifact.path, 1, `declared artifact ${JSON.stringify(artifact.path)} (action: ${artifact.action}) is not in the tree, so it was never examined; a declared document that was never written has not discharged the obligation.`)); definite = true; } } else findings.push({ rule_id: null, where: "<declaration>", message: "core supplied no documentation declaration, so no declaration-dependent rule could be evaluated. This is COULD_NOT_CHECK and it BLOCKS." });
+  if (input.declaration) { const declarationFindings = declarationViolations(input.declaration, input.changeSet ?? undefined); findings.push(...declarationFindings); definite ||= declarationFindings.length > 0; checked.push("<declaration>"); if (input.declaration.impact === "change") for (const artifact of input.declaration.artifacts ?? []) if (["create", "modify"].includes(artifact.action ?? "") && artifact.path && !existsSync(join(input.root, artifact.path))) { findings.push(violation("planner.docs.artifact-path-shape", artifact.path, 1, `declared artifact ${JSON.stringify(artifact.path)} (action: ${artifact.action}) is not in the tree, so it was never examined; a declared document that was never written has not discharged the obligation.`)); definite = true; } } else findings.push({ rule_id: null, where: "<declaration>", message: "core supplied no documentation declaration, so no declaration-dependent rule could be evaluated. This is COULD_NOT_CHECK and it BLOCKS." });
   if (input.declaration && input.changeSet === null) findings.push({ rule_id: null, where: "<change_set>", message: "core supplied no change set, so whether this diff touches docs/ without declaring it could not be established. This is COULD_NOT_CHECK and it BLOCKS." });
   const rendered = await (input.render ?? (() => renderDocumentation(input.root)))(); findings.push(...rendered.findings); definite ||= rendered.findings.length > 0; if (rendered.couldNotCheck) findings.push({ rule_id: "planner.docs.reference-integrity", file: "docs/", line: 1, col: 1, evidence: rendered.couldNotCheck, source_line: "" }); else checked.push("<render:asciidoctor>");
   // Fail closed on any rule id this capability does not declare, however it was built (a renderer can return anything).

package/src/enforce.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { topologyFor } from "./topology";
 
-export type Profile = "traceability" | "topology" | "docs" | "planner" | "telemetry" | "delivery" | "coder" | "tester" | "security" | "architecture" | "metrics" | "runtime" | "interlocking" | "htmx" | "design" | "all";
+export type Profile = "traceability" | "topology" | "docs" | "planner" | "telemetry" | "coder" | "tester" | "security" | "architecture" | "metrics" | "runtime" | "interlocking" | "htmx" | "design" | "all";
 
 export type Violation = {
   rule_id: string;
@@ -28,7 +28,6 @@ const profiles: Record<Exclude<Profile, "all">, string[]> = {
   docs: ["planner_docs_capability"],
   planner: ["planner_plan_integrity", "planner_schema_validation", "planner_static_validators", "atdd_topology"],
   telemetry: ["planner_telemetry_plan", "bun_telemetry_code", "bun_telemetry_test"],
-  delivery: ["delivery_evidence"],
   coder: ["bun_green_traceability_detector", "bun_clean_architecture_detector", "bun_ts_metrics_detector", "bun_fullstack_detector", "bun_design_system_detector", "bun_responsive_detector", "atdd_topology"],
   tester: ["bun_tester_discipline_detector", "htmx_e2e_detector", "atdd_topology"],
   security: ["bun_security_hygiene_detector"],

package/src/hooks.ts

@@ -36,17 +36,13 @@ export type WorktreeLayout = { primary: string; worktreeRoot: string; current: s
 async function layout(root: string, cfg: WorktreePolicy): Promise<WorktreeLayout | { error: string }> { const current = await realpath(resolve(root)), commonRoot = await primaryRoot(current); if (!commonRoot) return { error: "not inside a Git worktree" }; const primary = await realpath(commonRoot), expectedPrimary = join(dirname(primary), cfg.primary_directory); if (primary !== expectedPrimary) return { error: `primary checkout must be ${expectedPrimary}, not ${primary}` }; const branch = (await git(primary, ["symbolic-ref", "--quiet", "--short", "HEAD"])).out; if (branch !== cfg.primary_branch) return { error: `primary checkout ${primary} must be on ${cfg.primary_branch}, not ${branch || "a detached HEAD"}` }; return { primary, worktreeRoot: resolve(primary, cfg.root), current, branch: (await git(current, ["symbolic-ref", "--quiet", "--short", "HEAD"])).out }; }
 async function worktreeCommitPolicy(root: string, cfg: WorktreePolicy): Promise<string | null> { if (!cfg.enabled || !cfg.require_linked_worktree) return null; const state = await layout(root, cfg); if ("error" in state) return state.error; if (state.current === state.primary) return `commits must use a linked worktree beneath ${state.worktreeRoot}; run: atdd-bun worktree start <branch>`; if (!inside(state.worktreeRoot, state.current)) return `linked worktree ${state.current} is outside required root ${state.worktreeRoot}`; if (!state.branch) return "commits require a named branch, not a detached HEAD"; return null; }
 
-/** Where the pushed branch left its base branch. A delivery record unchanged since then was judged when it merged, so
- * pre-push does not judge it again, exactly as the merge gate does not; with no base found, every record is judged. */
-async function pushBase(root: string, remote: string, cfg: HookPolicy): Promise<string | null> { for (const ref of [`${remote}/HEAD`, ...cfg.protected_branches.map(name => `${remote}/${name}`)]) { const found = await git(root, ["merge-base", "HEAD", ref]); if (!found.code && found.out) return found.out; } return null; }
-
 export async function runHook(event: HookEvent, root = process.cwd(), args: string[] = [], stdin = "") {
   const cfg = await policy(root), branch = (await git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"])).out;
   if (["pre-commit", "pre-merge-commit"].includes(event) && cfg.protected_branches.includes(branch)) return bad(`protected branch ${branch} is blocked`);
   if (["pre-commit", "pre-merge-commit"].includes(event)) { const violation = await worktreeCommitPolicy(root, cfg.worktrees); if (violation) return bad(violation); }
   if (event === "pre-commit") { const staged = await files(root, ["diff", "--cached", "--name-only"]), registries = staged.filter(path => isRegistry(cfg, path)), generated = staged.filter(isGeneratedView), counted = staged.length - registries.length - generated.length, lines = (await stagedLineStats(root)).filter(row => !isRegistry(cfg, row.path) && !isGeneratedView(row.path)).reduce((n, row) => n + row.added + row.removed, 0); if (counted > cfg.max_staged_files) return bad(`staged files ${counted} exceed ${cfg.max_staged_files}`); if (lines > cfg.max_staged_changed_lines) return bad(`staged changed lines ${lines} exceed ${cfg.max_staged_changed_lines}`); return cfg.require_traceability || registries.length || generated.length ? validation(root, staged, false, registries.length > 0) : { ok: true, message: "ok" }; }
   if (event === "commit-msg") { const deleted = (await files(root, ["diff", "--cached", "--name-only", "--diff-filter=D"])).length, stats = await stagedStats(root), lines = stats.reduce((n, row) => n + row.removed, 0), registryRemoved = stats.filter(row => isRegistry(cfg, row.path)).reduce((n, row) => n + row.removed - row.added, 0), message = args[0] && existsSync(args[0]) ? await readFile(args[0], "utf8") : "", approved = message.includes("[mass-delete-approved]"); if ((deleted > 50 || lines > 10_000) && !approved) return bad("mass delete requires [mass-delete-approved]"); return registryRemoved > cfg.max_registry_removed_lines && !approved ? bad(`registry removal of ${registryRemoved} net lines exceeds ${cfg.max_registry_removed_lines}; requires [mass-delete-approved]`) : { ok: true, message: "ok" }; }
-  if (event === "pre-push") { for (const row of stdin.split("\n").filter(Boolean).map(row => row.split(/\s+/))) { const [,,remote, remoteSha] = row, target = remote?.replace("refs/heads/", ""); if (target && cfg.protected_branches.includes(target)) return bad(`protected branch ${target} is blocked`); const local = row[1]; if (local && !/^0+$/.test(local)) { const range = !remoteSha || /^0+$/.test(remoteSha) ? `${local}^..${local}` : `${remoteSha}..${local}`, count = Number((await git(root, ["rev-list", "--count", range])).out); if (count > cfg.max_commits_per_push) return bad(`commits per push ${count} exceed ${cfg.max_commits_per_push}`); } } const base = await pushBase(root, args[0] || "origin", cfg), previous = process.env.ATDD_DELIVERY_SINCE; if (base) process.env.ATDD_DELIVERY_SINCE = base; else delete process.env.ATDD_DELIVERY_SINCE; try { return await validation(root, await files(root, ["diff", "--name-only", "HEAD~1..HEAD"]), true); } finally { if (previous === undefined) delete process.env.ATDD_DELIVERY_SINCE; else process.env.ATDD_DELIVERY_SINCE = previous; } }
+  if (event === "pre-push") { for (const row of stdin.split("\n").filter(Boolean).map(row => row.split(/\s+/))) { const [,,remote, remoteSha] = row, target = remote?.replace("refs/heads/", ""); if (target && cfg.protected_branches.includes(target)) return bad(`protected branch ${target} is blocked`); const local = row[1]; if (local && !/^0+$/.test(local)) { const range = !remoteSha || /^0+$/.test(remoteSha) ? `${local}^..${local}` : `${remoteSha}..${local}`, count = Number((await git(root, ["rev-list", "--count", range])).out); if (count > cfg.max_commits_per_push) return bad(`commits per push ${count} exceed ${cfg.max_commits_per_push}`); } } return validation(root, await files(root, ["diff", "--name-only", "HEAD~1..HEAD"]), true); }
   if (event === "post-commit") { const result = await validation(root, await files(root, ["show", "--pretty=format:", "--name-only", "HEAD"]), false); return { ok: true, message: result.ok ? result.message : `advisory: ${result.message}` }; }
   return { ok: true, message: "ok" };
 }

package/src/index.ts

@@ -7,8 +7,6 @@ export type { PlanArtifact, PlanFinding, PlanGraph, PlanKind } from "./planner-k
 export { validateStaticPlannerConventions } from "./planner-validators";
 export { validateTelemetryPlan, loadTelemetryFiles, telemetryDecisionOf, CONCRETE_URN } from "./telemetry-plan";
 export type { TelemetryPlanItem, TelemetryFile } from "./telemetry-plan";
-export { canonicalRoot, gateMode, deliveryAdopted, deliveryPolicy, loadEvidence, loosenedDelivery, STAGES, validateDelivery } from "./delivery";
-export type { DeliveryOptions, GateMode, DeliveryPolicy, EvidenceFile, Independence, Stage, StagePolicy } from "./delivery";
 export { PLANNER_SCHEMA_RULE_ID, validatePlannerSchemas } from "./planner-schema-validator";
 export { defaultHookPolicy, hookEvents, hooksStatus, installHooks, runHook, uninstallHooks } from "./hooks";
 export type { HookEvent, HookPolicy } from "./hooks";

package/src/integrity.ts

@@ -1,9 +1,8 @@
 import { existsSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
-import { deliveryInstalled, deliverySkillFiles, instructionPaths } from "./agent";
+import { instructionPaths } from "./agent";
 import { renderWorkflow } from "./ci";
-import { loosenedDelivery } from "./delivery";
 import { defaultHookPolicy, type HookPolicy } from "./hooks";
 
 /**
@@ -101,9 +100,6 @@ async function checkGenerated(root: string, packageRoot: string, skipWorkflow =
   else if (!existsSync(workflow)) findings.push({ file: WORKFLOW, detail: "is missing", restore: "bun run atdd-bun ci init --replace" });
   else if (unstamp(await readFile(workflow, "utf8")) !== unstamp(await renderWorkflow(root))) findings.push({ file: WORKFLOW, detail: "was edited; it must match what the package generates (protected_branches decides its push branches)", restore: "bun run atdd-bun ci init --replace" });
   for (const skill of SKILLS) await same(skill, "templates/agents/atdd/SKILL.md", "bun run atdd-bun agent init --replace");
-  // Required while delivery is adopted; protected whenever present, so turning delivery off and on cannot launder an edit.
-  const adopted = await deliveryInstalled(root);
-  for (const [path, template] of deliverySkillFiles) if (adopted || existsSync(join(root, path))) await same(path, `templates/agents/${template}`, "bun run atdd-bun agent init --replace");
   await same(relative(root, await testFilePath(root)), "templates/agents/atdd-bun.integrity.test.ts", "bun run atdd-bun integrity init --replace");
   const canonical = (await readFile(join(packageRoot, "templates/agents/AGENTS.block.md"), "utf8")).match(BLOCK)![0];
   for (const file of instructionPaths) {
@@ -119,8 +115,7 @@ async function checkGenerated(root: string, packageRoot: string, skipWorkflow =
 const explicitProfiles = (config: { profiles?: unknown }): string[] | null => Array.isArray(config.profiles) ? config.profiles.map(String) : null;
 
 /** A policy with null-valued hook keys (and worktrees children) removed: YAML gives null for a key with no value, and the
- * hooks read null as absent, so the comparison must too. Other keys keep their null: delivery and profiles are read by
- * readers that tell null apart from absent (`delivery:` with no value adopts delivery). */
+ * hooks read null as absent, so the comparison must too. Other keys, including profiles, keep their null. */
 function withoutNulls(config: Record<string, unknown>): Record<string, unknown> {
   const out = Object.fromEntries(Object.entries(config).filter(([key, value]) => value !== null || !(key in defaultHookPolicy)));
   const worktrees = out.worktrees;
@@ -149,7 +144,7 @@ export function policyShapeErrors(config: Record<string, unknown>): string[] {
 }
 
 /** Names of the policy fields in `current` that are looser than in `base`. */
-export function loosenedPolicy(base: Partial<HookPolicy> & { profiles?: unknown; delivery?: unknown }, current: Partial<HookPolicy> & { profiles?: unknown; delivery?: unknown }): string[] {
+export function loosenedPolicy(base: Partial<HookPolicy> & { profiles?: unknown }, current: Partial<HookPolicy> & { profiles?: unknown }): string[] {
   const b = { ...defaultHookPolicy, ...base, worktrees: { ...defaultHookPolicy.worktrees, ...base.worktrees } }, c = { ...defaultHookPolicy, ...current, worktrees: { ...defaultHookPolicy.worktrees, ...current.worktrees } };
   const out: string[] = [];
   for (const key of ["max_staged_files", "max_staged_changed_lines", "max_commits_per_push", "max_registry_removed_lines"] as const) if (Number(c[key]) > Number(b[key])) out.push(`${key} ${b[key]} → ${c[key]}`);
@@ -165,7 +160,6 @@ export function loosenedPolicy(base: Partial<HookPolicy> & { profiles?: unknown;
   if (before && !after) out.push(`profiles becomes implicit: the explicit list [${before.join(", ")}] was removed`);
   const dropped = before && after ? before.filter(name => !after.includes(name)) : [];
   if (dropped.length) out.push(`profiles drops ${dropped.join(", ")}`);
-  out.push(...loosenedDelivery(base, current));
   return out;
 }
 

package/src/setup.ts

@@ -11,12 +11,10 @@ import { join } from "node:path";
  * without this a greenfield repository's first `profiles:` line could switch most of them off unreported. A
  * brownfield repository trims the list before its first commit; after that, dropping one is a reported loosening.
  * An existing atdd-bun.yaml is never touched. */
-/** Profiles a repository adopts on purpose, never by default: delivery gates every change on a reviewed tranche record. */
-const OPT_IN = ["delivery"];
 export async function policyInit(root = process.cwd()) {
   const file = join(root, "atdd-bun.yaml");
   if (existsSync(file)) return { ok: true, message: `${file} kept` };
-  await writeFile(file, `# Generated by atdd-bun init. The profiles this repository enforces; trim the list before the first commit to\n# adopt gradually. Once committed, removing a profile or the list is reported by the integrity check.\nprofiles: [${concreteProfiles.filter(profile => !OPT_IN.includes(profile)).join(", ")}]\n`);
+  await writeFile(file, `# Generated by atdd-bun init. The profiles this repository enforces; trim the list before the first commit to\n# adopt gradually. Once committed, removing a profile or the list is reported by the integrity check.\nprofiles: [${concreteProfiles.join(", ")}]\n`);
   return { ok: true, message: file };
 }
 

package/templates/agents/AGENTS.block.md

@@ -7,7 +7,5 @@ Before changing code, tests, or `plan/`, follow `.agents/skills/atdd/SKILL.md`:
 
 When the work reaches a stage whose profiles are not active yet, ask the user what they want to do and propose the matching preset from the package convention `atdd-bun.profiles.presets`.
 
-When `delivery` is active, deliver tranches through `.agents/skills/delivery/SKILL.md`: the reviews it requires are recorded under the delivery root and checked in CI.
-
 Never modify the toolkit itself (`node_modules/@afokapu/atdd-bun`, or the files atdd-bun generates); change only the configuration it offers, and loosen it only when the user asks. The integrity test and CI fail if the toolkit is modified.
 <!-- atdd-bun:end -->

package/templates/github/atdd-bun.yml

@@ -21,11 +21,6 @@ jobs:
       - run: bun install --frozen-lockfile
       - run: bun run atdd-bun integrity
       - run: bun run atdd-bun all
-        env:
-          # The delivery profile's gate: before the merge on pull requests and the merge queue, after it on a push.
-          ATDD_DELIVERY_GATE: ${{ github.event_name == 'push' && 'post-merge' || 'merge' }}
-          # On a push, the gate judges everything since the previous tip, not only the last commit.
-          ATDD_BASE_REF: ${{ github.event_name == 'push' && github.event.before || '' }}
       - run: bun test
       - run: bun run atdd-bun release check
       - uses: actions/upload-artifact@v4

package/conventions/delivery/delivery.approved-sha-resolves.convention.yaml

@@ -1,33 +0,0 @@
-schema_version: 1.1.0
-rule_id: delivery.approved-sha-resolves
-kind: rule
-status: active
-name: The approved SHA is a commit in this repository
-statement: >-
-  A ready record's approved_sha resolves to a commit in the repository's history, every work entry names a commit in approved_sha's history, and every reviewed stage's last approval does too, each containing the one before it in lifecycle order (REQUIRED).
-terms:
-- term_id: approved_sha
-  text: >-
-    the commit the closing review approved and the tranche asks to merge.
-content:
-  summary: >-
-    An approval of a commit nobody can find proves nothing: it may be a typo, a rewritten history, or an invention.
-  normative_text: |
-    The validator asks Git whether the commit exists. A rebase after approval changes every SHA and therefore needs a fresh review; the record cannot be updated by hand to follow it.
-  fix_hint: |
-    Record the full or abbreviated SHA the final review named. After a rebase, run the final review again on the new head.
-  exceptions:
-  - >-
-    At the gate, a record the change does not touch is not judged again: it was judged when it merged, and its tranche branch may be gone. The pre-push hook scopes the same way, from where the branch left its base branch; with no base found it judges every record. Everywhere else every ready record is judged.
-  - >-
-    A shallow clone may lack the commit: CI must fetch full history (the generated workflow uses fetch-depth 0).
-metadata:
-  aliases:
-  - DELIVERY-APPROVED-SHA-RESOLVES-001
-  severity: 3
-  # strict: atdd-bun fails on every finding; it has no advisory mode and no ratchet baseline.
-  disposition: strict
-  introduced_in: 0.8.0
-implementation:
-  type: validator
-  ref: delivery_evidence

package/conventions/delivery/delivery.board.convention.yaml

@@ -1,60 +0,0 @@
-schema_version: 1.1.0
-rule_id: delivery.board
-kind: policy
-status: active
-name: Agents talk through a local board, one topic per conversation
-statement: >-
-  Where atdd-bun.yaml sets delivery.board, the coordinator and drivers talk through a local message board with atdd-bun chat, never by typing into another agent's pane: one topic for the program, one per tranche, one per review conversation, each agent launched with its identity and the only topics it may use, every message naming its sender and recipients. The board makes the work visible; the evidence record stays the only thing the delivery rules judge.
-terms:
-- term_id: topics
-  text: >-
-    Three levels, each its own topic, named by atdd-bun chat topic so every agent spells them alike. atdd-<program>: coordinator, drivers and humans; status only (started, blocked, ready, merged, a decision a human must take). atdd-<program>-<tranche>: the tranche's driver; the tasks it gives its writers and their results. atdd-<program>-<tranche>-<stage>-<round>: the driver; one review's request and verdict. A rebuttal opens the next round's topic.
-  values:
-    program: atdd-bun chat topic <program>
-    tranche: atdd-bun chat topic <program> <tranche>
-    review: atdd-bun chat topic <program> <tranche> <stage> <round>
-- term_id: identity
-  text: >-
-    <role>@<tranche> for the whole tranche (driver@auth, writer-glm@auth, reviewer-codex@auth; a later round adds it: reviewer-codex-2@auth); coordinator for the coordinator.
-- term_id: launch
-  text: >-
-    Whoever starts a coordinator or driver gives it, in its environment, ATDD_AGENT (its identity) and ATDD_TOPICS (the topics it may use, comma-separated), and ATDD_BOARD_URL when the board is not the configured one. The coordinator gives a driver its tranche topic and the program topic; the driver adds each review topic as it opens it. atdd-bun chat refuses any other topic, to read or to write. Writers and reviewers get no board access: each is a headless run whose task is its launch prompt and whose answer is its output, which the driver posts (a verdict as "verdict of <reviewer>"), so their tools stay minimal and no sandbox has to reach the board.
-  values:
-    coordinator: ATDD_AGENT=coordinator@<program> ATDD_TOPICS=atdd-<program>
-    driver: ATDD_AGENT=driver@<tranche> ATDD_TOPICS=atdd-<program>,atdd-<program>-<tranche>
-- term_id: message
-  text: >-
-    atdd-bun chat post writes the header: from, to, participants and conversation always; kind (task, result, review-request, verdict, rebuttal, status, blocked, heartbeat), stage, reply-to, repo, branch, worktree, goal, base and sha when they apply. The body carries the whole instruction or answer, however long: the thread is the history. A heartbeat carries nothing else; anything that needs an answer goes as blocked, never inside a heartbeat.
-- term_id: commands
-  text: >-
-    Post with the body on standard input; read what is on a topic; wait for the next message addressed to you on one or several topics (comma-separated), skipping kinds you do not act on (--skip heartbeat), bounded by --timeout so a tool call ends (exit 2: nothing yet). wait remembers where each identity stopped on each set of topics (~/.atdd-board/cursors), so re-arming a watcher is always the same command; --since still overrides it; follow is the listener for a host that wakes its agent on each line a running process prints (Claude Code's Monitor tool): it streams every message addressed to the identity as it arrives and keeps running, keeping the same saved place; a host that wakes its agent only when a process exits runs wait and re-arms it after each wake-up. One listener per identity. When nothing arrives (wait's timeout, or follow's --check-in seconds, 20 minutes by default and 0 to turn it off), the listener prints the owner's check-in, asking where the agent is, whether it is moving or blocked and who knows, whether its stakeholder is informed, and whether it is avoiding ceremony and rabbit holes. The agent acts on it, moving the work or posting once to whoever it waits on, and never posts just to say it is still there. And, for a human, atdd-bun chat alone opens the board: every topic on the left, the selected conversation on the right, live.
-  values:
-    post: atdd-bun chat post <topic> --to <agent> --kind <kind> [--reply-to <id>] < message.md
-    read: atdd-bun chat read <topic> [--mine]
-    wait: atdd-bun chat wait <topic>[,<topic>...] [--since <id>] [--skip heartbeat] --timeout 540
-    follow: atdd-bun chat follow <topic>[,<topic>...] [--skip heartbeat,progress] [--timeout <seconds>] [--check-in <seconds>]
-    board: atdd-bun chat
-- term_id: server
-  text: >-
-    A local ntfy server, bound to the loopback address, keeping its messages in a cache file. Every agent on the machine reaches it from the same address, so ntfy's per-client limits are raised: requests, subscriptions, daily messages, and new topics (one topic per conversation creates many). With the defaults, ten parallel tranches exhaust them and posts are refused.
-  values:
-    docker: docker run -d --name atdd-board -p 127.0.0.1:2586:80 -v ~/.atdd-board:/var/cache/ntfy -e NTFY_CACHE_FILE=/var/cache/ntfy/cache.db -e NTFY_CACHE_DURATION=720h -e NTFY_MESSAGE_SIZE_LIMIT=64k -e NTFY_VISITOR_REQUEST_LIMIT_BURST=100000 -e NTFY_VISITOR_REQUEST_LIMIT_REPLENISH=1ms -e NTFY_VISITOR_SUBSCRIPTION_LIMIT=10000 -e NTFY_VISITOR_MESSAGE_DAILY_LIMIT=0 -e NTFY_VISITOR_TOPIC_CREATION_LIMIT_BURST=0 binwiederhier/ntfy serve
-content:
-  summary: >-
-    Typing into an agent's pane loses messages to startup screens, busy prompts and cut pastes. A board with one topic per conversation delivers every message, keeps the history, and lets a human follow any thread.
-  normative_text: |
-    A reviewer never reads the tranche's conversation: its brief is the review request in its launch prompt, and its verdict is its output. The driver records that verdict in evidence.yaml and posts it on the review topic; the board is never evidence.
-    Agents use atdd-bun chat only. It refuses an address that is not local and a topic the agent was not given. Never call ntfy directly: in the ntfy client -u means credentials, and a topic without a server goes to the public ntfy.sh.
-    A running session that must be woken is reached through its own channel (codex queue --thread <id>; --resume <session> for Claude and Pi), never by typing into its pane; a driver's launch prompt tells it to wait on its topics between steps.
-  fix_hint: |
-    Derive the topic with atdd-bun chat topic, launch coordinators and drivers with ATDD_AGENT and ATDD_TOPICS, and post with --to. To follow the work, run atdd-bun chat in a terminal pane. ntfy cannot list its topics, so the first message on a topic also posts the topic's name to the directory topic atdd-topics, which the view reads.
-  exceptions:
-  - >-
-    The board is opt-in: without a delivery.board block there is none, and atdd-bun chat refuses to post or read. With the block and no url it is at http://127.0.0.1:2586; ATDD_BOARD_URL moves it on one machine but never switches it on. Switching it on or off changes how agents talk, not what a record must prove, so it is not a loosening.
-metadata:
-  aliases:
-  - DELIVERY-BOARD-001
-  introduced_in: 0.10.0
-# A policy, not a rule: how agents talk cannot be validated from the repository. atdd-bun chat enforces its guard rails.
-implementation:
-  type: none

package/conventions/delivery/delivery.config-schema.convention.yaml

@@ -1,49 +0,0 @@
-schema_version: 1.1.0
-rule_id: delivery.config-schema
-kind: rule
-status: active
-name: The delivery policy in atdd-bun.yaml is well-formed
-statement: >-
-  The `delivery:` block of atdd-bun.yaml validates against delivery-config.schema.json: known keys only, each stage naming a writer list, a reviewer list or both, models named in lowercase, independence one of fresh-process or different-model, the root in canonical form (no leading, trailing or doubled slash, no dot segment) not overlapping the plan, source, test, e2e or telemetry root, and, inside docs/, exactly docs/delivery/tranches (REQUIRED).
-terms:
-- term_id: policy
-  text: >-
-    the `delivery:` block: root, independence, stages (plan, red, green, refactor, final; per stage: writer, reviewer, optional independence), fallback and commands. Every key is optional; an omitted key takes the package default.
-content:
-  summary: >-
-    The skill and the validators read the same policy. A misspelled key would be ignored by one and not the other, so a malformed block is a finding, and the rest of the run judges evidence against the package defaults.
-  normative_text: |
-    The policy decides which models may write and review each stage (an allowed set, in no order; "*" allows any), how independent a reviewer must be, and when a model counts as unavailable. It is read by the delivery skill when it dispatches work and by this profile when it judges the record, so both must see the same, valid document.
-  fix_hint: |
-    Correct the key the finding names. The defaults are:
-
-      delivery:
-        root: docs/delivery/tranches
-        independence: different-model
-        stages:
-          plan:     { writer: [codex, claude-opus, kimi], reviewer: [glm, claude-opus, codex, kimi] }
-          red:      { writer: [glm, claude-sonnet, deepseek-flash, claude-opus, codex, kimi] }
-          green:    { writer: [glm, claude-sonnet, deepseek-flash, claude-opus, codex, kimi] }
-          refactor: { writer: [glm, claude-sonnet, deepseek-flash, claude-opus, codex, kimi] }
-          final:    { reviewer: [codex, glm, claude-opus, kimi] }
-
-    independence defaults to different-model. A stage may name a writer, a reviewer or both. The 0.9
-    names plan_review, test_review, code_review and final_review are still read, as plan, red, refactor
-    and final, with authors as writers and reviewers as reviewers.
-  exceptions:
-  - >-
-    Adoption is not exempt from the gate: the pull request that adopts delivery brings the generated skill and workflow,
-    outside the delivery root, so it carries its own ready tranche record like any other change. A later change to
-    atdd-bun.yaml alone needs no record (delivery.merge-gate).
-  - >-
-    Inert until adoption: with no `delivery:` block and `delivery` absent from `profiles:`, no delivery rule emits anything.
-metadata:
-  aliases:
-  - DELIVERY-CONFIG-SCHEMA-001
-  severity: 3
-  # strict: atdd-bun fails on every finding; it has no advisory mode and no ratchet baseline.
-  disposition: strict
-  introduced_in: 0.8.0
-implementation:
-  type: validator
-  ref: delivery_evidence