@sdd-method/author-cli 0.7.0 → 0.9.0

package/dist/lib/metamodel/tql-subset-parser.js

@@ -0,0 +1,280 @@
+// The documented TypeQL subset — PARSER (M-ADR 0210 §4.2).
+//
+// This module reads the authored form of a fact-based model and nothing else: it knows
+// the subset's grammar and refuses, with a located error, anything outside it. It knows
+// nothing about catalogues, YAML or projections — that is `schema-projection.ts`. The split
+// is deliberate: a store extending the subset extends the parser; the method's projection
+// is one consumer of the parsed model among possible others.
+//
+// Fail-closed (M-ADR 0200 §4.3): a construct the parser does not recognise is a ParseError,
+// never a skip. The five blindnesses measured in the prototype this replaces — `@values`,
+// an `@card` form outside the subset, a role with two players, a value-type/family
+// contradiction, a content change that must be visible — are each refused here or made
+// visible to the projection, and the round-trip gate proves that with mutation controls
+// before every verdict.
+//
+// Grammar (one declaration per line; `#` outside a string literal starts a comment):
+//   define
+//   attribute <label>, value <string|integer|double|boolean|date|datetime>;
+//   entity <label>[, owns <attr> [@key] [@card(1..1)|@card(0..1)|@card(0..)]][, plays <rel>:<role> [...]] ...;
+//   relation <label>[, relates <role> [@card(1..1)|@card(0..1)|@card(0..)]][, owns ...][, plays ...] ...;
+// Meta rows (the second file):
+//   insert $m isa <meta-type>, has <key> <"string"|int|true|false>[, has ...];
+export class ParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ParseError";
+    }
+}
+export const VALUE_TYPES = new Set(["string", "integer", "double", "boolean", "date", "datetime"]);
+export const META_TYPES = new Set([
+    "schema-meta",
+    "catalogue-meta",
+    "column-meta",
+    "fk-meta",
+    "column-enum-meta",
+    "enum-meta",
+    "enum-value-meta",
+    "enum-value-property",
+    "coverage-meta",
+    "relationship-meta",
+    "vocabulary-meta",
+    "rule-meta",
+]);
+/** Meta keys whose values are lists (repeated `has` on one row). */
+const LIST_KEYS = new Set(["m-external-for-profile", "m-reads"]);
+function unlit(s, where) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === "\\" && i + 1 < s.length) {
+            const n = s[i + 1];
+            const map = { n: "\n", t: "\t", '"': '"', "\\": "\\" };
+            const r = map[n];
+            if (r === undefined)
+                throw new ParseError(`${where}: bad escape \\${n}`);
+            out += r;
+            i++;
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+/** A `#` outside a string literal starts a comment. */
+export function stripComment(line) {
+    let out = "";
+    let q = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === '"' && (i === 0 || line[i - 1] !== "\\"))
+            q = !q;
+        if (c === "#" && !q)
+            break;
+        out += c;
+    }
+    return out.trim();
+}
+const CARD_RE = /^@card\((\d+)\.\.(\d*)\)$/;
+function parseAnnotations(tokens, where) {
+    let key = false;
+    let required = false;
+    let multi = false;
+    let optional = false;
+    for (const t of tokens) {
+        if (t === "@key") {
+            key = true;
+        }
+        else if (t.startsWith("@card(")) {
+            const m = CARD_RE.exec(t);
+            if (!m)
+                throw new ParseError(`${where}: unparseable cardinality ${JSON.stringify(t)}`);
+            const lo = m[1];
+            const hi = m[2];
+            if (lo === "1" && hi === "1")
+                required = true;
+            else if (lo === "0" && hi === "")
+                multi = true;
+            else if (lo === "0" && hi === "1")
+                optional = true;
+            else
+                throw new ParseError(`${where}: cardinality ${t} cannot be projected onto the catalogue schema (only @card(1..1), @card(0..1) or @card(0..) are in the subset)`);
+        }
+        else if (t.startsWith("@values")) {
+            throw new ParseError(`${where}: @values(...) is not admitted in this projection — vocabularies bind through column_enums meta rows or a recorded absence (M-ADR 0210 §4.5)`);
+        }
+        else {
+            throw new ParseError(`${where}: unknown token ${JSON.stringify(t)}`);
+        }
+    }
+    return { key, required, multi, optional };
+}
+function splitClauses(body, where) {
+    // refuse before the naive split can be fooled by a comma inside the parenthesis
+    if (body.includes("@values")) {
+        throw new ParseError(`${where}: @values(...) is not admitted in this projection (M-ADR 0210 §4.5)`);
+    }
+    return body.split(",").map((c) => c.trim());
+}
+const ATTR_RE = /^attribute ([a-z][a-z0-9-]*), value ([a-z]+)$/;
+const TYPE_RE = /^(entity|relation) ([a-z][a-z0-9-]*)(?:, (.*))?$/;
+/** Parse the type-system file. `fileLabel` names the file in error locations. */
+export function parseTypes(text, fileLabel = "catalogue-schema.tql", options = {}) {
+    const singlePlayer = options.singlePlayer ?? true;
+    const attrs = new Map();
+    const entities = new Map();
+    const relations = new Map();
+    const seen = new Set();
+    const lines = text.split(/\r?\n/);
+    for (let ln = 1; ln <= lines.length; ln++) {
+        let line = stripComment(lines[ln - 1]);
+        if (line === "" || line === "define")
+            continue;
+        const where = `${fileLabel}:${ln}`;
+        if (!line.endsWith(";"))
+            throw new ParseError(`${where}: declaration must end with ';' — one declaration per line`);
+        line = line.slice(0, -1);
+        const am = ATTR_RE.exec(line);
+        if (am) {
+            const lab = am[1];
+            const vt = am[2];
+            if (!VALUE_TYPES.has(vt))
+                throw new ParseError(`${where}: unknown value type ${JSON.stringify(vt)}`);
+            if (seen.has(lab))
+                throw new ParseError(`${where}: duplicate declaration of ${JSON.stringify(lab)}`);
+            seen.add(lab);
+            attrs.set(lab, vt);
+            continue;
+        }
+        const tm = TYPE_RE.exec(line);
+        if (!tm)
+            throw new ParseError(`${where}: not in the subset: ${JSON.stringify(line.slice(0, 100))}`);
+        const kind = tm[1];
+        const lab = tm[2];
+        const body = tm[3];
+        if (seen.has(lab))
+            throw new ParseError(`${where}: duplicate declaration of ${JSON.stringify(lab)}`);
+        seen.add(lab);
+        const decl = { owns: new Map(), plays: new Map(), relates: new Map() };
+        for (const clause of body !== undefined ? splitClauses(body, where) : []) {
+            const w = clause.split(/\s+/).filter((x) => x !== "");
+            if (w.length === 0)
+                throw new ParseError(`${where}: empty clause`);
+            const head = w[0];
+            if (head === "owns") {
+                if (w.length < 2)
+                    throw new ParseError(`${where}: owns without attribute`);
+                if (decl.owns.has(w[1]))
+                    throw new ParseError(`${where}: ${lab} owns ${w[1]} twice`);
+                decl.owns.set(w[1], parseAnnotations(w.slice(2), where));
+            }
+            else if (head === "plays") {
+                if (w.length < 2 || !w[1].includes(":"))
+                    throw new ParseError(`${where}: plays needs <relation>:<role>`);
+                if (decl.plays.has(w[1]))
+                    throw new ParseError(`${where}: ${lab} plays ${w[1]} twice`);
+                decl.plays.set(w[1], parseAnnotations(w.slice(2), where));
+            }
+            else if (head === "relates") {
+                if (kind !== "relation")
+                    throw new ParseError(`${where}: only a relation relates`);
+                if (w.length < 2)
+                    throw new ParseError(`${where}: relates without role`);
+                if (decl.relates.has(w[1]))
+                    throw new ParseError(`${where}: ${lab} relates ${w[1]} twice`);
+                decl.relates.set(w[1], parseAnnotations(w.slice(2), where));
+            }
+            else {
+                throw new ParseError(`${where}: unknown clause ${JSON.stringify(head)}`);
+            }
+        }
+        (kind === "entity" ? entities : relations).set(lab, decl);
+    }
+    // every owned attribute must be declared; every role must exist; a role has at most ONE player
+    const playersAll = new Map();
+    for (const [lab, d] of [...entities, ...relations]) {
+        for (const a of d.owns.keys()) {
+            if (!attrs.has(a))
+                throw new ParseError(`${lab} owns undeclared attribute ${JSON.stringify(a)}`);
+        }
+        for (const rr of d.plays.keys()) {
+            const idx = rr.indexOf(":");
+            const rel = rr.slice(0, idx);
+            const role = rr.slice(idx + 1);
+            const r = relations.get(rel);
+            if (!r)
+                throw new ParseError(`${lab} plays role of undeclared relation ${JSON.stringify(rel)}`);
+            if (!r.relates.has(role))
+                throw new ParseError(`${lab} plays undeclared role ${JSON.stringify(rr)}`);
+            const list = playersAll.get(rr) ?? [];
+            list.push(lab);
+            playersAll.set(rr, list);
+        }
+    }
+    const players = new Map();
+    for (const [rr, ps] of playersAll) {
+        if (ps.length > 1 && !singlePlayer)
+            continue;
+        if (ps.length > 1) {
+            throw new ParseError(`role ${rr} has ${ps.length} players (${ps.join(", ")}); the projection can carry exactly one and refuses to pick`);
+        }
+        players.set(rr, ps[0]);
+    }
+    return { attrs, entities, relations, players, playersAll };
+}
+const ROW_RE = /^insert \$m isa ([a-z][a-z0-9-]*), (.*);$/;
+const TOK_RE = /has ([a-z][a-z0-9-]*) ("(?:[^"\\]|\\.)*"|-?\d+|true|false)/y;
+export function parseMeta(text, fileLabel = "catalogue-schema-meta.tql", options = {}) {
+    const metaTypes = options.metaTypes ?? META_TYPES;
+    const rows = new Map();
+    const lines = text.split(/\r?\n/);
+    for (let ln = 1; ln <= lines.length; ln++) {
+        const line = stripComment(lines[ln - 1]);
+        if (line === "")
+            continue;
+        const where = `${fileLabel}:${ln}`;
+        const m = ROW_RE.exec(line);
+        if (!m)
+            throw new ParseError(`${where}: not in the subset: ${JSON.stringify(line.slice(0, 100))}`);
+        const typ = m[1];
+        const body = m[2];
+        if (!metaTypes.has(typ))
+            throw new ParseError(`${where}: unknown meta type ${JSON.stringify(typ)}`);
+        const acc = new Map();
+        let i = 0;
+        for (;;) {
+            TOK_RE.lastIndex = i;
+            const t = TOK_RE.exec(body);
+            if (!t)
+                throw new ParseError(`${where}: meta row body not in the subset at offset ${i}: ${JSON.stringify(body.slice(i, i + 60))}`);
+            const k = t[1];
+            const v = t[2];
+            let val;
+            if (v.startsWith('"'))
+                val = unlit(v.slice(1, -1), where);
+            else if (v === "true" || v === "false")
+                val = v === "true";
+            else
+                val = Number.parseInt(v, 10);
+            const list = acc.get(k) ?? [];
+            list.push(val);
+            acc.set(k, list);
+            i = TOK_RE.lastIndex;
+            if (i === body.length)
+                break;
+            if (body.startsWith(", ", i))
+                i += 2;
+            else
+                throw new ParseError(`${where}: expected ', has ...' at offset ${i}: ${JSON.stringify(body.slice(i, i + 40))}`);
+        }
+        const row = {};
+        for (const [k, vs] of acc)
+            row[k] = LIST_KEYS.has(k) ? vs : vs[0];
+        const list = rows.get(typ) ?? [];
+        list.push(row);
+        rows.set(typ, list);
+    }
+    return rows;
+}
+//# sourceMappingURL=tql-subset-parser.js.map

package/dist/lib/pack/schema.js

@@ -26,7 +26,7 @@ export const PackSeedSchema = z.object({
     scope: z
         .string()
         .regex(/^[a-z0-9-]+$/, "scope must be lower-kebab-case slug"),
-    // Optional per ADR 0176 §4.6: absent = profile-agnostic pack.
+    // Optional per M-ADR 0176 §4.6: absent = profile-agnostic pack.
     forwardBase: z
         .object({
         bundle: z.enum(KNOWN_FORWARD_BASES),
@@ -66,7 +66,7 @@ export const PackSeedSchema = z.object({
         .array(z.string().min(1))
         .min(1, "managed_paths must have at least one entry"),
     forbiddenPaths: z.array(z.string()).optional(),
-    // ADR 0176 §4.3: scaffold-source path prefixes; each must cover at
+    // M-ADR 0176 §4.3: scaffold-source path prefixes; each must cover at
     // least one managed_paths entry (checked in the superRefine below).
     scaffoldSourcePaths: z.array(z.string().min(1)).optional(),
     requiresPack: z

package/dist/lib/pack/seed.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
 /**
- * Adopter pack seed file. Per ADR 0151 + context-pack-seed-schema.yaml.
+ * Adopter pack seed file. Per M-ADR 0151 + context-pack-seed-schema.yaml.
  *
  * Loaded by `sdd-cli pack build` and `sdd-cli pack validate` from
  * `orchestration/distribution/{pack-name}-seed.yaml` in adopter repos.
@@ -120,7 +120,7 @@ async function loadSeedRecursive(absPath, visited) {
     const seed = {
         version: asString(own.version, "version", absPath),
         scope: asString(own.scope, "scope", absPath),
-        // forward_base optional per ADR 0176 §4.6 (profile-agnostic packs omit it)
+        // forward_base optional per M-ADR 0176 §4.6 (profile-agnostic packs omit it)
         ...(own.forward_base && {
             forwardBase: {
                 bundle: asString(own.forward_base.bundle, "forward_base.bundle", absPath),

package/dist/lib/pack/validate.js

@@ -36,7 +36,7 @@ export async function runPackValidate(opts, stdout = (s) => process.stdout.write
     stdout(pass(`Seed valid: ${seed.scope} v${seed.version}`));
     stdout(info(seed.forwardBase
         ? `Forward base: ${seed.forwardBase.bundle} >= ${seed.forwardBase.minimumVersion}`
-        : "Forward base: none (profile-agnostic pack, ADR 0176 §4.6)"));
+        : "Forward base: none (profile-agnostic pack, M-ADR 0176 §4.6)"));
     if (seed.scaffoldSourcePaths) {
         stdout(info(`Scaffold-source prefixes: ${seed.scaffoldSourcePaths.join(", ")}`));
     }

package/dist/lib/plan/read-sdd.js

@@ -10,7 +10,7 @@ import { parseRepoConfigFile } from "../sdd-index/repo-config.js";
  *
  * Repo-config parsing delegates to the shared sdd-index module so the
  * `plan --pilot` path and the MCP dependency-graph tools see the same
- * view. The richer ADR 0110 shape (package/version/stability) is
+ * view. The richer M-ADR 0110 shape (package/version/stability) is
  * flattened back to path-strings here to preserve the legacy
  * `RepoConfig` contract.
  */

package/dist/lib/repo-kind.js

@@ -2,7 +2,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 /**
  * Forward-base bundles set `.sdd-repo-kind` and qualify as the base
- * layer that additive extensions can compose on top of (per ADR 0135).
+ * layer that additive extensions can compose on top of (per M-ADR 0135).
  * The legacy self-contained `reverse-baseline` is retained as a
  * forward base for compat with adopters who haven't migrated to the
  * `reverse-extension-baseline` additive shape yet.
@@ -14,13 +14,6 @@ const FORWARD_BASE_BUNDLES = new Set([
     "reverse-baseline",
 ]);
 export const REPO_KIND_FILE = ".sdd-repo-kind";
-/**
- * Legacy marker filename from the pre-rebrand era. Read-only fallback during
- * the rebrand transition: `readRepoKind` accepts either filename; `sync`
- * auto-migrates legacy → canonical. New writes always use `REPO_KIND_FILE`.
- * Drop after one minor-version overlap.
- */
-export const LEGACY_REPO_KIND_FILE = ".iteraitive-repo-kind";
 const PROFILE_BY_REPO_KIND = {
     "platform-product": "platform",
     "application-product": "application",
@@ -59,7 +52,7 @@ export function repoKindFromProfile(profile) {
 /**
  * Returns the profile a bundle authoritatively claims, or null for
  * additive bundles that don't claim a profile of their own. Accepts
- * arbitrary strings (adopter pack names per ADR 0151) and returns null
+ * arbitrary strings (adopter pack names per M-ADR 0151) and returns null
  * for any name not in the closed sdd-method bundle set.
  */
 export function profileFromBundleName(name) {
@@ -73,7 +66,7 @@ export function bundleNameFromProfile(profile) {
 /**
  * Forward-base bundles set `.sdd-repo-kind` and qualify as the base
  * layer that additive extensions compose on top of. Additive bundles
- * (sdd-method's `reverse-extension-baseline` and ADR 0151 adopter
+ * (sdd-method's `reverse-extension-baseline` and M-ADR 0151 adopter
  * packs) return false. Accepts arbitrary strings; unknown names return
  * false.
  */
@@ -103,8 +96,7 @@ export function isBundleName(value) {
     return ALL_BUNDLE_NAMES.has(value);
 }
 export async function readRepoKind(repoRoot) {
-    // Canonical first; fall back to legacy marker during the rebrand transition.
-    for (const filename of [REPO_KIND_FILE, LEGACY_REPO_KIND_FILE]) {
+    for (const filename of [REPO_KIND_FILE]) {
         const path = join(repoRoot, filename);
         let raw;
         try {

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/behaviour-store.js

@@ -0,0 +1,60 @@
+// Create an SDD's behaviour store, inside the SDD (M-ADR 0221 §4.2): an OpenSpec project at
+// openspec/ that selects the method's sdd-change schema (M-ADR 0223 §4.2). A store is created when
+// its SDD first drafts a proposed change, agrees a change or baselines behaviour, not in advance, so this is an authoring step,
+// never part of sync. Sync keeps the schema copy current afterwards.
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { parseDocument } from "yaml";
+import { SHIPPED_CONFIG_TEMPLATE, SHIPPED_SCHEMA_DIR, STORE_CONFIG, STORE_SCHEMA_DIR, writeStoreSchema } from "../behaviour-store/schema.js";
+import { MANIFEST_REL_PATH } from "../catalogue/manifest-loader.js";
+export const STORE_KEEP_FILES = ["openspec/specs/.gitkeep", "openspec/changes/archive/.gitkeep", "docs/agreements/.gitkeep"];
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The refusal, or null when the store can be created. */
+export async function storeScaffoldRefusal(repo) {
+    if (await exists(join(repo, "openspec"))) {
+        return "openspec/ already exists: this SDD has a behaviour store. Sync keeps its schema copy current.";
+    }
+    if (!(await exists(join(repo, SHIPPED_SCHEMA_DIR, "schema.yaml"))) || !(await exists(join(repo, SHIPPED_CONFIG_TEMPLATE)))) {
+        return `this SDD holds no shipped ${SHIPPED_SCHEMA_DIR}/ and ${SHIPPED_CONFIG_TEMPLATE}: sync a method bundle that carries them first.`;
+    }
+    return null;
+}
+export async function scaffoldBehaviourStore(repo) {
+    const refusal = await storeScaffoldRefusal(repo);
+    if (refusal !== null)
+        throw new Error(refusal);
+    let sddId = null;
+    try {
+        const m = parseDocument(await readFile(join(repo, MANIFEST_REL_PATH), "utf8")).toJS();
+        if (typeof m?.sdd_id === "string" && m.sdd_id.length > 0)
+            sddId = m.sdd_id;
+    }
+    catch {
+        sddId = null;
+    }
+    const template = await readFile(join(repo, SHIPPED_CONFIG_TEMPLATE), "utf8");
+    const config = sddId === null ? template : template.replaceAll("<sdd-id>", sddId);
+    const filesWritten = [];
+    await mkdir(dirname(join(repo, STORE_CONFIG)), { recursive: true });
+    await writeFile(join(repo, STORE_CONFIG), config);
+    filesWritten.push(STORE_CONFIG);
+    for (const rel of STORE_KEEP_FILES) {
+        if (await exists(join(repo, dirname(rel))))
+            continue;
+        await mkdir(join(repo, dirname(rel)), { recursive: true });
+        await writeFile(join(repo, rel), "");
+        filesWritten.push(rel);
+    }
+    const copied = await writeStoreSchema(repo);
+    filesWritten.push(...copied.missing.map((f) => `${STORE_SCHEMA_DIR}/${f}`));
+    return { filesWritten, sddId };
+}
+//# sourceMappingURL=behaviour-store.js.map