@sdd-method/author-cli 0.7.0 → 0.9.0

package/dist/lib/scaffold/domain.js

@@ -1,12 +1,13 @@
 import { access, copyFile, mkdir, readdir, writeFile } from "node:fs/promises";
+import { BEHAVIOUR_FILE, seedArchetypeBehaviour } from "./archetype-behaviour.js";
 import { dirname, join, relative } from "node:path";
 /**
- * Domain scaffolding (ADR 0173). Writes the invariant domain shape into a
+ * Domain scaffolding (M-ADR 0173). Writes the invariant domain shape into a
  * platform-root SDD, optionally seeded from a domain archetype. The generic
  * shape is method-owned and domain-agnostic; archetypes overlay starter content.
  *
  * Only the `integration` archetype is built in (the method tier — the method
- * owns that vocabulary via ADR 0171/0172). Reference-architecture and adopter
+ * owns that vocabulary via M-ADR 0171/0172). Reference-architecture and adopter
  * archetypes are resolved from a consumed registry (not in this prototype).
  */
 export const METHOD_DOMAIN_ARCHETYPES = ["integration"];
@@ -25,7 +26,7 @@ export async function scaffoldDomain(input) {
             return;
         await write(rel, content);
     };
-    // Registry archetype (ADR 0176 §4.4): copy seed files from the bundle
+    // Registry archetype (M-ADR 0176 §4.4): copy seed files from the bundle
     // cache FIRST — copy-and-own; the generic shape then fills only the
     // gaps the seed didn't provide.
     if (input.registryArchetype) {
@@ -34,6 +35,21 @@ export async function scaffoldDomain(input) {
             filesWritten.push(join("docs", "domains", input.name, rel));
         }
     }
+    // The archetype's behaviour is seeded once into the behaviour store, as a change to agree, and cited from
+    // then on (archetype-behaviour.ts); the rows themselves are never copied into the domain.
+    let behaviourSkipped;
+    if (input.registryArchetype) {
+        const seeded = await seedArchetypeBehaviour({
+            targetRepo: input.targetRepo,
+            domain: input.name,
+            archetypeId: input.registryArchetype.id,
+            bundleName: input.registryArchetype.bundleName,
+            bundleCacheDir: input.registryArchetype.bundleCacheDir,
+            seeds: input.registryArchetype.seeds,
+        });
+        filesWritten.push(...seeded.filesWritten);
+        behaviourSkipped = seeded.skipped;
+    }
     await writeIfMissing("README.md", renderDomainReadme(input));
     await writeIfMissing("architecture/glossary.md", renderDomainGlossary(input));
     await writeIfMissing("architecture/data-model.mermaid.md", renderDomainDataModel(input));
@@ -48,7 +64,7 @@ export async function scaffoldDomain(input) {
     if (input.archetype === "integration") {
         await write("architecture/interaction-patterns.md", renderIntegrationArchetype());
     }
-    return { filesWritten };
+    return { filesWritten, ...(behaviourSkipped ? { behaviourSkipped } : {}) };
 }
 /**
  * Copy a registry archetype's seed files from the bundle cache into the
@@ -63,6 +79,8 @@ async function copyRegistrySeeds(archetype, domainDir) {
         const files = await walkFiles(seedRoot);
         for (const abs of files) {
             const rel = relative(seedRoot, abs);
+            if (rel === BEHAVIOUR_FILE)
+                continue; // seeded into the behaviour store and cited, never copied
             const dst = join(domainDir, rel);
             await mkdir(dirname(dst), { recursive: true });
             await copyFile(abs, dst);
@@ -113,7 +131,7 @@ function titleize(slug) {
 function renderDomainReadme(input) {
     const title = titleize(input.name);
     const intro = input.archetype === "integration"
-        ? "Provider-specific integrations that bridge external systems to the platform via canonical contracts. Each integration is a separate `integration-product` SDD that registers into this domain (ADR 0136)."
+        ? "Provider-specific integrations that bridge external systems to the platform via canonical contracts. Each integration is a separate `integration-product` SDD that registers into this domain (M-ADR 0136)."
         : `TODO: one-paragraph description of the ${title} domain — the capability slice it owns and its boundary.`;
     return ([
         `# ${title} Domain`,
@@ -179,7 +197,7 @@ function renderDomainDataModel(input) {
     return ([
         `# ${title} Domain — Data Model`,
         "",
-        "> Entity-relationship diagram for this domain (ADR 0142 — first-class catalogue entity).",
+        "> Entity-relationship diagram for this domain (M-ADR 0142 — first-class catalogue entity).",
         "",
         "```mermaid",
         "erDiagram",

package/dist/lib/scaffold/registry.js

@@ -122,7 +122,7 @@ export async function resolveArchetype(targetRepo, reference) {
             ok: false,
             available,
             error: available.length === 0
-                ? `No archetype registries found in ${BUNDLE_CACHE_REL}/ — sync an archetype-bearing bundle first (ADR 0176).`
+                ? `No archetype registries found in ${BUNDLE_CACHE_REL}/ — sync an archetype-bearing bundle first (M-ADR 0176).`
                 : `Archetype '${reference}' not found in cached registries. Available: ${known}`,
         };
     }

package/dist/lib/sync/briefing-merge.js

@@ -1,5 +1,5 @@
 /**
- * Briefing-layer sync per ADR 0148.
+ * Briefing-layer sync per M-ADR 0148.
  *
  * Two files participate, with different semantics:
  *
@@ -17,7 +17,7 @@
  *
  * Both files are rendered from templates that ship in the bundle at
  * `<target>/orchestration/templates/briefing/...`. Older bundles
- * pre-dating ADR 0148 won't carry the templates; this module skips
+ * pre-dating M-ADR 0148 won't carry the templates; this module skips
  * gracefully with a log line in that case.
  */
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";

package/dist/lib/sync/bundle-cache.js

@@ -1,7 +1,7 @@
 import { appendFile, copyFile, mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 /**
- * Consumer-side bundle cache (ADR 0176 §4.2).
+ * Consumer-side bundle cache (M-ADR 0176 §4.2).
  *
  * Every consumed non-forward-base bundle is extracted to
  * `<targetRepo>/.sdd/bundle-cache/<bundleName>@<version>/` — the
@@ -15,7 +15,7 @@ import { dirname, join } from "node:path";
  */
 export const BUNDLE_CACHE_REL = ".sdd/bundle-cache";
 /**
- * The registry file name (ADR 0176 §4.1) — always cache-only. A bundle may
+ * The registry file name (M-ADR 0176 §4.1) — always cache-only. A bundle may
  * ship its registry at the payload root or nested (a multi-bundle producer
  * repo keeps one registry per bundle subtree, e.g. a vertical overlay's
  * `verticals/fleet/registry.yaml`, because the producer-layout rule forbids
@@ -33,7 +33,7 @@ export const REGISTRY_FILE = "registry.yaml";
 export const VOCAB_FILE = "application-archetypes.yaml";
 /**
  * Split a bundle's managed paths into the set to materialise into the
- * repo tree vs the set that stays cache-only (ADR 0176 §4.3):
+ * repo tree vs the set that stays cache-only (M-ADR 0176 §4.3):
  * scaffold-source-prefixed paths, registry files, and the archetype
  * vocabulary file are cache-only.
  */
@@ -103,7 +103,7 @@ export async function ensureCacheGitignored(targetRepo) {
         return false;
     }
     const prefixNewline = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-    await appendFile(giPath, `${prefixNewline}# sdd-cli bundle cache (ADR 0176) — extracted bundle payloads, not source\n${line}\n`);
+    await appendFile(giPath, `${prefixNewline}# sdd-cli bundle cache (M-ADR 0176) — extracted bundle payloads, not source\n${line}\n`);
     return true;
 }
 //# sourceMappingURL=bundle-cache.js.map

package/dist/lib/sync/yaml-block-merge.js

@@ -4,7 +4,7 @@
  * (including content above a lone trailing block, or below it, or
  * both) is preserved verbatim.
  *
- * Conflict model (per ADR 0114, narrowed to block scope):
+ * Conflict model (per M-ADR 0114, narrowed to block scope):
  *  - If the existing file has no markers, treat it as adopter-authored.
  *    Refuse to replace unless `allowOverwrite` is true.
  *  - If the existing file has markers, upsert the block. Lines outside

package/dist/lib/validate/archetype-citations.js

@@ -0,0 +1,169 @@
+// archetype-citations: an estate's citations of reference-architecture archetype behaviour still say what is true
+// (seed once, then cite; scaffold/archetype-behaviour.ts writes them).
+//
+// For each docs/domains/<domain>/archetype-citations.yaml, each citation is resolved against the archetype's
+// behaviour rows in the bundle the estate has cached (its locked version):
+//   unresolved  the citations name no cached bundle or archetype, the cited requirement is gone from the
+//               archetype, the relation is not one of the four, a departure has no reason or decision, or the
+//               estate requirement it names exists in neither the living specs nor an open change;
+//   stale       a derived, extended or narrowed citation whose archetype requirement no longer has the digest
+//               recorded: the archetype changed since the estate took or re-aligned it. Review it and re-pin
+//               (move `digest` and `version`), or record that the estate departs.
+// A departed citation is never stale: departing is a decision, recorded with its reason, not drift. With no
+// citations anywhere the check reports [N/A], an empty population, not a pass.
+//
+// A digest must be a quoted string: YAML reads an unquoted all-digit value, or digits around one `e`, as a
+// number, which would compare as a false stale. A narrowed or extended citation may say why in `reason`
+// (`note` is read as the same). `not_adopted` records archetype requirements the estate has decided not to
+// take, each with its reason and decision; every id must resolve, and none may be both cited and not adopted.
+// A coverage line names the archetype requirements neither cited nor recorded as not adopted: the gaps, which
+// are reported, not failed, since an estate may be part-way through adopting.
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { cachedVersion, CITATIONS_FILE, loadArchetypeBehaviour, RELATIONS } from "../scaffold/archetype-behaviour.js";
+import { discoverArchetypes } from "../scaffold/registry.js";
+const REQ_RE = /^###\s+Requirement:\s*(.+?)\s*$/gm;
+async function list(dir) {
+    try {
+        return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/** Every requirement title in the living specs and in open changes (a seeded change not yet archived counts). */
+async function estateRequirements(repo) {
+    const titles = new Set();
+    const specFiles = [];
+    for (const d of await list(join(repo, "openspec", "specs")))
+        specFiles.push(join(repo, "openspec", "specs", d, "spec.md"));
+    for (const c of await list(join(repo, "openspec", "changes"))) {
+        if (c === "archive")
+            continue;
+        for (const d of await list(join(repo, "openspec", "changes", c, "specs"))) {
+            specFiles.push(join(repo, "openspec", "changes", c, "specs", d, "spec.md"));
+        }
+    }
+    for (const f of specFiles) {
+        let text;
+        try {
+            text = await readFile(f, "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const m of text.matchAll(REQ_RE))
+            titles.add(m[1]);
+    }
+    return titles;
+}
+export async function checkArchetypeCitations(repo) {
+    const domains = await list(join(repo, "docs", "domains"));
+    const files = [];
+    for (const d of domains) {
+        const p = join(repo, "docs", "domains", d, CITATIONS_FILE);
+        try {
+            files.push([`docs/domains/${d}/${CITATIONS_FILE}`, await readFile(p, "utf8")]);
+        }
+        catch {
+            // no citations for this domain
+        }
+    }
+    if (files.length === 0)
+        return { exitCode: 0, stdout: "[N/A] no archetype citations (docs/domains/*/archetype-citations.yaml) in this repository\n" };
+    const archetypes = await discoverArchetypes(repo);
+    const titles = await estateRequirements(repo);
+    const lines = [];
+    let problems = 0;
+    let total = 0;
+    const bad = (tag, msg) => {
+        lines.push(`[${tag}] ${msg}`);
+        problems++;
+    };
+    for (const [rel, text] of files) {
+        let doc;
+        try {
+            doc = (parseYaml(text) ?? {});
+        }
+        catch (e) {
+            bad("unresolved", `${rel}: does not parse: ${e.message.split("\n")[0]}`);
+            continue;
+        }
+        const archetype = archetypes.find((a) => a.id === doc.archetype && a.bundleName === doc.bundle);
+        if (!archetype) {
+            bad("unresolved", `${rel}: archetype ${String(doc.archetype)} of bundle ${String(doc.bundle)} is not in the bundle cache (sync the bundle)`);
+            continue;
+        }
+        const reqs = await loadArchetypeBehaviour(archetype.bundleCacheDir, archetype.seeds);
+        const byId = new Map((reqs ?? []).map((r) => [r.id, r]));
+        const at = cachedVersion(archetype.bundleCacheDir) ?? "the cached bundle";
+        const cites = Array.isArray(doc.citations) ? doc.citations : [];
+        const notAdopted = Array.isArray(doc.not_adopted) ? doc.not_adopted : [];
+        if (cites.length === 0 && notAdopted.length === 0)
+            bad("unresolved", `${rel}: lists no citations`);
+        const citedIds = new Set(cites.map((c) => String(c.cites)));
+        for (const n of notAdopted) {
+            total++;
+            const tag = `${rel}: not adopted ${String(n.cites)}`;
+            if (!byId.has(String(n.cites))) {
+                bad("unresolved", `${tag}: ${archetype.bundleName} ${at} has no archetype requirement ${String(n.cites)}`);
+            }
+            else if (!n.reason || !n.decision) {
+                bad("unresolved", `${tag}: a non-adoption needs its reason and the decision that took it`);
+            }
+            else if (citedIds.has(String(n.cites))) {
+                bad("unresolved", `${tag}: it is also cited; an archetype requirement is either answered or not adopted`);
+            }
+            else {
+                lines.push(`[ok] ${tag} (${String(n.reason)})`);
+            }
+        }
+        for (const c of cites) {
+            total++;
+            const tag = `${rel}: '${String(c.requirement)}' -> ${String(c.cites)}`;
+            const relation = String(c.relation);
+            if (typeof c.digest !== "string") {
+                bad("unresolved", `${tag}: digest must be a quoted string (YAML read ${String(c.digest)} as a ${typeof c.digest}); quote it`);
+                continue;
+            }
+            if (!RELATIONS.includes(relation)) {
+                bad("unresolved", `${tag}: relation must be one of ${RELATIONS.join(", ")} (got ${relation})`);
+                continue;
+            }
+            if (relation === "departed" && (!c.reason || !c.decision)) {
+                bad("unresolved", `${tag}: a departure needs its reason and the decision that took it`);
+                continue;
+            }
+            if (relation !== "departed" && !titles.has(String(c.requirement))) {
+                bad("unresolved", `${tag}: this estate has no requirement titled so (living specs or open changes)`);
+                continue;
+            }
+            const src = byId.get(String(c.cites));
+            if (!src) {
+                bad("unresolved", `${tag}: ${archetype.bundleName} ${at} has no archetype requirement ${String(c.cites)}`);
+                continue;
+            }
+            if (relation === "departed") {
+                lines.push(`[ok] ${tag} (departed: ${String(c.reason)})`);
+            }
+            else if (src.digest !== String(c.digest)) {
+                bad("stale", `${tag}: the archetype requirement changed (${String(c.digest)} at ${String(doc.version)} -> ${src.digest} at ${at}); review it and re-pin, or record a departure`);
+            }
+            else {
+                const why = c.reason ?? c.note;
+                lines.push(`[ok] ${tag} (${relation}${why && relation !== "derived" ? `: ${String(why)}` : ""})`);
+            }
+        }
+        const answered = new Set([...citedIds, ...notAdopted.map((n) => String(n.cites))]);
+        const gaps = [...byId.keys()].filter((id) => !answered.has(id));
+        lines.push(`[coverage] ${rel}: ${byId.size - gaps.length} of ${byId.size} ${archetype.id} requirements answered ` +
+            `(${[...citedIds].filter((id) => byId.has(id)).length} cited, ${notAdopted.length} not adopted)` +
+            (gaps.length ? `; not yet answered: ${gaps.join(", ")}` : ""));
+    }
+    const verdict = problems
+        ? `[FAIL] archetype citations: ${problems} of ${total} unresolved or stale`
+        : `[PASS] archetype citations: ${total} resolve, none stale`;
+    return { exitCode: problems ? 1 : 0, stdout: lines.join("\n") + "\n" + verdict + "\n" };
+}
+//# sourceMappingURL=archetype-citations.js.map

package/dist/lib/validate/behaviour-store.js

@@ -20,6 +20,16 @@
 //                 never against itself (M-ADR 0222 §4.3, §4.4). A list the catalogue gives nothing to
 //                 check against (no Observed in line, or a repository with no catalogue contracts) fails:
 //                 a cross-check of zero contracts is unresolved, not a pass.
+//   7. features: every living spec is keyed by a catalogue feature (M-ADR 0221 §4.7). A spec keyed by no
+//                 feature is dropped from the catalogue by the requirements builder, which reports it only as a
+//                 build finding; this check makes it a failure, so a shipped requirement cannot vanish from the
+//                 catalogue with every check green. Without catalogues/features.csv the check is unresolved, not
+//                 passed.
+//   8. overlap:  no requirement of a living spec is named by two open, agreed changes, whether added,
+//                 modified, removed or renamed (M-ADR 0223 §4.10). Proposals may overlap.
+//   9. schema:   the store's config.yaml selects the method's sdd-change schema, and the store's copy of it
+//                 (openspec/schemas/sdd-change/) is identical to the one the SDD's bundle shipped
+//                 (docs/method/foundations/openspec/sdd-change/). Sync refreshes the copy (M-ADR 0223 §4.2).
 //   6. scope:    a baseline ADDS requirements; it REMOVES, MODIFIES or RENAMES only a requirement whose
 //                 latest archived change was a baseline, which is how a corrective baseline withdraws
 //                 what a baseline admitted wrongly. A requirement a judged change shipped is changed only
@@ -29,14 +39,18 @@
 //
 // OPENSPEC'S OWN VALIDATION is the separate validator `behaviour-store-openspec`, because it needs
 // the OpenSpec CLI at OPENSPEC_VERSION (the Method Validation module installs it). Without a store
-// both report [N/A], an empty population, never a pass.
+// both report [N/A], an empty population, never a pass. It also archives each open, agreed change in a
+// scratch copy of the store and validates the specs it would leave (M-ADR 0223 §4.5): a change's own
+// --strict run exempts its MODIFIED requirements from the 500-character limit the specs are held to.
 import { execFile } from "node:child_process";
-import { access, readdir, readFile } from "node:fs/promises";
+import { access, cp, mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { promisify } from "node:util";
 import { parseDocument } from "yaml";
 import { observedIn, orderArchives, parseRequirements, parseSurfaces, renamedFrom, surfaceMatches } from "../behaviour-store/archive.js";
 import { parseCatalogueCsv } from "../catalogue/csv-reader.js";
+import { compareStoreSchema, SCHEMA_NAME, SHIPPED_SCHEMA_DIR, STORE_CONFIG, STORE_SCHEMA_DIR, storeSchemaName } from "../behaviour-store/schema.js";
 const execFileAsync = promisify(execFile);
 /** The OpenSpec release the method depends on (M-ADR 0223 ruling 2). The module installs exactly this. */
 export const OPENSPEC_VERSION = "1.14.3";
@@ -236,7 +250,9 @@ export async function checkBehaviourStore(repo) {
         const record = records.get(change);
         if (tasks !== null && TASK_DONE_RE.test(tasks)) {
             started++;
-            if (!record)
+            if (!record && recordFiles.some((f) => f.replace(/\.ya?ml$/, "") === change))
+                failures.push(`${dir}: has completed tasks but its agreement record (${AGREEMENTS_DIR}/${change}.yaml) is malformed; see its record failures`);
+            else if (!record)
                 failures.push(`${dir}: has completed tasks but no agreement record (${AGREEMENTS_DIR}/${change}.yaml)`);
             else if (record.status !== "agreed")
                 failures.push(`${dir}: has completed tasks but its agreement record is ${record.status}, not agreed`);
@@ -259,6 +275,29 @@ export async function checkBehaviourStore(repo) {
     }
     lines.push(`agreement: ${open.length} open change(s), ${started} with completed tasks`);
     lines.push(staleChecked === 0 ? "stale: vacuous (no open agreed change modifies, removes or renames a requirement)" : `stale: ${staleChecked} targeted living spec(s) checked against their agreed commits`);
+    // 8. overlap: two open, agreed changes never name the same requirement of one living spec (M-ADR 0223 §4.10).
+    // A name counts whether the delta adds, modifies, removes or renames it (both FROM and TO). Proposals may overlap.
+    const claimed = new Map();
+    let agreedOpen = 0;
+    for (const change of open) {
+        if (records.get(change)?.status !== "agreed")
+            continue;
+        agreedOpen++;
+        const specsDir = join(repo, STORE_DIR, "changes", change, "specs");
+        for (const spec of await dirs(specsDir)) {
+            const text = (await readText(join(specsDir, spec, "spec.md"))) ?? "";
+            const names = new Set([...parseRequirements(text).filter((r) => r.operation).map((r) => r.name), ...renamedFrom(text)]);
+            for (const name of names) {
+                const key = `${spec}::${name}`;
+                const other = claimed.get(key);
+                if (other)
+                    failures.push(`${STORE_DIR}/changes/${change}: OVERLAP: requirement "${name}" of ${spec} is also named by agreed change ${other}; one waits for the other to archive, or the two become one change (M-ADR 0223 §4.10)`);
+                else
+                    claimed.set(key, change);
+            }
+        }
+    }
+    lines.push(agreedOpen < 2 ? `overlap: vacuous (${agreedOpen} open agreed change)` : `overlap: ${claimed.size} requirement name(s) across ${agreedOpen} open agreed changes`);
     // 4. archived changes
     const archived = await dirs(join(repo, STORE_DIR, "changes", "archive"));
     let baselines = 0;
@@ -285,7 +324,31 @@ export async function checkBehaviourStore(repo) {
     lines.push(`verdicts: ${archived.length} archived change(s), ${baselines} baseline(s), ${archived.length - baselines} needing a PASS verdict`);
     // 5. surfaces, and 6. what each baseline may change, in archive order
     const archiveRel = `${STORE_DIR}/changes/archive`;
-    const { order, ties } = await orderArchives(repo, archiveRel, archived);
+    const { order, ties, history } = await orderArchives(repo, archiveRel, archived);
+    // Same-day archives the history cannot order sit in one group. A scope verdict that a group peer could reverse
+    // (it touches the same requirement) depends on an order nobody knows, so it is unresolved, not a violation. Without
+    // git history (a worktree upload, a plain copy, an export) every same-day pair is such a group.
+    const peers = new Map();
+    for (const [a, b] of ties) {
+        const group = peers.get(a) ?? peers.get(b) ?? new Set();
+        group.add(a).add(b);
+        peers.set(a, group).set(b, group);
+    }
+    const touches = new Map();
+    for (const name of peers.keys()) {
+        const keys = new Set();
+        for (const feature of await dirs(join(repo, archiveRel, name, "specs"))) {
+            const text = (await readText(join(repo, archiveRel, name, "specs", feature, "spec.md"))) ?? "";
+            for (const r of parseRequirements(text))
+                if (r.operation)
+                    keys.add(`${feature}::${r.name}`);
+            for (const from of renamedFrom(text))
+                keys.add(`${feature}::${from}`);
+        }
+        touches.set(name, keys);
+    }
+    const orderDecides = (name, key) => [...(peers.get(name) ?? [])].some((p) => p !== name && touches.get(p)?.has(key));
+    let scopeUnresolved = 0;
     const servedBy = baselines > 0 ? await catalogueContracts(repo) : null;
     let surfacesChecked = 0;
     const lastTouch = new Map();
@@ -333,7 +396,11 @@ export async function checkBehaviourStore(repo) {
                 if (isBaseline) {
                     scopeChecked++;
                     const last = lastTouch.get(key);
-                    if (last !== "baseline") {
+                    if (last !== "baseline" && orderDecides(name, key)) {
+                        scopeUnresolved++;
+                        failures.push(`${dir}: scope unresolved for "${t}" (${feature}): the verdict depends on the order of same-day archives the history cannot give${history ? "" : " (no git history here: run from a clone)"}`);
+                    }
+                    else if (last !== "baseline") {
                         failures.push(`${dir}: a baseline changes "${t}" (${feature}), which ${last === "change" ? "a judged change last shipped" : "no earlier archived change admitted"}; a baseline may remove or modify only what a baseline admitted, and anything else takes a change (M-ADR 0222 §4.4)`);
                     }
                 }
@@ -352,8 +419,55 @@ export async function checkBehaviourStore(repo) {
     const unseen = servedBy === null ? "" : `; repositories with no catalogue contracts: ${[...new Set(await observedInAll(repo, archiveRel, order))].filter((r) => (servedBy.get(r) ?? []).length === 0).join(", ") || "none"}`;
     lines.push(baselines === 0 ? "surfaces: vacuous (no baseline)" : `surfaces: ${baselines} baseline(s), ${surfacesChecked} served contract(s) checked against catalogues/repo_contract.csv${unseen}`);
     lines.push(scopeChecked === 0 ? "scope: vacuous (no baseline removes, modifies or renames a requirement)" : `scope: ${scopeChecked} requirement(s) a baseline removes, modifies or renames, checked against their lineage`);
+    if (!history && archived.length > 0)
+        lines.push("order: no git history (not a git work tree, or git log failed), so same-day archives cannot be ordered");
+    if (scopeUnresolved > 0)
+        lines.push(`scope: ${scopeUnresolved} verdict(s) unresolved, depending on an order the history cannot give`);
     for (const [a, b] of ties)
         lines.push(`order: ${a} and ${b} were archived the same day and the history does not order them; ordered by name`);
+    // 7. living specs keyed by a catalogue feature
+    const livingSpecs = await dirs(join(repo, STORE_DIR, "specs"));
+    if (livingSpecs.length > 0) {
+        const featuresCsv = await readText(join(repo, "catalogues", "features.csv"));
+        if (featuresCsv === null) {
+            failures.push(`${STORE_DIR}/specs: living specs cannot be checked against catalogue features: catalogues/features.csv is missing; build the catalogue`);
+        }
+        else {
+            const featureIds = new Set(parseCatalogueCsv(featuresCsv).rows.map((r) => r["id"] ?? ""));
+            const unkeyed = livingSpecs.filter((f) => !featureIds.has(f));
+            for (const f of unkeyed) {
+                failures.push(`${STORE_DIR}/specs/${f}: no catalogue feature has the id "${f}", so its requirements are not catalogued; give the behaviour a feature first (M-ADR 0222 §4.4)`);
+            }
+            lines.push(`features: ${livingSpecs.length} living spec(s), ${livingSpecs.length - unkeyed.length} keyed by a catalogue feature`);
+        }
+    }
+    else {
+        lines.push("features: vacuous (no living spec)");
+    }
+    // 9. schema: the store uses the method's sdd-change schema, and its copy is the one the SDD's bundle
+    // shipped (M-ADR 0223 §4.2). OpenSpec reads the copy, so an edited or stale copy changes what every
+    // change is asked for, with nothing else noticing.
+    const selected = await storeSchemaName(repo);
+    if (selected !== SCHEMA_NAME) {
+        failures.push(`${STORE_CONFIG}: ${selected === null ? "missing" : selected === "" ? "names no schema" : `selects schema "${selected}"`}; a behaviour store uses the method's ${SCHEMA_NAME} schema (M-ADR 0223 §4.2)`);
+    }
+    else {
+        const c = await compareStoreSchema(repo);
+        if (!c.shipped) {
+            failures.push(`schema unresolved: this SDD holds no shipped ${SCHEMA_NAME} schema (${SHIPPED_SCHEMA_DIR}/); sync a method bundle that carries it`);
+        }
+        else {
+            const fix = "sdd-cli sync refreshes it; put adopter guidance in the store's config.yaml rules, not in the schema";
+            for (const f of c.missing)
+                failures.push(`${STORE_SCHEMA_DIR}/${f}: missing from the store's copy of the schema; ${fix}`);
+            for (const f of c.differing)
+                failures.push(`${STORE_SCHEMA_DIR}/${f}: differs from the shipped ${SHIPPED_SCHEMA_DIR}/${f}; ${fix}`);
+            for (const f of c.extra)
+                failures.push(`${STORE_SCHEMA_DIR}/${f}: not in the shipped schema; ${fix}`);
+            const drift = c.missing.length + c.differing.length + c.extra.length;
+            lines.push(drift === 0 ? `schema: ${SCHEMA_NAME}, identical to the shipped copy` : `schema: ${SCHEMA_NAME}, ${drift} file(s) differ from the shipped copy`);
+        }
+    }
     const population = recordFiles.length + open.length + archived.length;
     const body = lines.map((l) => `  ${l}`).join("\n") + "\n";
     if (failures.length > 0) {
@@ -361,7 +475,7 @@ export async function checkBehaviourStore(repo) {
     }
     if (population === 0)
         return { exitCode: 0, stdout: body + `[N/A] the behaviour store has no changes and no agreement records yet\n` };
-    return { exitCode: 0, stdout: body + "[PASS] behaviour store: records, agreement, stale, verdict, surfaces and scope checks hold\n" };
+    return { exitCode: 0, stdout: body + "[PASS] behaviour store: records, agreement, stale, overlap, verdict, surfaces, scope, feature and schema checks hold\n" };
 }
 /** Per repository, the contracts the catalogue says it serves (repo_contract ⋈ contracts.spec_path); null when either file is missing. */
 async function catalogueContracts(repo) {
@@ -452,6 +566,47 @@ export async function checkBehaviourStoreOpenspec(repo) {
         if (r.code !== 0 && (t.failed ?? 0) === 0)
             failures.push(`${label}: OpenSpec exited ${r.code} with no failed item reported`);
     }
+    // Each open, agreed change, archived in a scratch copy: the specs it would leave must validate --strict.
+    let dryArchived = 0;
+    for (const change of (await dirs(join(repo, STORE_DIR, "changes"))).filter((d) => d !== "archive")) {
+        const rel = `${AGREEMENTS_DIR}/${change}.yaml`;
+        const text = await readText(join(repo, rel));
+        if (text === null || parseAgreementRecord(rel, text).record?.status !== "agreed")
+            continue;
+        const scratch = await mkdtemp(join(tmpdir(), "sdd-dry-archive-"));
+        try {
+            await cp(join(repo, STORE_DIR), join(scratch, STORE_DIR), { recursive: true });
+            const label = `specs after archiving ${change} (dry, in a copy)`;
+            const a = await runOpenspec(scratch, ["archive", change, "--yes", "--json"]);
+            if (a.code !== 0) {
+                const said = [...a.raw.matchAll(/"(?:message|error)":\s*"((?:[^"\\]|\\.)*)"/g)].map((m) => m[1]);
+                failures.push(`${label}: the change does not archive (exit ${a.code}): ${said.length > 0 ? said.join("; ") : a.raw.trim().split("\n").slice(-3).join(" | ")}`);
+                continue;
+            }
+            dryArchived++;
+            const v = await runOpenspec(scratch, ["validate", "--specs", "--strict", "--json", "--no-interactive"]);
+            const t = v.json?.summary?.totals;
+            if (!t) {
+                failures.push(`${label}: OpenSpec returned no report (exit ${v.code}): ${v.raw.trim().split("\n").slice(-3).join(" | ")}`);
+                continue;
+            }
+            lines.push(`${label}: ${t.items ?? 0} spec(s), ${t.passed ?? 0} passed, ${t.failed ?? 0} failed`);
+            for (const item of v.json?.items ?? []) {
+                if (item.valid)
+                    continue;
+                for (const i of item.issues ?? [])
+                    failures.push(`${label}: ${item.id}${i.path ? ` (${i.path})` : ""}: ${i.level} ${i.message}`);
+                if ((item.issues ?? []).length === 0)
+                    failures.push(`${label}: ${item.id}: invalid`);
+            }
+            if (v.code !== 0 && (t.failed ?? 0) === 0)
+                failures.push(`${label}: OpenSpec exited ${v.code} with no failed spec reported`);
+        }
+        finally {
+            await rm(scratch, { recursive: true, force: true });
+        }
+    }
+    lines.push(`dry archive: ${dryArchived} open, agreed change(s) archived in a copy`);
     const body = [`  OpenSpec ${version}`, ...lines.map((l) => `  ${l}`)].join("\n") + "\n";
     if (failures.length > 0)
         return { exitCode: 1, stdout: body + failures.map((f) => `[FAIL] ${f}`).join("\n") + "\n" };

package/dist/lib/validate/dispatch.js

@@ -1,3 +1,4 @@
+import { checkArchetypeCitations } from "./archetype-citations.js";
 import { checkBehaviourStore, checkBehaviourStoreOpenspec } from "./behaviour-store.js";
 import { checkBundleCoherence } from "./bundle-coherence.js";
 import { checkYamlParse } from "./yaml-parse.js";
@@ -14,6 +15,12 @@ const BEHAVIOUR_STORE_VALIDATORS = [
         source: { kind: "native", run: async (ctx) => checkBehaviourStoreOpenspec(ctx.targetRepo) },
         build: () => ({ status: "run", args: [] }),
     },
+    // Seed once, then cite: requirements an estate took from a reference-architecture archetype still answer to it.
+    {
+        name: "archetype-citations",
+        source: { kind: "native", run: async (ctx) => checkArchetypeCitations(ctx.targetRepo) },
+        build: () => ({ status: "run", args: [] }),
+    },
 ];
 // Validators that accept --app-root / --repo-root flags work fine from the
 // bundled location because they override their internal ROOT_DIR via the
@@ -92,7 +99,7 @@ const APP_VALIDATORS = [
     ...BEHAVIOUR_STORE_VALIDATORS,
     // Note: validate-runway-classification is intentionally NOT in the app set.
     // It requires platform-level files (docs/platform/feature-tree.md,
-    // architecture-runway-index.md) that app repos don't own. Per ADR 0089,
+    // architecture-runway-index.md) that app repos don't own. Per M-ADR 0089,
     // the reduced app suite is app-specific validators + shared foundations,
     // not platform validators.
 ];

package/dist/maintain-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.8.0",
-  "built_against_sdd_cli": "2.2.0"
+  "version": "0.10.0",
+  "built_against_sdd_cli": "2.4.0"
 }

package/dist/verbs/conformance.js

@@ -4,16 +4,16 @@ export function registerConformance(program) {
     program
         .command("conformance")
         .description("Conformance-reverse: diff the declared surface (spec/binding/contract) against the observed " +
-        "surface (code) and report drift with PROVISIONAL verdicts (ADR 0180). Advisory by default — " +
+        "surface (code) and report drift with PROVISIONAL verdicts (M-ADR 0180). Advisory by default — " +
         "disposition (code-defect vs spec-stale vs divergence) is a triage step, not this verb's call. " +
         "Checks are derived from the spec-implementation binding (.sdd/implementation-binding.yaml, " +
-        "ADR 0181) when present; else .sdd/conformance-checks.yaml.")
+        "M-ADR 0181) when present; else .sdd/conformance-checks.yaml.")
         .option("--target-repo <dir>", "target SDD repo", resolvePathOption, process.cwd())
         .option("--config <path>", "explicit checks file (overrides the binding)")
         .option("--code-root <dir>", "checkout root for implementation member repos (resolves @code/ sources)", resolvePathOption)
         .option("--check <id>", "run only the named check")
         .option("--json", "machine-readable report (CI ingestion)")
-        .option("--reconcile", "for binding-vs-reality checks, emit the binding fragment regenerated from the observed-set (ADR 0181 §2.3)")
+        .option("--reconcile", "for binding-vs-reality checks, emit the binding fragment regenerated from the observed-set (M-ADR 0181 §2.3)")
         .option("--emit-finding <dir>", "write the conformance_finding catalogue CSV into <dir> (federates via aggregate)")
         .option("--strict", "exit non-zero when any check needs triage (default: advisory, exit 0)")
         .action(async (opts) => {

package/dist/verbs/list.js

@@ -7,7 +7,7 @@ const VALID_PROFILES = [
 export function registerList(program) {
     program
         .command("list")
-        .description("Enumerate SDD repositories discoverable in the current workspace, including adopter pack provenance (ADR 0151)")
+        .description("Enumerate SDD repositories discoverable in the current workspace, including adopter pack provenance (M-ADR 0151)")
         .option("--profile <profile>", "filter by profile: platform | application | integration")
         .option("--workspace-root <path>", "workspace directory to walk (repeatable; defaults to cwd)", collectRoots, [])
         .option("--format <format>", "output format: text | json", "text")

package/dist/verbs/render.js

@@ -10,7 +10,7 @@ export function registerRender(program) {
         .description("Render method artefacts to visual form");
     render
         .command("screen <file>")
-        .description("Render a screen-spec's openui-lang block to a structural wireframe SVG (ADR 0169). " +
+        .description("Render a screen-spec's openui-lang block to a structural wireframe SVG (M-ADR 0169). " +
         "Platform comes from the `platform:` frontmatter; an adopter overlay is read from " +
         ".sdd/screen-validation.yaml when present.")
         .option("--out <file>", "write the SVG to a file (default: stdout)")