@sdd-method/maintain-cli 0.8.0 → 0.10.0

package/dist/lib/scaffold/archetype-behaviour.js

@@ -0,0 +1,173 @@
+// Archetype behaviour, seeded once and then cited.
+//
+// A reference-architecture archetype ships its behaviour as canonical rows (behaviour.tql, rows of the
+// behaviour schema in the M-ADR 0210 subset). An estate does not sync them: it takes them ONCE, when it
+// scaffolds the domain, as an OpenSpec change that ADDS the archetype's requirements to its behaviour store,
+// to agree and build through its own process like any other change (M-ADR 0221-0223). From then on the
+// estate owns its requirements and CITES the archetype's: docs/domains/<domain>/archetype-citations.yaml
+// records, per requirement, the archetype requirement it answers to, the bundle version and a digest of that
+// requirement there, and how the estate's relates to it (derived, extended, narrowed, or departed with a
+// reason and the decision that took it). The validator `archetype-citations` reports a citation whose source
+// has changed since, so evolution is visible rather than silent; re-aligning is a re-pin.
+//
+// The generated OpenSpec spec the reference architecture keeps beside its rows is never read here: the rows
+// are the source, and two homes for one behaviour is what M-ADR 0221 rules out.
+import { createHash } from "node:crypto";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { stringify as stringifyYaml } from "yaml";
+import { parseMeta } from "../metamodel/tql-subset-parser.js";
+export const BEHAVIOUR_FILE = "behaviour.tql";
+export const CITATIONS_FILE = "archetype-citations.yaml";
+export const RELATIONS = ["derived", "extended", "narrowed", "departed"];
+const BEHAVIOUR_META = new Set(["requirement-meta", "scenario-meta", "scenario-step-meta", "cite-meta"]);
+const str = (r, k) => String(r[k] ?? "");
+const num = (r, k) => Number(r[k] ?? 0);
+/** The archetype's requirements, in position order, from its behaviour rows. */
+export function parseArchetypeBehaviour(text, label) {
+    const rows = parseMeta(text, label, { metaTypes: BEHAVIOUR_META });
+    const reqs = [...(rows.get("requirement-meta") ?? [])].sort((a, b) => num(a, "m-position") - num(b, "m-position"));
+    const scen = rows.get("scenario-meta") ?? [];
+    const steps = rows.get("scenario-step-meta") ?? [];
+    const cites = rows.get("cite-meta") ?? [];
+    return reqs.map((r) => {
+        const id = str(r, "m-requirement");
+        const scenarios = scen
+            .filter((x) => str(x, "m-requirement") === id)
+            .sort((a, b) => num(a, "m-position") - num(b, "m-position"))
+            .map((x) => {
+            const sid = str(x, "m-scenario");
+            return {
+                id: sid,
+                title: str(x, "m-title"),
+                steps: steps
+                    .filter((t) => str(t, "m-scenario") === sid)
+                    .sort((a, b) => num(a, "m-position") - num(b, "m-position"))
+                    .map((t) => ({ keyword: str(t, "m-keyword"), text: str(t, "m-text") })),
+                cites: cites.filter((c) => str(c, "m-scenario") === sid).map((c) => str(c, "m-cites")),
+            };
+        });
+        const req = {
+            id,
+            title: str(r, "m-title"),
+            statement: str(r, "m-statement"),
+            tier: str(r, "m-tier"),
+            ruleFile: str(r, "m-rule-file"),
+            ruleLabel: str(r, "m-rule-label"),
+            scenarios,
+        };
+        return { ...req, digest: requirementDigest(req) };
+    });
+}
+/** Digest of everything a citation answers to: wording, tier, source rule and scenarios, not position. */
+export function requirementDigest(r) {
+    const canon = JSON.stringify([r.id, r.title, r.statement, r.tier, r.ruleFile, r.ruleLabel,
+        r.scenarios.map((s) => [s.id, s.title, s.steps.map((t) => [t.keyword, t.text]), [...s.cites].sort()])]);
+    return createHash("sha256").update(canon).digest("hex").slice(0, 12);
+}
+/** The archetype's behaviour rows in a cached bundle: <bundle cache>/<seed prefix>/behaviour.tql, if it ships them. */
+export async function loadArchetypeBehaviour(bundleCacheDir, seeds) {
+    for (const seed of seeds) {
+        const file = join(bundleCacheDir, seed, BEHAVIOUR_FILE);
+        let text;
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        return parseArchetypeBehaviour(text, file);
+    }
+    return undefined;
+}
+/** `<bundle>@<version>` cache directory names carry the version the estate locked. */
+export function cachedVersion(bundleCacheDir) {
+    const name = bundleCacheDir.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "";
+    const at = name.lastIndexOf("@");
+    return at > 0 ? name.slice(at + 1) : undefined;
+}
+function renderChange(domain, archetypeId, bundle, version, reqs) {
+    const proposal = [
+        "## Why", "",
+        `The ${domain} domain was scaffolded from the reference architecture's ${archetypeId} archetype (${bundle} ${version}). ` +
+            "The archetype prescribes behaviour every conforming estate needs; this change adds it to the behaviour store once. " +
+            "From here the requirements are this estate's: the citations in " +
+            `docs/domains/${domain}/${CITATIONS_FILE} record which archetype requirement each one answers to.`, "",
+        "## What Changes", "",
+        `- Adds ${reqs.length} requirements to the ${domain} spec, one per archetype rule, each with its scenarios.`,
+        "- Before agreeing the change, narrow, extend or remove requirements to fit this estate: an optional requirement whose condition " +
+            "the estate does not declare is removed; one the estate meets differently is reworded. Record each such choice in the citations " +
+            "(narrowed, extended, or departed with its reason and the decision that took it).",
+        "",
+    ].join("\n");
+    const spec = ["## ADDED Requirements"];
+    for (const r of reqs) {
+        spec.push("", `### Requirement: ${r.title}`, "", r.statement, "", `Seeded from archetype requirement ${r.id} (${archetypeId}, ${r.tier}), rule "${r.ruleLabel}".`, "");
+        for (const s of r.scenarios) {
+            spec.push(`#### Scenario: ${s.title}`, "", ...s.steps.map((t) => `- **${t.keyword}** ${t.text}`), "");
+        }
+    }
+    const tasks = ["## 1. Fit", "", "- [ ] 1.1 Review each seeded requirement against this estate and record the relation in the citations", ""].join("\n");
+    return { proposal, spec: spec.join("\n").replace(/\n+$/, "") + "\n", tasks };
+}
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeAt(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, "utf8");
+}
+/**
+ * Seed an estate's behaviour from an archetype, once: an OpenSpec change adding the archetype's requirements,
+ * and the domain's citations. Writes nothing when the estate has no behaviour store, when the archetype ships
+ * no rows, or when either the change or the citations already exist.
+ */
+export async function seedArchetypeBehaviour(input) {
+    const store = join(input.targetRepo, "openspec");
+    if (!(await exists(store)))
+        return { filesWritten: [], skipped: "no behaviour store (openspec/) in this repository; `sdd-cli scaffold behaviour-store` creates one" };
+    const reqs = await loadArchetypeBehaviour(input.bundleCacheDir, input.seeds);
+    if (!reqs || reqs.length === 0)
+        return { filesWritten: [], skipped: `archetype ${input.archetypeId} ships no behaviour rows` };
+    const version = cachedVersion(input.bundleCacheDir) ?? "unknown";
+    const change = `seed-${input.domain}-from-archetype`;
+    const changeDir = join(store, "changes", change);
+    const citations = join(input.targetRepo, "docs", "domains", input.domain, CITATIONS_FILE);
+    if (await exists(changeDir))
+        return { filesWritten: [], skipped: `openspec/changes/${change} already exists (seeded once)` };
+    if (await exists(citations))
+        return { filesWritten: [], skipped: `docs/domains/${input.domain}/${CITATIONS_FILE} already exists (seeded once)` };
+    const { proposal, spec, tasks } = renderChange(input.domain, input.archetypeId, input.bundleName, version, reqs);
+    const doc = {
+        archetype: input.archetypeId,
+        bundle: input.bundleName,
+        version,
+        citations: reqs.map((r) => ({ requirement: r.title, cites: r.id, digest: r.digest, relation: "derived" })),
+    };
+    const header = [
+        `# ${CITATIONS_FILE} — the ${input.domain} domain's requirements that answer to reference-architecture archetype requirements.`,
+        "# Seeded once from the archetype; the requirements are this estate's. Per citation: `requirement` is this estate's",
+        "# requirement title, `cites` the archetype requirement id, `digest` that requirement at `version`, and `relation` one of",
+        "# derived | extended | narrowed | departed (departed needs `reason` and `decision`; narrowed and extended may give",
+        "# a `reason`). Keep `digest` quoted. An archetype requirement this estate decides not to take goes under",
+        "# `not_adopted:` as {cites, reason, decision}. Checked by `sdd-cli validate --validator archetype-citations`: a",
+        "# changed source is reported until reviewed and re-pinned, and requirements neither cited nor not adopted are listed.",
+        "",
+    ].join("\n");
+    const files = [
+        [join(changeDir, "proposal.md"), proposal],
+        [join(changeDir, "tasks.md"), tasks],
+        [join(changeDir, "specs", input.domain, "spec.md"), spec],
+        [citations, header + stringifyYaml(doc, { lineWidth: 0 })],
+    ];
+    for (const [p, c] of files)
+        await writeAt(p, c);
+    return { filesWritten: files.map(([p]) => p.slice(input.targetRepo.length + 1)) };
+}
+//# sourceMappingURL=archetype-behaviour.js.map

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/adr-transitions.js

@@ -187,14 +187,16 @@ const CITATION_LINK = /\]\(([^)\s#]+)(?:#[^)\s]*)?\)/g;
  *
  * A citation is the moved path written literally (repo-relative), or a Markdown
  * link whose target resolves to it from the citing file. Method-managed files are
- * excluded: the bundle already ships them corrected.
+ * excluded: the bundle already ships them corrected. So is a moved file itself, at
+ * its old path: the sync renames it and replaces its content with the shipped copy.
  */
 export async function findStrandedCitations(targetRepo, moved, managed, trackedTextFiles) {
     if (moved.length === 0)
         return [];
+    const leaving = new Set(moved.map((m) => m.fromPath));
     const out = [];
     for (const file of trackedTextFiles) {
-        if (managed.has(file))
+        if (managed.has(file) || leaving.has(file))
             continue;
         let text;
         try {

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

@@ -16,6 +16,7 @@ import { syncBriefingFiles } from "./briefing-merge.js";
 import { DEFAULT_AGENT_HARNESS } from "../agent-harness.js";
 import { BLOCK_BEGIN, BLOCK_END } from "../init/ci-workflow.js";
 import { blockSha256, CI_BINDINGS, DEFAULT_CI_BINDING, isCiBinding, parseCiRunner, syncCiBinding, } from "../ci-binding/index.js";
+import { SCHEMA_NAME, STORE_SCHEMA_DIR, storeSchemaName, writeStoreSchema } from "../behaviour-store/schema.js";
 import { BRIEFING_TEMPLATE_ROOT, WRAPPER_BLOCK_BEGIN, WRAPPER_BLOCK_END, briefingWrappers, } from "../briefing/index.js";
 const SECTION_RULE = "═".repeat(59);
 /**
@@ -75,7 +76,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 +156,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 +185,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 +194,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) {
@@ -236,9 +237,19 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             ...(migrateFrom?.managedPaths ?? []),
         ];
         const withdrawnKeep = new Set(adrTransitions.protectedFromRemoval);
-        const removals = computeRemovals(prevPaths, materialisePaths, {
-            noDelete: !opts.delete,
-        }).filter((p) => !withdrawnKeep.has(p));
+        // A path the incoming bundle still manages is never a removal, whether it materialises into the tree or
+        // only into the bundle cache: the lock records cache-only paths too, so comparing against the
+        // materialised set alone scheduled every cache-only path as a removal on every sync.
+        // A cache-only path that IS in the tree was left there by a sync from before cache-only mode
+        // (M-ADR 0176 §4.3); it is removed, as before, but named as what it is.
+        const prevSet = new Set(prevPaths);
+        const cacheOnlyStrays = opts.delete
+            ? cacheOnlyPaths.filter((p) => prevSet.has(p) && existsSync(join(opts.targetRepo, p)))
+            : [];
+        const removals = [
+            ...computeRemovals(prevPaths, bundle.managedPaths, { noDelete: !opts.delete }),
+            ...cacheOnlyStrays,
+        ].filter((p) => !withdrawnKeep.has(p));
         stdout(info(`Bundle: ${incomingBundleName} (version: ${bundle.manifest.bundleVersion})`));
         stdout(info(`Incoming managed files: ${bundle.managedPaths.length}`));
         if (cacheOnlyPaths.length > 0) {
@@ -290,8 +301,12 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
         stdout(info(`Removals from previous sync of this bundle: ${removals.length}` +
             (lockOnly > 0
                 ? ` — ${removalsOnDisk.length} file(s) on disk to delete, ${lockOnly} lock entr(ies) only ` +
-                    `(paths never materialised here, e.g. cache-only payload members; nothing is deleted for these)`
+                    `(no file at the path in this tree; nothing is deleted for these)`
                 : ` (all present on disk)`)));
+        if (cacheOnlyStrays.length > 0) {
+            stdout(info(`Of these, ${cacheOnlyStrays.length} cache-only path(s) were left in the tree by a sync from before cache-only mode; ` +
+                `the bundle cache holds them now, so the tree copies are removed`));
+        }
         stdout(info(`ADR renames to apply: ${adrTransitions.renames.length}`));
         stdout(info(`ADR transition warnings: ${adrTransitions.warnings.length}`));
         if (adrTransitions.warnings.length > 0) {
@@ -303,7 +318,8 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
         // each citation in the adopter's own documents to a moved path. Never
         // rewritten; printed in dry-run too, so the figure a reviewer approves is the
         // figure the run states.
-        const stranded = await findStrandedCitations(opts.targetRepo, adrTransitions.movedPaths, new Set(materialisePaths), await trackedTextFiles(opts.targetRepo));
+        // The managed set includes the paths this sync removes: they are method files too.
+        const stranded = await findStrandedCitations(opts.targetRepo, adrTransitions.movedPaths, new Set([...materialisePaths, ...removals]), await trackedTextFiles(opts.targetRepo));
         if (stranded.length > 0) {
             stdout(warn(`Citations to moved paths: ${stranded.length} — the adopter's own documents still name ` +
                 `a path the method moved. Update each (not rewritten automatically):`));
@@ -451,7 +467,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 +504,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 +576,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.
@@ -577,6 +593,17 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
         }
         for (const line of briefingResult.log)
             stdout(info(line));
+        // The store's copy of the method's change schema (M-ADR 0223 §4.2). The bundle ships it inert under
+        // docs/method/foundations/openspec/, and OpenSpec reads only the store's copy, so a store inside this
+        // SDD that selects the schema gets the shipped one. The copy is method-managed (the behaviour-store
+        // validator fails a drifted copy); adopter guidance belongs in the store's config.yaml rules.
+        if ((await storeSchemaName(opts.targetRepo)) === SCHEMA_NAME) {
+            const c = await writeStoreSchema(opts.targetRepo);
+            const changed = [...c.missing, ...c.differing, ...c.extra];
+            if (c.shipped && changed.length > 0) {
+                stdout(info(`Refreshed ${STORE_SCHEMA_DIR}/ from the shipped schema: ${changed.length} file(s) changed (${changed.join(", ")})`));
+            }
+        }
         // Record the wrapper block and the module exactly as they now stand on disk, so the next sync
         // can tell them untouched from edited (M-ADR 0218 §4.7), and the binding and the CLI source
         // when they are not the defaults.

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