@afokapu/atdd-bun 0.10.31 → 0.10.33

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,55 +1,39 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { readFile, rm, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { deliveryAdopted } from "./delivery";
+import { join, resolve } from "node:path";
 
 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; }
-}
+const legacySkillPaths = [".agents/skills/atdd/SKILL.md", ".claude/skills/atdd/SKILL.md"];
 // 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?/;
+const generatedSkill = /<!-- Generated by @afokapu\/atdd-bun /;
 /** `current` with the managed block replaced, or appended after at least one blank line; `current` itself is kept. */
 const withBlock = (current: string, managed: string) => block.test(current) ? current.replace(block, managed) : `${current}${current ? "\n\n".slice(current.match(/\n{0,2}$/)![0].length) : ""}${managed}`;
 
-/** Write the ATDD skill for every agent and a managed pointer block in AGENTS.md and CLAUDE.md. Existing files
- * and an existing block are kept unless `replace`; the rest of each instruction file is never touched. */
+/** Write the managed ATDD block in AGENTS.md and CLAUDE.md. Existing files and an existing block are kept unless
+ * `replace`; the rest of each instruction file is never touched. Generated legacy skills are retired automatically. */
 export async function agentInit(repo = process.cwd(), replace = false) {
-  const written: string[] = [], kept: string[] = [];
-  for (const path of skillPaths) {
-    const output = join(repo, path);
-    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 written: string[] = [], kept: string[] = [], retired: string[] = [];
+  for (const path of legacySkillPaths) {
     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);
+    if (!existsSync(output) || (!replace && !generatedSkill.test(await readFile(output, "utf8")))) continue;
+    await rm(output); retired.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") : "";
     if (block.test(current) && !replace) { kept.push(file); continue; }
     await writeFile(file, withBlock(current, managed)); written.push(file);
   }
-  if (!written.length) return { ok: false, message: `${kept.join(", ")} exist; use --replace` };
-  return { ok: true, message: written.join("\n") };
+  if (!written.length && !retired.length) return { ok: false, message: `${kept.join(", ")} exist; use --replace` };
+  return { ok: true, message: [...written, ...retired.map(path => `${path} removed`)].join("\n") };
 }
 export async function agentStatus(repo = process.cwd()) {
-  const expected = [...skillPaths, ...(await deliveryInstalled(repo) ? deliverySkillFiles.map(([path]) => path) : [])];
-  const missing = expected.map(path => join(repo, path)).filter(path => !existsSync(path));
+  const missing: string[] = [];
   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") };
+  for (const path of legacySkillPaths) { const skill = join(repo, path); if (existsSync(skill) && generatedSkill.test(await readFile(skill, "utf8"))) missing.push(`${skill} (retired generated skill)`); }
+  return { ok: !missing.length, message: missing.length ? `missing: ${missing.join(", ")}` : instructionPaths.map(path => join(repo, path)).join("\n") };
 }

package/src/cli.ts

@@ -8,7 +8,7 @@ import { journeyDocs } from "./journey-docs";
 import { adrRegister } from "./docs-capability";
 import { releaseCheck } from "./release";
 import { initializeRepository } from "./setup";
-import { chat } from "./board";
+import { profileRegistries } from "./profile-registry";
 
 const args = process.argv.slice(2);
 const usage = {
@@ -20,16 +20,11 @@ const usage = {
     "atdd-bun worktree <start|finish|status>",
     "atdd-bun ci <init|status> [--replace]",
     "atdd-bun agent <init|status> [--replace]",
+    "atdd-bun profiles registry [--check]",
     "atdd-bun integrity [init|status] [--replace]",
     "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 +96,11 @@ 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] === "profiles") {
+  if (args[1] !== "registry") fail("profiles requires registry");
+  const result = await profileRegistries({ check: args.includes("--check") });
+  console[result.ok ? "log" : "error"](result.message); process.exit(result.ok ? 0 : 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,8 @@ 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 ConcreteProfile = Exclude<Profile, "all">;
 
 export type Violation = {
   rule_id: string;
@@ -22,13 +23,12 @@ export type EnforcementConfig = {
   profiles?: Profile[];
 };
 
-const profiles: Record<Exclude<Profile, "all">, string[]> = {
+export const profileImplementations: Record<ConcreteProfile, string[]> = {
   traceability: ["atdd_traceability_closure"],
   topology: ["atdd_topology"],
   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"],
@@ -40,9 +40,8 @@ const profiles: Record<Exclude<Profile, "all">, string[]> = {
   design: ["bun_design_system_detector", "bun_responsive_detector"],
 };
 
-type ConcreteProfile = Exclude<Profile, "all">;
 /** Every profile but `all`. */
-export const concreteProfiles = Object.keys(profiles) as ConcreteProfile[];
+export const concreteProfiles = Object.keys(profileImplementations) as ConcreteProfile[];
 /** Profile names accepted by the CLI and public integrations. */
 export const profileNames = [...concreteProfiles, "all"] as Profile[];
 
@@ -69,10 +68,10 @@ export function implementationsFor(requested: Profile[] = ["all"]): string[] {
   const selected = new Set<string>();
   for (const profile of requested) {
     if (profile === "all") {
-      for (const ids of Object.values(profiles)) ids.forEach((id) => selected.add(id));
+      for (const ids of Object.values(profileImplementations)) ids.forEach((id) => selected.add(id));
       continue;
     }
-    const ids = profiles[profile];
+    const ids = profileImplementations[profile];
     if (!ids) throw new Error(`unknown enforcement profile: ${profile}`);
     ids.forEach((id) => selected.add(id));
   }
@@ -80,10 +79,10 @@ export function implementationsFor(requested: Profile[] = ["all"]): string[] {
 }
 
 /** The rule ids a detector's manifest declares it emits (emits_rule_ids and api_emits_rule_ids). */
-export async function declaredRuleIds(implementation: string): Promise<Set<string>> {
+export async function declaredRuleIds(implementation: string, detectors = detectorRoot): Promise<Set<string>> {
   const ids = new Set<string>();
   let inList = false;
-  for (const line of (await readFile(join(detectorRoot, implementation, "atdd.implementation.yaml"), "utf8")).split("\n")) {
+  for (const line of (await readFile(join(detectors, implementation, "atdd.implementation.yaml"), "utf8")).split("\n")) {
     if (line === "emits_rule_ids:" || line === "api_emits_rule_ids:") { inList = true; continue; }
     if (/^[A-Za-z_][\w-]*:/.test(line)) { inList = false; continue; }
     const match = inList && line.match(/^\s*-\s+([^#\s]+)/);

package/src/hooks.ts

@@ -1,13 +1,13 @@
 import { chmod, mkdir, readdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { enabledProfiles, enforce } from "./enforce";
 import { topologyFor } from "./topology";
 import { JOURNEY_DOCS_DIR } from "./journey-docs";
 
 export type WorktreePolicy = { enabled: boolean; root: string; primary_directory: string; primary_branch: string; require_linked_worktree: boolean };
 export type HookPolicy = { max_staged_files: number; max_staged_changed_lines: number; max_commits_per_push: number; max_registry_removed_lines: number; registry_paths: string[]; protected_branches: string[]; require_plan_reference: boolean; require_traceability: boolean; worktrees: WorktreePolicy };
-export const defaultWorktreePolicy: WorktreePolicy = { enabled: false, root: "../worktrees", primary_directory: "main", primary_branch: "main", require_linked_worktree: true };
+export const defaultWorktreePolicy: WorktreePolicy = { enabled: false, root: "../worktrees/{repo}", primary_directory: ".", primary_branch: "main", require_linked_worktree: true };
 export const defaultHookPolicy: HookPolicy = { max_staged_files: 20, max_staged_changed_lines: 350, max_commits_per_push: 10, max_registry_removed_lines: 350, registry_paths: ["plan/_*.yaml", "plan/_*.yml", "contracts/_*.yaml", "contracts/_*.yml"], protected_branches: ["main", "master"], require_plan_reference: true, require_traceability: true, worktrees: defaultWorktreePolicy };
 export const hookEvents = ["pre-commit", "commit-msg", "pre-push", "pre-merge-commit", "post-commit", "post-merge"] as const;
 export type HookEvent = typeof hookEvents[number];
@@ -33,20 +33,16 @@ async function validation(root: string, changed: string[], full: boolean, regist
 const inside = (parent: string, child: string) => { const path = relative(parent, child); return path === "" || (path !== ".." && !path.startsWith("../") && !path.startsWith("..\\")); };
 async function primaryRoot(root: string): Promise<string | null> { const result = await git(root, ["rev-parse", "--git-common-dir"]); if (result.code) return null; return dirname(resolve(root, result.out)); }
 export type WorktreeLayout = { primary: string; worktreeRoot: string; current: string; branch: string };
-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 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 = cfg.primary_directory === "." ? primary : 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.replaceAll("{repo}", basename(primary))), 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";
@@ -19,5 +17,6 @@ export type { Gap, Journey, JourneyModel, JourneyPath } from "./journey-docs";
 export { checkIntegrity, checkInstalledPackage, formatIntegrity, integrityInit, loosenedPolicy, writeManifest } from "./integrity";
 export type { IntegrityFinding, IntegrityOptions } from "./integrity";
 export { releaseCheck } from "./release";
+export { profileRegistries, renderProfileRegistries, PROFILE_REGISTRY_DIR } from "./profile-registry";
 export { defaultTopology, topologyFor } from "./topology";
 export type { Topology } from "./topology";

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";
 
 /**
@@ -19,7 +18,6 @@ const PACKAGE = "@afokapu/atdd-bun";
 const ownRoot = resolve(import.meta.dir, "..");
 export const MANIFEST = "integrity.json";
 export const TEST_FILE = "atdd-bun.integrity.test.ts";
-const SKILLS = [".agents/skills/atdd/SKILL.md", ".claude/skills/atdd/SKILL.md"];
 const WORKFLOW = ".github/workflows/atdd-bun.yml";
 const BLOCK = /<!-- atdd-bun:start[\s\S]*?<!-- atdd-bun:end -->/;
 // Generated files carry the version that wrote them; an upgrade must not read as tampering.
@@ -100,10 +98,6 @@ async function checkGenerated(root: string, packageRoot: string, skipWorkflow =
   if (skipWorkflow) { /* rendered from atdd-bun.yaml, which does not parse: reported by the caller */ }
   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 +113,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 +142,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 +158,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/profile-registry.ts

@@ -0,0 +1,74 @@
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { concreteProfiles, declaredRuleIds, profileImplementations } from "./enforce";
+
+export const PROFILE_REGISTRY_DIR = "conventions/_profiles";
+type Convention = { rule_id: string; path: string };
+type Relationship = Record<string, unknown> & { source_ref: string; target_ref: string; type: string };
+type Graph = { edges: Relationship[] };
+
+async function filesBelow(root: string, extension: string): Promise<string[]> {
+  const out: string[] = [];
+  for (const entry of await readdir(root, { withFileTypes: true })) {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) out.push(...await filesBelow(path, extension));
+    else if (entry.name.endsWith(extension)) out.push(path);
+  }
+  return out;
+}
+
+async function conventionIndex(root: string): Promise<Map<string, Convention>> {
+  const index = new Map<string, Convention>();
+  for (const base of ["planner-nodes/nodes", "conventions"]) for (const file of await filesBelow(join(root, base), ".convention.yaml")) {
+    const rule_id = (Bun.YAML.parse(await readFile(file, "utf8")) as { rule_id?: unknown }).rule_id;
+    if (typeof rule_id !== "string") continue;
+    const path = relative(root, file).replaceAll("\\", "/");
+    if (index.has(rule_id)) throw new Error(`multiple convention files declare ${rule_id}: ${index.get(rule_id)!.path}, ${path}`);
+    index.set(rule_id, { rule_id, path });
+  }
+  return index;
+}
+
+const sorted = <T>(items: Iterable<T>, compare: (left: T, right: T) => number = (left, right) => String(left).localeCompare(String(right))) => [...items].sort(compare);
+const relationshipKey = (edge: Relationship) => `${edge.source_ref}\u0000${edge.target_ref}\u0000${edge.type}`;
+const scalar = (value: unknown) => value === null ? "null" : typeof value === "string" ? JSON.stringify(value) : typeof value === "number" || typeof value === "boolean" ? String(value) : (() => { throw new Error(`profile registry cannot render non-scalar value ${JSON.stringify(value)}`); })();
+const fields = (value: Record<string, unknown>, indent: string) => sorted(Object.entries(value), ([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${indent}${key}: ${scalar(entry)}`);
+const render = (profile: string, implementations: string[], conventions: Convention[], relationships: Relationship[]) => [
+  'schema_version: "1.0.0"', `profile: ${scalar(profile)}`,
+  "implementations:", ...implementations.map(implementation => `  - ${scalar(implementation)}`),
+  "conventions:", ...conventions.flatMap(convention => [`  - rule_id: ${scalar(convention.rule_id)}`, `    path: ${scalar(convention.path)}`]),
+  "relationships:", ...relationships.flatMap(edge => { const entries = fields(edge, "    "); return [`  - ${entries[0]!.slice(4)}`, ...entries.slice(1)]; }), "",
+].join("\n");
+
+/** Deterministically project profiles, detector manifests, conventions, and direct graph edges into small registries. */
+export async function renderProfileRegistries(root = resolve(import.meta.dir, "..")): Promise<Map<string, string>> {
+  const conventions = await conventionIndex(root);
+  const graph = Bun.YAML.parse(await readFile(join(root, "relationships.yaml"), "utf8")) as Graph;
+  if (!Array.isArray(graph.edges)) throw new Error("relationships.yaml has no edges list");
+  const rendered = new Map<string, string>();
+  for (const profile of concreteProfiles) {
+    const implementations = sorted(profileImplementations[profile]);
+    const declared = await Promise.all(implementations.map(implementation => declaredRuleIds(implementation, join(root, "detectors"))));
+    const ruleIds = sorted(new Set(declared.flatMap(ids => [...ids])));
+    const missing = ruleIds.filter(id => !conventions.has(id));
+    if (missing.length) throw new Error(`${profile} declares rule IDs without exactly one convention: ${missing.join(", ")}`);
+    const rules = new Set(ruleIds);
+    const relationships = sorted(graph.edges.filter(edge => rules.has(edge.source_ref) || rules.has(edge.target_ref)), (left, right) => relationshipKey(left).localeCompare(relationshipKey(right)));
+    rendered.set(`${PROFILE_REGISTRY_DIR}/${profile}.yaml`, render(profile, implementations, ruleIds.map(id => conventions.get(id)!), relationships));
+  }
+  return rendered;
+}
+
+/** Write or check the shipped profile registries. `check` reports every stale or unexpected generated file. */
+export async function profileRegistries(options: { root?: string; check?: boolean } = {}) {
+  const root = resolve(options.root ?? resolve(import.meta.dir, "..")), expected = await renderProfileRegistries(root), directory = join(root, PROFILE_REGISTRY_DIR);
+  const actual = existsSync(directory) ? sorted((await readdir(directory)).filter(name => name.endsWith(".yaml")).map(name => `${PROFILE_REGISTRY_DIR}/${name}`)) : [];
+  const files: string[] = [];
+  for (const path of sorted(new Set([...expected.keys(), ...actual]))) if (!expected.has(path) || !existsSync(join(root, path)) || (await readFile(join(root, path), "utf8")) !== expected.get(path)) files.push(path);
+  if (options.check) return { ok: !files.length, message: files.length ? `profile registries have drifted: ${files.join(", ")}; run: atdd-bun profiles registry` : "profile registries are current", files };
+  await mkdir(directory, { recursive: true });
+  for (const path of actual.filter(path => !expected.has(path))) await rm(join(root, path));
+  for (const [path, content] of expected) await writeFile(join(root, path), content);
+  return { ok: true, message: `wrote ${expected.size} profile registries`, files: sorted(expected.keys()) };
+}