@sdd-method/maintain-cli 0.9.0 → 0.10.0

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/ci-binding/module.js

@@ -144,8 +144,10 @@ export class MethodValidation {
       if (code !== 0 && !step.advisory) failed++
       lines.push(verdict.padEnd(8) + " exit " + code + "  " + step.id + "  (" + step.title + ")")
       if (code !== 0 || measuredNothing) {
-        const out = (await ran.stdout()) + (await ran.stderr())
-        lines.push(...out.trim().split("\n").slice(-6).map((l) => "           " + l))
+        const out = ((await ran.stdout()) + (await ran.stderr())).trim().split("\n")
+        // Every failure line, then the step's last lines: a long report never hides a finding behind its tail.
+        const failures = out.filter((l) => /^\s*\[FAIL\] /.test(l))
+        lines.push(...[...failures, ...out.slice(-6).filter((l) => !failures.includes(l))].map((l) => "           " + l))
       }
     }
     lines.push(failed === 0 ? "RESULT: PASS" : "RESULT: FAIL (" + failed + " failing step(s))")

package/dist/lib/repo-kind.js

@@ -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",
@@ -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

@@ -1,4 +1,4 @@
-// Archetype behaviour, seeded once and then cited (reference architecture sdm-d93u.4.1).
+// 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
@@ -131,7 +131,7 @@ async function writeAt(path, content) {
 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" };
+        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` };
@@ -154,8 +154,10 @@ export async function seedArchetypeBehaviour(input) {
         `# ${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`). Checked by",
-        "# `sdd-cli validate --validator archetype-citations`: a changed source is reported until reviewed and re-pinned.",
+        "# 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 = [

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/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);
 /**
@@ -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):`));
@@ -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/validate/archetype-citations.js

@@ -11,6 +11,13 @@
 //               (move `digest` and `version`), or record that the estate departs.
 // A departed citation is never stale: departing is a decision, recorded with its reason, not drift. With no
 // citations anywhere the check reports [N/A], an empty population, not a pass.
+//
+// A digest must be a quoted string: YAML reads an unquoted all-digit value, or digits around one `e`, as a
+// number, which would compare as a false stale. A narrowed or extended citation may say why in `reason`
+// (`note` is read as the same). `not_adopted` records archetype requirements the estate has decided not to
+// take, each with its reason and decision; every id must resolve, and none may be both cited and not adopted.
+// A coverage line names the archetype requirements neither cited nor recorded as not adopted: the gaps, which
+// are reported, not failed, since an estate may be part-way through adopting.
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
@@ -92,12 +99,34 @@ export async function checkArchetypeCitations(repo) {
         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)
+        const notAdopted = Array.isArray(doc.not_adopted) ? doc.not_adopted : [];
+        if (cites.length === 0 && notAdopted.length === 0)
             bad("unresolved", `${rel}: lists no citations`);
+        const citedIds = new Set(cites.map((c) => String(c.cites)));
+        for (const n of notAdopted) {
+            total++;
+            const tag = `${rel}: not adopted ${String(n.cites)}`;
+            if (!byId.has(String(n.cites))) {
+                bad("unresolved", `${tag}: ${archetype.bundleName} ${at} has no archetype requirement ${String(n.cites)}`);
+            }
+            else if (!n.reason || !n.decision) {
+                bad("unresolved", `${tag}: a non-adoption needs its reason and the decision that took it`);
+            }
+            else if (citedIds.has(String(n.cites))) {
+                bad("unresolved", `${tag}: it is also cited; an archetype requirement is either answered or not adopted`);
+            }
+            else {
+                lines.push(`[ok] ${tag} (${String(n.reason)})`);
+            }
+        }
         for (const c of cites) {
             total++;
             const tag = `${rel}: '${String(c.requirement)}' -> ${String(c.cites)}`;
             const relation = String(c.relation);
+            if (typeof c.digest !== "string") {
+                bad("unresolved", `${tag}: digest must be a quoted string (YAML read ${String(c.digest)} as a ${typeof c.digest}); quote it`);
+                continue;
+            }
             if (!RELATIONS.includes(relation)) {
                 bad("unresolved", `${tag}: relation must be one of ${RELATIONS.join(", ")} (got ${relation})`);
                 continue;
@@ -122,9 +151,15 @@ export async function checkArchetypeCitations(repo) {
                 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 why = c.reason ?? c.note;
+                lines.push(`[ok] ${tag} (${relation}${why && relation !== "derived" ? `: ${String(why)}` : ""})`);
             }
         }
+        const answered = new Set([...citedIds, ...notAdopted.map((n) => String(n.cites))]);
+        const gaps = [...byId.keys()].filter((id) => !answered.has(id));
+        lines.push(`[coverage] ${rel}: ${byId.size - gaps.length} of ${byId.size} ${archetype.id} requirements answered ` +
+            `(${[...citedIds].filter((id) => byId.has(id)).length} cited, ${notAdopted.length} not adopted)` +
+            (gaps.length ? `; not yet answered: ${gaps.join(", ")}` : ""));
     }
     const verdict = problems
         ? `[FAIL] archetype citations: ${problems} of ${total} unresolved or stale`

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

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

package/dist/maintain-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.9.0",
-  "built_against_sdd_cli": "2.3.0"
+  "version": "0.10.0",
+  "built_against_sdd_cli": "2.4.0"
 }

package/dist/verify-version.json

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sdd-method/maintain-cli",
-  "version": "0.9.0",
-  "sddCliVersion": "2.3.0",
+  "version": "0.10.0",
+  "sddCliVersion": "2.4.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",