@sdd-method/author-cli 0.8.0 → 0.10.0

package/dist/author-program.js

@@ -31,6 +31,7 @@ const SPEC_URL = "docs/method/cli/sdd-cli-specification.md (in the method distri
 /** The verbs the author adds to verify, as `<verb>` or `<verb> <subcommand>` (M-ADR 0220 §4.2). Asserted by test. */
 export const AUTHOR_ONLY_SURFACE = [
     "scaffold domain",
+    "scaffold behaviour-store",
     "plan",
     "contracts attest",
     "conformance",
@@ -46,6 +47,7 @@ export const AUTHOR_ONLY_SURFACE = [
     "context pull",
     "catalogue check",
     "migrate vocabulary",
+    "migrate intents",
 ];
 /** The full surface: verify's, plus the author's own. */
 export const AUTHOR_SURFACE = [...VERIFY_SURFACE, ...AUTHOR_ONLY_SURFACE];

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

@@ -64,6 +64,33 @@ export function renamedFrom(text) {
     }
     return out;
 }
+/** The FROM -> TO pairs of a RENAMED section, in file order. */
+export function renamePairs(text) {
+    const out = [];
+    let op = null;
+    let from = null;
+    for (const line of text.split("\n")) {
+        const section = /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements\b/.exec(line);
+        if (section) {
+            op = section[1];
+            from = null;
+            continue;
+        }
+        if (op !== "RENAMED")
+            continue;
+        const f = /^\s*-\s*FROM:\s*`?###\s+Requirement:\s*(.+?)`?\s*$/.exec(line);
+        if (f) {
+            from = f[1].trim();
+            continue;
+        }
+        const t = /^\s*-\s*TO:\s*`?###\s+Requirement:\s*(.+?)`?\s*$/.exec(line);
+        if (t && from !== null) {
+            out.push({ from, to: t[1].trim() });
+            from = null;
+        }
+    }
+    return out;
+}
 /** Each archive directory's position in the SDD's history: the index of the first commit that added a file under it. */
 async function archiveHistory(sddPath, archiveRel) {
     let stdout;
@@ -100,7 +127,7 @@ export async function orderArchives(sddPath, archiveRel, names) {
         if (date(a) === date(b) && position(a) === position(b))
             ties.push([a, b]);
     }
-    return { order, ties };
+    return { order, ties, history: history !== null };
 }
 /** The repositories a baseline was observed in: its evidence file's `**Observed in:** repo[@sha], repo[@sha]` line. */
 export function observedIn(evidence) {

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

@@ -0,0 +1,85 @@
+// The method's OpenSpec change schema (M-ADR 0223 §4.2) and its copy in a behaviour store.
+//
+// The method ships the schema inert, at docs/method/foundations/openspec/sdd-change/, because
+// sync writes an SDD's managed paths and a store is created only when its SDD first needs one
+// (M-ADR 0221 §4.2): a managed path at openspec/ would create a store in every SDD.
+// OpenSpec reads a project schema only from <store>/openspec/schemas/<name>/, so the store
+// holds a copy. The copy is method-managed: sync refreshes it, scaffold writes it, and the
+// behaviour-store validator fails when it differs. Adopter guidance goes in the store's
+// config.yaml (`context:`, per-artifact `rules:`), never in the copy.
+import { cp, mkdir, readdir, readFile, rm } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { parseDocument } from "yaml";
+export const SCHEMA_NAME = "sdd-change";
+export const SHIPPED_SCHEMA_DIR = "docs/method/foundations/openspec/sdd-change";
+export const SHIPPED_CONFIG_TEMPLATE = "docs/method/foundations/openspec/config-template.yaml";
+export const STORE_SCHEMA_DIR = `openspec/schemas/${SCHEMA_NAME}`;
+export const STORE_CONFIG = "openspec/config.yaml";
+async function files(dir) {
+    const out = [];
+    async function walk(d) {
+        for (const e of await readdir(d, { withFileTypes: true })) {
+            const p = join(d, e.name);
+            if (e.isDirectory())
+                await walk(p);
+            else if (e.isFile())
+                out.push(relative(dir, p));
+        }
+    }
+    try {
+        await walk(dir);
+    }
+    catch {
+        return null;
+    }
+    return out.sort();
+}
+async function read(p) {
+    try {
+        return await readFile(p);
+    }
+    catch {
+        return null;
+    }
+}
+/** The schema the store's config.yaml selects: its name, null without a config, or "" without a `schema:` key. */
+export async function storeSchemaName(repo) {
+    const text = await read(join(repo, STORE_CONFIG));
+    if (text === null)
+        return null;
+    const v = parseDocument(text.toString("utf8")).toJS()?.schema;
+    return typeof v === "string" ? v : "";
+}
+/** Compare the store's copy of the schema with the one the SDD's method bundle shipped, file by file. */
+export async function compareStoreSchema(repo) {
+    const shipped = await files(join(repo, SHIPPED_SCHEMA_DIR));
+    if (shipped === null || shipped.length === 0)
+        return { shipped: false, missing: [], differing: [], extra: [] };
+    const store = (await files(join(repo, STORE_SCHEMA_DIR))) ?? [];
+    const missing = shipped.filter((f) => !store.includes(f));
+    const extra = store.filter((f) => !shipped.includes(f));
+    const differing = [];
+    for (const f of shipped.filter((x) => store.includes(x))) {
+        const a = await read(join(repo, SHIPPED_SCHEMA_DIR, f));
+        const b = await read(join(repo, STORE_SCHEMA_DIR, f));
+        if (a === null || b === null || !a.equals(b))
+            differing.push(f);
+    }
+    return { shipped: true, missing, differing, extra };
+}
+/**
+ * Replace the store's copy of the schema with the shipped one. Returns what changed, as a
+ * comparison taken before the write; a store already current returns empty lists.
+ */
+export async function writeStoreSchema(repo) {
+    const before = await compareStoreSchema(repo);
+    if (!before.shipped)
+        return before;
+    if (before.missing.length + before.differing.length + before.extra.length === 0)
+        return before;
+    await rm(join(repo, STORE_SCHEMA_DIR), { recursive: true, force: true });
+    await mkdir(join(repo, STORE_SCHEMA_DIR), { recursive: true });
+    await cp(join(repo, SHIPPED_SCHEMA_DIR), join(repo, STORE_SCHEMA_DIR), { recursive: true });
+    return before;
+}
+//# sourceMappingURL=schema.js.map

package/dist/lib/catalogue/build.js

@@ -1167,6 +1167,9 @@ async function collectRows(schema, manifest, findings, sddPath, snapshotStore) {
         out.set("requirements", r.requirements);
         out.set("requirement_lineage", r.lineage);
         out.set("requirement_status", r.status);
+        out.set("changes", r.changes);
+        out.set("change_work_order", r.workOrders);
+        out.set("change_work_item", r.workItems);
     }
     // 15. C4 systems + containers + components (L1 + L2 + L3). The L3 walker
     // is the forward-method authoring path reading

package/dist/lib/catalogue/builders/requirements.js

@@ -8,7 +8,13 @@
 //                       directory name, which is the catalogue feature id; plus one per requirement an open,
 //                       agreed change ADDS (stage agreed).
 //   requirement_lineage each archived change, in archive order, whose delta ADDED, MODIFIED or RENAMED a
-//                       requirement that is current now. A change carrying baseline-evidence.md is a baseline.
+//                       requirement that is current now, under any name a later RENAMED gave it. A change carrying
+//                       baseline-evidence.md is a baseline. Statuses follow renames the same way.
+//   changes             each change in the store, open or archived (M-ADR 0223 §4.2): its directory name, its
+//                       undated name, kind, status (archived, or its agreement record's) and verdict.
+//   change_work_order   per (change, repository): the record's work order, agreed or completed.
+//   change_work_item    per (change, work item): the ids its proposal's `## Work Items` section lists, keyed by
+//                       the undated name so the row survives archive.
 //   requirement_status  per (requirement, repository): observed from a baseline's `**Observed in:**` line;
 //                       declared-shipped from an archived change whose agreement record's verdict is PASS, through
 //                       its work orders' `implements` lists; agreed from an open change whose record is agreed.
@@ -20,7 +26,7 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { observedIn, orderArchives, parseRequirements } from "../../behaviour-store/archive.js";
+import { observedIn, orderArchives, parseRequirements, renamePairs } from "../../behaviour-store/archive.js";
 export { observedIn, parseRequirements };
 const STORE = "openspec";
 const AGREEMENTS = join("docs", "agreements");
@@ -62,6 +68,17 @@ async function deltaOf(changeDir) {
     }
     return out;
 }
+async function renamesOf(changeDir) {
+    const out = [];
+    for (const feature of await dirs(join(changeDir, "specs"))) {
+        const text = await readText(join(changeDir, "specs", feature, "spec.md"));
+        if (text === null)
+            continue;
+        for (const r of renamePairs(text))
+            out.push({ feature, ...r });
+    }
+    return out;
+}
 async function agreementRecord(sddPath, change) {
     const text = await readText(join(sddPath, AGREEMENTS, `${change}.yaml`));
     if (text === null)
@@ -82,10 +99,33 @@ export async function archiveOrder(sddPath, names, findings) {
     }
     return order;
 }
+const CHANGE_STATUSES = new Set(["proposed", "agreed", "superseded", "withdrawn"]);
+/**
+ * The work-item ids a proposal's `## Work Items` section lists (M-ADR 0223 §4.2): one per bullet, the backticked
+ * id if there is one, else the bullet's first word. HTML comments (the template's guidance) are ignored.
+ */
+export function parseWorkItems(proposal) {
+    const text = proposal.replace(/<!--[\s\S]*?-->/g, "");
+    const m = /^##\s+Work Items\s*$/im.exec(text);
+    if (!m)
+        return [];
+    const rest = text.slice(m.index + m[0].length);
+    const end = /^##\s/m.exec(rest);
+    const ids = [];
+    for (const line of (end ? rest.slice(0, end.index) : rest).split("\n")) {
+        const b = /^\s*[-*]\s+(.*)$/.exec(line);
+        if (!b)
+            continue;
+        const id = (/`([^`]+)`/.exec(b[1])?.[1] ?? b[1].split(/\s+/)[0] ?? "").replace(/[:,;]+$/, "").trim();
+        if (id && !ids.includes(id))
+            ids.push(id);
+    }
+    return ids;
+}
 const rel = (sddPath, p) => p.slice(sddPath.length + 1).split("\\").join("/");
 export async function buildRequirements(inputs) {
     const { sddPath, findings } = inputs;
-    const empty = { requirements: [], lineage: [], status: [] };
+    const empty = { requirements: [], lineage: [], status: [], changes: [], workOrders: [], workItems: [] };
     const store = join(sddPath, STORE);
     if (!(await isDir(store)))
         return empty;
@@ -115,6 +155,28 @@ export async function buildRequirements(inputs) {
     const events = [];
     const lineage = [];
     const unknownRepos = new Set();
+    const changes = [];
+    const workOrders = [];
+    const workItems = [];
+    // The change itself, its work orders and its work items (M-ADR 0223 §4.2).
+    const recordChange = async (id, name, kind, status, archivedOn, changeDir, record) => {
+        const verdict = record?.verdict?.result === "PASS" || record?.verdict?.result === "FAIL" ? record.verdict.result : "";
+        changes.push({ id, name, change_kind: kind, status, archived_on: archivedOn, verdict, source_sdd_id: "", platform_sdd_id: "" });
+        for (const wo of record?.work_orders ?? []) {
+            if (!wo.repo)
+                continue;
+            if (!inputs.knownRepoIds.has(wo.repo)) {
+                unknownRepos.add(wo.repo);
+                continue;
+            }
+            const woStatus = wo.status === "agreed" || wo.status === "completed" ? wo.status : verdict === "PASS" && status === "archived" ? "completed" : "agreed";
+            workOrders.push({ id: `${id}__${wo.repo}`, change_id: id, repo_id: wo.repo, status: woStatus, source_sdd_id: "", platform_sdd_id: "" });
+        }
+        const proposal = await readText(join(changeDir, "proposal.md"));
+        for (const item of proposal === null ? [] : parseWorkItems(proposal)) {
+            workItems.push({ id: `${name}__${item}`, change_id: id, change_name: name, work_item_id: item, source_sdd_id: "", platform_sdd_id: "" });
+        }
+    };
     const pushEvent = (e) => {
         if (!inputs.knownRepoIds.has(e.repo)) {
             unknownRepos.add(e.repo);
@@ -123,21 +185,25 @@ export async function buildRequirements(inputs) {
         if (requirements.has(e.requirementId))
             events.push(e);
     };
-    // 2. Archived changes, in archive order.
-    for (const dir of await archiveOrder(sddPath, await dirs(join(store, "changes", "archive")), findings)) {
+    // 2. Archived changes, in archive order. A requirement is named as it was when each change archived, so its
+    // rows are carried forward through every later RENAMED (and one in the same change) to the name it has now;
+    // otherwise a rename would read as a requirement born at the rename, with no baseline.
+    const archived = [];
+    const renames = [];
+    const archives = await archiveOrder(sddPath, await dirs(join(store, "changes", "archive")), findings);
+    for (const [index, dir] of archives.entries()) {
         const changeDir = join(store, "changes", "archive", dir);
+        renames.push(await renamesOf(changeDir));
         const change = dir.replace(/^\d{4}-\d{2}-\d{2}-/, "");
         const archivedOn = /^(\d{4}-\d{2}-\d{2})-/.exec(dir)?.[1] ?? "";
         const evidence = await readText(join(changeDir, "baseline-evidence.md"));
         const kind = evidence !== null ? "baseline" : "change";
+        await recordChange(dir, change, kind, "archived", archivedOn, changeDir, await agreementRecord(sddPath, change));
         const delta = await deltaOf(changeDir);
         for (const d of delta) {
             if (d.operation === "REMOVED")
                 continue;
-            const requirementId = `${d.feature}::${d.name}`;
-            if (!requirements.has(requirementId))
-                continue;
-            lineage.push({ id: `${requirementId}__${dir}`, requirement_id: requirementId, change_id: dir, change_kind: kind, operation: d.operation, archived_on: archivedOn, source_sdd_id: "", platform_sdd_id: "" });
+            archived.push({ index, feature: d.feature, name: d.name, lineage: { change_id: dir, change_kind: kind, operation: d.operation, archived_on: archivedOn, source_sdd_id: "", platform_sdd_id: "" } });
         }
         if (evidence !== null) {
             const repos = observedIn(evidence);
@@ -147,7 +213,7 @@ export async function buildRequirements(inputs) {
             for (const repo of repos)
                 for (const d of delta)
                     if (d.operation !== "REMOVED")
-                        pushEvent({ requirementId: `${d.feature}::${d.name}`, repo, status: "observed", basis: dir });
+                        archived.push({ index, feature: d.feature, name: d.name, event: { repo, status: "observed", basis: dir } });
             continue;
         }
         const record = await agreementRecord(sddPath, change);
@@ -162,13 +228,43 @@ export async function buildRequirements(inputs) {
                     findings.add("convention", `${AGREEMENTS}/${change}.yaml: work order for ${wo.repo} implements "${name}", which the change's delta does not name`);
                 }
                 for (const d of match)
-                    pushEvent({ requirementId: `${d.feature}::${d.name}`, repo: wo.repo, status: "declared-shipped", basis: dir });
+                    archived.push({ index, feature: d.feature, name: d.name, event: { repo: wo.repo, status: "declared-shipped", basis: dir } });
             }
         }
     }
+    const current = (feature, name, from) => {
+        let n = name;
+        for (let j = from; j < renames.length; j++)
+            for (const r of renames[j])
+                if (r.feature === feature && r.from === n)
+                    n = r.to;
+        return `${feature}::${n}`;
+    };
+    // One lineage row per (requirement, change): a change that renames and modifies a requirement records MODIFIED,
+    // the behaviour change, and its delta still shows the rename.
+    const lineageById = new Map();
+    for (const a of archived) {
+        const requirementId = current(a.feature, a.name, a.index);
+        if (a.event)
+            pushEvent({ requirementId, ...a.event });
+        else if (a.lineage && requirements.has(requirementId)) {
+            const id = `${requirementId}__${a.lineage["change_id"]}`;
+            if (lineageById.get(id)?.["operation"] === "MODIFIED")
+                continue;
+            lineageById.set(id, { id, requirement_id: requirementId, ...a.lineage });
+        }
+    }
+    lineage.push(...lineageById.values());
     // 3. Open changes whose agreement record is agreed.
     for (const dir of (await dirs(join(store, "changes"))).filter((d) => d !== "archive")) {
         const record = await agreementRecord(sddPath, dir);
+        const openKind = (await readText(join(store, "changes", dir, "baseline-evidence.md"))) !== null ? "baseline" : "change";
+        let openStatus = record?.status ?? "proposed";
+        if (!CHANGE_STATUSES.has(openStatus)) {
+            findings.add("convention", `${AGREEMENTS}/${dir}.yaml: status "${openStatus}" is not a change status; catalogued as proposed`);
+            openStatus = "proposed";
+        }
+        await recordChange(dir, dir, openKind, openStatus, "", join(store, "changes", dir), record);
         if (record?.status !== "agreed")
             continue;
         const delta = await deltaOf(join(store, "changes", dir));
@@ -203,6 +299,9 @@ export async function buildRequirements(inputs) {
         requirements: [...requirements.values()].sort(byId),
         lineage,
         status: [...status.values()].sort(byId),
+        changes: changes.sort(byId),
+        workOrders: workOrders.sort(byId),
+        workItems: workItems.sort(byId),
     };
 }
 //# sourceMappingURL=requirements.js.map

package/dist/lib/catalogue/canonical-schema.yaml

@@ -7,7 +7,7 @@
 # Emitted by sdd-cli's YAML emitter with no line folding; the three header scalars are quoted for the
 # textual readers downstream. The one deliberate difference from the authored form is schema_status:
 # the authored form says canonical; a projection never does.
-schema_version: "4.1.0"
+schema_version: "4.2.0"
 schema_owner: "sdd-method"
 schema_status: "generated"
 enums:
@@ -643,6 +643,31 @@ enums:
     - value: observed
       description: Independent evidence from this repository's code matches (a baseline's characterization tests or a reverse snapshot).
     description: A requirement's status in one implementing repository (M-ADR 0221 §4.5).
+  change_status:
+    values:
+    - value: proposed
+      description: Open, with a proposed agreement record or none yet.
+    - value: agreed
+      description: "Open, with an agreed record: being built."
+    - value: superseded
+      description: Open, its record superseded by another change.
+    - value: withdrawn
+      description: Open, its record withdrawn.
+    - value: archived
+      description: Archived into the living specs.
+    description: Where a change stands (M-ADR 0222 §4.6, M-ADR 0223 §4.6).
+  judge_verdict:
+    values:
+    - value: PASS
+    - value: FAIL
+    description: The judge's verdict on a change (M-ADR 0223 §4.5).
+  work_order_status:
+    values:
+    - value: agreed
+      description: Agreed; the repository's work is not yet judged.
+    - value: completed
+      description: Marked completed by a passing judge.
+    description: A work order's status in its change's agreement record (M-ADR 0223 §4.2, §4.6).
 catalogues:
   domains:
     primary_key: id
@@ -4200,7 +4225,7 @@ catalogues:
     - name: change_id
       type: string
       nullable: false
-      description: The archived change's directory name (its archive date prefix included).
+      description: The archived change's directory name (its archive date prefix included); a changes.id.
     - name: change_kind
       type: string
       nullable: false
@@ -4226,6 +4251,9 @@ catalogues:
     - column: requirement_id
       references: requirements.id
       nullable: false
+    - column: change_id
+      references: changes.id
+      nullable: false
     column_enums:
       change_kind: enums.requirement_change_kind
       operation: enums.requirement_operation
@@ -4269,3 +4297,111 @@ catalogues:
       nullable: false
     column_enums:
       status: enums.requirement_status_value
+  changes:
+    primary_key: id
+    columns:
+    - name: id
+      type: string
+      nullable: false
+      description: "The change's directory name: the open change's name, or the archived change's directory (its archive date prefix included). requirement_lineage.change_id references it."
+    - name: name
+      type: string
+      nullable: false
+      description: "The change's name without the archive date prefix: the same before and after archive, so a work item that cites the change keeps its link."
+    - name: change_kind
+      type: string
+      nullable: false
+      description: "Bound to requirement_change_kind: baseline (it carries baseline-evidence.md) or change."
+    - name: status
+      type: string
+      nullable: false
+      description: "Bound to change_status: archived for an archived change; otherwise the agreement record's status, or proposed when there is no record yet."
+    - name: archived_on
+      type: string
+      nullable: true
+      description: The archive date (YYYY-MM-DD) from the archived change's directory name; empty for an open change.
+    - name: verdict
+      type: string
+      nullable: true
+      description: "Bound to judge_verdict: the agreement record's verdict result (M-ADR 0223 §4.6). Empty for a baseline, and for a change not yet judged."
+    - name: source_sdd_id
+      type: string
+      nullable: true
+      description: Originating SDD (stamped at aggregation; empty in a per-SDD build).
+    - name: platform_sdd_id
+      type: string
+      nullable: true
+      description: The platform SDD the row belongs to (stamped at aggregation).
+    description: "A change in the SDD's behaviour store (M-ADR 0223 §4.2), open or archived, including baseline changes. Derived, never authored: from the store's change directories and their agreement records (M-ADR 0222 §4.6)."
+    column_enums:
+      change_kind: enums.requirement_change_kind
+      status: enums.change_status
+      verdict: enums.judge_verdict
+  change_work_order:
+    primary_key: id
+    columns:
+    - name: id
+      type: string
+      nullable: false
+      description: <change_id>__<repo_id>.
+    - name: change_id
+      type: string
+      nullable: false
+    - name: repo_id
+      type: string
+      nullable: false
+      description: The repository the work order is for.
+    - name: status
+      type: string
+      nullable: false
+      description: "Bound to work_order_status: the record's status for the work order; a judge PASS marks it completed (M-ADR 0223 §4.6)."
+    - name: source_sdd_id
+      type: string
+      nullable: true
+      description: Originating SDD (stamped at aggregation; empty in a per-SDD build).
+    - name: platform_sdd_id
+      type: string
+      nullable: true
+      description: The platform SDD the row belongs to (stamped at aggregation).
+    description: "Edge: a change's work order for one implementing repository (M-ADR 0223 §4.2), from the change's agreement record. Derived, never authored."
+    foreign_keys:
+    - column: change_id
+      references: changes.id
+      nullable: false
+    - column: repo_id
+      references: repositories.id
+      nullable: false
+    column_enums:
+      status: enums.work_order_status
+  change_work_item:
+    primary_key: id
+    columns:
+    - name: id
+      type: string
+      nullable: false
+      description: "<change_name>__<work_item_id>: keyed by the change's undated name, so the row is the same before and after archive."
+    - name: change_id
+      type: string
+      nullable: false
+      description: "The change as it stands now: its open name, or its archive directory."
+    - name: change_name
+      type: string
+      nullable: false
+      description: The change's undated name.
+    - name: work_item_id
+      type: string
+      nullable: false
+      description: The work item's id in the adopter's work-item tool, as the proposal's Work Items section gives it.
+    - name: source_sdd_id
+      type: string
+      nullable: true
+      description: Originating SDD (stamped at aggregation; empty in a per-SDD build).
+    - name: platform_sdd_id
+      type: string
+      nullable: true
+      description: The platform SDD the row belongs to (stamped at aggregation).
+    description: "Annotation: a work item a change's proposal says it delivers (M-ADR 0223 §4.2), giving the roll-up from work item to changes to requirements. The work item's id is the adopter's work-item tool's (M-ADR 0035), so it has no foreign key."
+    foreign_keys:
+    - column: change_id
+      references: changes.id
+      nullable: false

package/dist/lib/catalogue/rubric-coverage-map.yaml

@@ -905,3 +905,31 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
+  changes:
+    kind: entity
+    scoring: not-applicable
+    reason: projected from the behaviour store, whose change gate and judge hold its quality (M-ADR 0222, M-ADR 0223)
+  change_work_order:
+    kind: edge
+    scoring: derived-edge
+    class: realisation
+    impact_flow: both
+    reason: derived from agreement records and verdicts
+  change_work_item:
+    kind: annotation
+    scoring: derived-edge
+    class: traceability
+    impact_flow: none
+    reason: derived from each change's proposal
+  change_status:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  judge_verdict:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  work_order_status:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact

package/dist/lib/intents/format.js

@@ -0,0 +1,77 @@
+// The intent artefact's shape (M-ADR 0227 §4.1), shared by the migration that writes intents and the check
+// that reads them. The section names and header lines are the shipped template's
+// (docs/method/methods/templates/intent-template.md), so a change there is a change here.
+export const INTENT_DIRS = ["content/method/intents", "content/product/intents"];
+export const INTENT_SECTIONS = [
+    "Problem",
+    "Proposed outcome",
+    "Affected users and systems",
+    "Constraints",
+    "Open questions",
+    "Decision to resolve in exploration",
+    "ADR requirement",
+    "Where it went",
+];
+/** Header fields of the retired Idea and the idea map: planning state, which belongs in the work item (§4.3). */
+export const PLANNING_FIELDS = [
+    "Status",
+    "Priority",
+    "Blocked by",
+    "Enables",
+    "Parent Idea",
+    "Child Ideas",
+    "Idea ID",
+    "Epic ID",
+    "Theme",
+];
+/** A "Where it went" line naming a path: "- `<path>` (<sdd-id>; <source>)". */
+export const WHERE_PATH_LINE = /^-\s+`([^`]+)`\s+\(([^;)]+);\s*([^)]+)\)\s*$/;
+/** "## 3. Why Explore This (Revised)" -> "why explore this". */
+export function normaliseHeading(h) {
+    return h
+        .replace(/^\s*\d+[A-Za-z]?(\.\d+)*\.?\s*/, "")
+        .replace(/\((revised|updated)\)\s*$/i, "")
+        .trim()
+        .toLowerCase();
+}
+export function parseMarkdown(text) {
+    const lines = text.split("\n");
+    let title = "";
+    const fields = new Map();
+    const sections = new Map();
+    const headings = [];
+    let current = null;
+    let buf = [];
+    const flush = () => {
+        if (current !== null) {
+            const prev = sections.get(current);
+            const body = buf.join("\n").trim();
+            sections.set(current, prev ? `${prev}\n\n${body}` : body);
+        }
+        buf = [];
+    };
+    for (const line of lines) {
+        const h1 = /^#\s+(.+?)\s*$/.exec(line);
+        if (h1 && !title && current === null) {
+            title = h1[1];
+            continue;
+        }
+        const h2 = /^##\s+(.+?)\s*$/.exec(line);
+        if (h2) {
+            flush();
+            headings.push(h2[1]);
+            current = normaliseHeading(h2[1]);
+            continue;
+        }
+        if (current === null) {
+            const f = /^\*\*([^*:]+):\*\*\s*(.*?)\s*$/.exec(line);
+            if (f)
+                fields.set(f[1].trim(), f[2]);
+            continue;
+        }
+        buf.push(line);
+    }
+    flush();
+    return { title, fields, sections, headings };
+}
+//# sourceMappingURL=format.js.map