@sdd-method/maintain-cli 0.8.0 → 0.9.0

package/dist/lib/scaffold/registry.js

@@ -0,0 +1,136 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { BUNDLE_CACHE_REL, REGISTRY_FILE } from "../sync/bundle-cache.js";
+/**
+ * Scan the bundle cache for registries and return every archetype found.
+ * Bundles without any registry.yaml are skipped silently (vendor packs
+ * etc.). A registry may sit at the bundle's payload root or nested
+ * (multi-bundle producer repos keep one registry per bundle subtree,
+ * e.g. a vertical overlay's `verticals/fleet/registry.yaml`) — all are
+ * read; seed paths stay payload-root-relative regardless of where the
+ * declaring registry sits.
+ */
+export async function discoverArchetypes(targetRepo) {
+    const cacheRoot = join(targetRepo, BUNDLE_CACHE_REL);
+    let entries;
+    try {
+        entries = await readdir(cacheRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const bundleCacheDir = join(cacheRoot, e.name);
+        const at = e.name.lastIndexOf("@");
+        const bundleName = at > 0 ? e.name.slice(0, at) : e.name;
+        for (const registryPath of await findRegistryFiles(bundleCacheDir)) {
+            let raw;
+            try {
+                raw = await readFile(registryPath, "utf8");
+            }
+            catch {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = parseYaml(raw);
+            }
+            catch {
+                continue; // malformed registry — skip rather than break scaffold
+            }
+            if (parsed === null || typeof parsed !== "object")
+                continue;
+            if (!Array.isArray(parsed.archetypes))
+                continue;
+            const tier = typeof parsed.tier === "string" ? parsed.tier : "unknown";
+            for (const a of parsed.archetypes) {
+                if (a === null || typeof a !== "object")
+                    continue;
+                const rec = a;
+                const id = typeof rec.id === "string" ? rec.id : undefined;
+                const seeds = Array.isArray(rec.seeds)
+                    ? rec.seeds.filter((s) => typeof s === "string")
+                    : [];
+                if (!id || seeds.length === 0)
+                    continue;
+                out.push({
+                    id,
+                    tier,
+                    seeds,
+                    bundleName,
+                    bundleCacheDir,
+                    ...(typeof rec.layer === "string" && { layer: rec.layer }),
+                    ...(typeof rec.domain_name === "string" && { domainName: rec.domain_name }),
+                    ...(typeof rec.status === "string" && { status: rec.status }),
+                    ...(typeof rec.notes === "string" && { notes: rec.notes }),
+                });
+            }
+        }
+    }
+    return out;
+}
+/** Depth cap for nested-registry discovery — bundle payloads are shallow. */
+const REGISTRY_SCAN_MAX_DEPTH = 4;
+/**
+ * Find every registry.yaml within a cached bundle (root + nested),
+ * depth-capped. Returns absolute paths in a stable (sorted) order.
+ */
+async function findRegistryFiles(dir, depth = 0) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (e.isFile() && e.name === REGISTRY_FILE) {
+            found.push(join(dir, e.name));
+        }
+        else if (e.isDirectory() && depth < REGISTRY_SCAN_MAX_DEPTH) {
+            found.push(...(await findRegistryFiles(join(dir, e.name), depth + 1)));
+        }
+    }
+    return found;
+}
+/**
+ * Resolve an archetype reference against the cache. Accepts bare ids
+ * (`core/identity`) and bundle-qualified ids
+ * (`ref-arch-core-b2b-saas:core/identity`).
+ */
+export async function resolveArchetype(targetRepo, reference) {
+    const available = await discoverArchetypes(targetRepo);
+    let bundleFilter;
+    let id = reference;
+    const colon = reference.indexOf(":");
+    if (colon > 0) {
+        bundleFilter = reference.slice(0, colon);
+        id = reference.slice(colon + 1);
+    }
+    const matches = available.filter((a) => a.id === id && (bundleFilter === undefined || a.bundleName === bundleFilter));
+    if (matches.length === 1) {
+        return { ok: true, archetype: matches[0], available };
+    }
+    if (matches.length === 0) {
+        const known = available.map((a) => `${a.bundleName}:${a.id}`).join(", ");
+        return {
+            ok: false,
+            available,
+            error: available.length === 0
+                ? `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}`,
+        };
+    }
+    const collisions = matches.map((a) => `${a.bundleName}:${a.id}`).join(", ");
+    return {
+        ok: false,
+        available,
+        error: `Archetype id '${id}' is declared by multiple bundles (${collisions}). Use the qualified form '<bundle>:<id>'.`,
+    };
+}
+//# sourceMappingURL=registry.js.map

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/index.js

@@ -75,7 +75,7 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             stdout(fail(`Missing payload file listed in MANAGED_PATHS.txt: ${missing[0]}`));
             return { exitCode: 1 };
         }
-        // ADR 0176 §4.3: split consumption modes. Scaffold-source paths and
+        // M-ADR 0176 §4.3: split consumption modes. Scaffold-source paths and
         // the registry file extract to the bundle cache only; everything
         // else materialises into the repo tree as before.
         const { materialise: materialisePaths, cacheOnly: cacheOnlyPaths } = splitConsumptionModes(bundle.managedPaths, bundle.manifest.scaffoldSourcePaths);
@@ -155,7 +155,7 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             }
         }
         // Additive bundles require a forward base already in the lock.
-        // For adopter packs (ADR 0151) the requires_forward_base field
+        // For adopter packs (M-ADR 0151) the requires_forward_base field
         // declares which sdd-method bundle (and minimum version) is needed.
         const incomingBundleName = bundle.manifest.bundleName;
         const incomingIsForward = bundle.manifest.isForwardBase;
@@ -184,7 +184,7 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             }
         }
         // Adopter pack requires_forward_base check: the named forward base
-        // must be in the lock at a compatible version. Per ADR 0151 §4.2.
+        // must be in the lock at a compatible version. Per M-ADR 0151 §4.2.
         if (!incomingIsForward && bundle.manifest.requiresForwardBase) {
             const err = checkRequiresForwardBase(prevLock, bundle.manifest.requiresForwardBase, incomingBundleName);
             if (err !== null) {
@@ -193,7 +193,7 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             }
         }
         // Adopter pack requires_pack check: vertical extensions name a base
-        // pack they depend on. Per ADR 0151 §4.3.
+        // pack they depend on. Per M-ADR 0151 §4.3.
         if (!incomingIsForward && bundle.manifest.requiresPack) {
             const err = checkRequiresPack(prevLock, bundle.manifest.requiresPack, incomingBundleName);
             if (err !== null) {
@@ -451,7 +451,7 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             for (const d of prunedDirs)
                 stdout(`  - ${d}/\n`);
         }
-        // ADR 0176 §4.2: cache non-forward-base bundles (the resolution
+        // M-ADR 0176 §4.2: cache non-forward-base bundles (the resolution
         // substrate for scaffold --archetype). Forward bases are not cached
         // — they carry no archetype registries and are large.
         if (!bundle.manifest.isForwardBase) {
@@ -488,7 +488,7 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             isForwardBase: incomingIsForward,
             managedPaths: [...bundle.managedPaths],
             pathDigests,
-            // Adopter-pack provenance per ADR 0151 — fields only present for
+            // Adopter-pack provenance per M-ADR 0151 — fields only present for
             // non-forward-base bundles produced by adopter pack builders.
             ...(bundle.manifest.producedByAdopter && {
                 producedByAdopter: bundle.manifest.producedByAdopter,
@@ -560,7 +560,7 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
         }
         for (const line of ci.log)
             stdout(info(line));
-        // Briefing layer per ADR 0148: agent-instructions.md (unconditional
+        // Briefing layer per M-ADR 0148: agent-instructions.md (unconditional
         // overwrite) + harness wrapper (marker-aware merge). Templates ship
         // in the bundle's orchestration/templates/briefing/; gracefully skip
         // when an older bundle without them is being synced.

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

@@ -9,7 +9,7 @@
  * SDD_REPO_PATH value. An adopter's other servers, and an `sdd-mcp` entry that runs anything
  * else, are left alone.
  *
- * Conflict handling mirrors ADR 0114: if the adopter has modified a method-owned hook, sync
+ * Conflict handling mirrors M-ADR 0114: if the adopter has modified a method-owned hook, sync
  * refuses unless `--allow-overwrite` is passed.
  */
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";

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,134 @@
+// 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.
+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 : [];
+        if (cites.length === 0)
+            bad("unresolved", `${rel}: lists no citations`);
+        for (const c of cites) {
+            total++;
+            const tag = `${rel}: '${String(c.requirement)}' -> ${String(c.cites)}`;
+            const relation = String(c.relation);
+            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 {
+                lines.push(`[ok] ${tag} (${relation})`);
+            }
+        }
+    }
+    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,11 @@
 //                 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.
 //   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
@@ -354,6 +359,25 @@ export async function checkBehaviourStore(repo) {
     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`);
     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)");
+    }
     const population = recordFiles.length + open.length + archived.length;
     const body = lines.map((l) => `  ${l}`).join("\n") + "\n";
     if (failures.length > 0) {
@@ -361,7 +385,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, verdict, surfaces, scope and feature 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) {

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-program.js

@@ -80,14 +80,14 @@ export function buildMaintainProgram() {
     registerContext(program);
     registerRender(program);
     const catalogue = program.commands.find((c) => c.name() === "catalogue");
-    catalogue.description("Build, aggregate, validate and query per-SDD catalogues (ADR 0134) — the derived model");
+    catalogue.description("Build, aggregate, validate and query per-SDD catalogues (M-ADR 0134) — the derived model");
     registerCatalogueBuild(catalogue);
     registerCatalogueCheck(catalogue);
     registerCatalogueAggregate(catalogue);
     registerCatalogueGraph(catalogue);
     registerCatalogueDiff(catalogue);
     const pack = program.commands.find((c) => c.name() === "pack");
-    pack.description("Build and validate adopter-shipped context-pack bundles (ADR 0151)");
+    pack.description("Build and validate adopter-shipped context-pack bundles (M-ADR 0151)");
     registerPackBuild(pack);
     return program;
 }

package/dist/maintain-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.8.0",
-  "built_against_sdd_cli": "2.2.0"
+  "version": "0.9.0",
+  "built_against_sdd_cli": "2.3.0"
 }

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/pack-build.js

@@ -11,8 +11,8 @@ export function registerPackBuild(pack) {
         .option("--producer-repo <dir>", "adopter repo root (managed_paths are resolved relative to this; defaults to cwd)", process.cwd())
         .option("--out-dir <dir>", "output directory for the tarball (defaults to <producer-repo>/dist/<pack-name>/)", resolvePathOption)
         .option("--forward-base-managed-paths <path>", "path to forward-base MANAGED_PATHS.txt for the leakage check (defaults to extracting from method-baseline.lock)")
-        .option("--publish-transform", "apply the point-in-time / producer-agnostic publish transform (ADR 0183/0184): drop non-Accepted ADRs, strip lineage + stripped-class fields, flatten cross-repo refs, fail closed on leaks. For producer-published bundles.")
-        .option("--origin-prefix", "with the publish transform, apply the range-aware origin prefix (ADR 0140 §4.1): 0NNN→M-ADR, 9NNN→RA-ADR, adopter 1NNN stays ADR; ADR files renamed to match. Implies --publish-transform. The RA-ADR bundle cutover switch.")
+        .option("--publish-transform", "apply the point-in-time / producer-agnostic publish transform (M-ADR 0183/0184): drop non-Accepted ADRs, strip lineage + stripped-class fields, flatten cross-repo refs, fail closed on leaks. For producer-published bundles.")
+        .option("--origin-prefix", "with the publish transform, apply the range-aware origin prefix (M-ADR 0140 §4.1): 0NNN→M-ADR, 9NNN→RA-ADR, adopter 1NNN stays ADR; ADR files renamed to match. Implies --publish-transform. The RA-ADR bundle cutover switch.")
         .option("--source-commit <sha>", "provenance from a release record: the commit the manifest records (with --source-branch, --source-repo and --generated-at)")
         .option("--source-branch <name>", "provenance from a release record: the branch the manifest records")
         .option("--source-repo <name>", "provenance from a release record: the repository name the manifest records, whatever the checkout is called")

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)")

package/dist/verify-program.js

@@ -109,11 +109,11 @@ export function registerVerifySurface(program) {
     registerList(program);
     const pack = program
         .command("pack")
-        .description("Validate adopter-shipped context-pack seeds (ADR 0151) — read-only");
+        .description("Validate adopter-shipped context-pack seeds (M-ADR 0151) — read-only");
     registerPackValidate(pack);
     const catalogue = program
         .command("catalogue")
-        .description("Validate and query per-SDD catalogues (ADR 0134) — read-only, never rebuilds");
+        .description("Validate and query per-SDD catalogues (M-ADR 0134) — read-only, never rebuilds");
     registerCatalogueValidate(catalogue);
     registerCatalogueImpact(catalogue);
     registerCatalogueBaselineCheck(catalogue);

package/dist/verify-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "2.2.0",
-  "built_against_sdd_cli": "2.2.0"
+  "version": "2.3.0",
+  "built_against_sdd_cli": "2.3.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sdd-method/maintain-cli",
-  "version": "0.8.0",
-  "sddCliVersion": "2.2.0",
+  "version": "0.9.0",
+  "sddCliVersion": "2.3.0",
   "description": "Bring an SDD repository current and rebuild its derived model — sync, briefing, catalogue build and aggregate, pack build, context pull — plus every read-only verify verb. Ships only the code those verbs reach; it cannot author specification content. Authoring is in @sdd-method/sdd-cli.",
   "license": "UNLICENSED",
   "type": "module",

package/scripts/validate-app-dependencies.sh

@@ -149,7 +149,7 @@ fi
 APP_DEPS_FILE="$APP_ROOT/app-platform-dependencies.yaml"
 
 # TWO AUTHORING SOURCES, NOT ONE.
-#   The catalogue builder does multi-source ingestion under the ADR 0157 parity
+#   The catalogue builder does multi-source ingestion under the M-ADR 0157 parity
 #   principle: `app-platform-dependencies.yaml` AND every
 #   `reverse-evidence/**/feature-grounding-evidence.yaml`'s platform_dependencies
 #   block, merged by primary key with forward winning. They are equal-status

package/scripts/validate-integration-docs.sh

@@ -160,7 +160,7 @@ check_manifest() {
             ;;
     esac
 
-    # Interaction patterns (ADR 0171) — optional fields, validated only when present.
+    # Interaction patterns (M-ADR 0171) — optional fields, validated only when present.
     # Existing manifests predate the field; absence is not a failure. Directionality
     # mismatch (pattern present but the matching capability flag is false) is a warning.
     local ingestion invocation