@sdd-method/author-cli 0.2.0 → 0.4.0

package/dist/lib/catalogue/coverage-run.js

@@ -89,7 +89,7 @@ export async function runCatalogueCoverage(inputs, write) {
         const available = new Set(schema.catalogues.map((c) => c.name).filter((n) => present(n)));
         lines.push(...renderScoresCoverage(await runScoresCoverage(session, { tier, available, sddRoot }), tier));
         // Staleness VERDICTS — the second half of the fourteenth check's §4.5
-        // scope (ledger §3o), member-tier only with the aggregate skip stated.
+        // scope, member-tier only with the aggregate skip stated.
         // Same coverage class, same reporting-only staging as the rest of the
         // scores family.
         lines.push(...renderStalenessVerdicts(await runStalenessVerdicts(session, { tier, available, sddRoot }), tier));

package/dist/lib/catalogue/dedupe-keyed-tables.js

@@ -20,10 +20,9 @@
  *     `build` (where the offending SDD is unambiguous) instead of only at
  *     `aggregate`.
  *
- * Background: the method's coordination record feature-edge-cross-source-duplicate.
  * Sibling precedents (the unconditional-emit fixes whose per-walker dedup this
- * generalises across sources): `feature-grounding-collision-edges-coordination.md`
- * (0.30.2) and `capability-spec-collision-edges-coordination.md` (0.30.3).
+ * generalises across sources): the feature-grounding collision-edge fix
+ * (0.30.2) and the capability-spec collision-edge fix (0.30.3).
  */
 /**
  * Render a cell exactly as the CSV writer will, so two rows count as identical

package/dist/lib/catalogue/ext-id.js

@@ -12,12 +12,12 @@
 // carries (`name`), so the old→new map is a build artefact, not an authored
 // migration: `sdd-cli catalogue migration-map` emits it, and the exemption
 // loader consults it during the cut window (an authored exemption keyed by
-// a mapped old id is regenerable, NOT drift — the F30 rule at schema scale).
+// a mapped old id is regenerable, NOT drift — the regenerability rule at schema scale).
 /**
  * Normalise a declared diagram entry id to slug form. Camel humps split
- * BEFORE lowercasing (the F11a rule, matching the aggregator's resolver):
- * most SDD ids are hyphenated, and `bvfmGatewayFramework` must derive the
- * same identity the adjudicator resolves for it (`bvfm-gateway-framework`).
+ * BEFORE lowercasing (matching the aggregator's resolver):
+ * most SDD ids are hyphenated, and `posGatewayFramework` must derive the
+ * same identity the adjudicator resolves for it (`pos-gateway-framework`).
  */
 export function normaliseEntryId(entryId) {
     return entryId

package/dist/lib/catalogue/feature-grounding-aliases-loader.js

@@ -14,7 +14,7 @@
  *       AuthHandler: example-service-api
  *       web-ui: example-web-ui
  *     repo_aliases:
- *       camera-bff: global-camera-bff
+ *       stock-bff: northwind-stock-bff
  *
  * Either block is optional. Empty / missing file = no aliases (every
  * reference must resolve directly against the canonical id).

package/dist/lib/catalogue/finding-identity.js

@@ -1,6 +1,6 @@
 /**
  * Finding IDENTITY — the stable key a findings baseline is compared on, per
- * M-ADR 0132 §4.3 as amended, delivering the ruling recorded at ledger §3p.
+ * M-ADR 0132 §4.3 as amended.
  *
  * THE PROBLEM THIS EXISTS FOR, measured rather than asserted. A findings
  * baseline stores whole `[finding]` lines, so improving a message invalidates
@@ -17,7 +17,7 @@
  * files, 74 non-empty, 1,677 body lines — that works for 1,434 lines (85.5%)
  * and fails for 243 (14.5%), which embed their subject in prose:
  *
- *   [finding] orphan: repo integration-calamp resolves to no capability ...
+ *   [finding] orphan: repo integration-acme resolves to no capability ...
  *
  * One renderer template, all orphan class, spread across 62 repos. Recovering
  * identity there means teaching the comparator the renderer's message
@@ -30,7 +30,7 @@
  * baseline is reviewed by people and a side-channel nobody sees is a side
  * channel nobody maintains:
  *
- *   [finding] orphan (repo:integration-calamp): repo integration-calamp ...
+ *   [finding] orphan (repo:integration-acme): repo integration-acme ...
  *   [finding] divergence (docs/domains/asset/product/x.traceability.yaml): ...
  *
  * A finding with no declared subject renders EXACTLY as it does today. That is

package/dist/lib/catalogue/freshness.js

@@ -1,6 +1,6 @@
 /**
  * `catalogue build --check`: are the committed catalogues what the committed specs build to?
- * (M-ADR 0218 §5, bead sdm-jts.6.)
+ * (M-ADR 0218 §5.)
  *
  * Builds into a temporary directory and compares, so it writes nothing into the SDD. Only what
  * the build PRODUCES is compared: a hand-written file that happens to sit in catalogues/ (a

package/dist/lib/catalogue/manifest-loader.js

@@ -123,7 +123,7 @@ const DataPlaneSchema = z.object({
     bindings: z.array(DataPlaneBindingSchema),
     deviations: z.array(DataPlaneDeviationSchema).optional(),
 });
-// Conformance coverage (M-ADR 0191 §4.3, second overlay element — WS4). An
+// Conformance coverage (M-ADR 0191 §4.3, second overlay element). An
 // application-product asserts which of its archetype's conformance expectations
 // its own conformance suite exercises (`coverage`), and declares a rationale for
 // any expected tag it deliberately does not cover (`deviations`). The method
@@ -249,7 +249,7 @@ const ManifestSchema = z.object({
     // optional declared deviations from the archetype default, each carrying a
     // rationale so the mismatch is sanctioned variance, not silent drift.
     data_plane: DataPlaneSchema.optional(),
-    // Conformance coverage declaration (M-ADR 0191 §4.3 WS4, sdd-manifest-schema
+    // Conformance coverage declaration (M-ADR 0191 §4.3, sdd-manifest-schema
     // 1.5.0). Which archetype conformance expectations the product's suite
     // exercises, plus rationales for any it deliberately does not.
     conformance: ConformanceSchema.optional(),

package/dist/lib/catalogue/scaffold-delta.js

@@ -216,7 +216,7 @@ export async function runScaffoldDelta(session, options) {
 }
 /**
  * The delta's DEFECT classes are gate-acting (`divergence`), PROMOTED by a
- * recorded governance act after the M-ADR 0207 §4.9 pilot completed with no
+ * recorded method act after the M-ADR 0207 §4.9 pilot completed with no
  * surprise in any gated figure (2026-08-08) — the deliberate later act the
  * scores-coverage precedent reserves, performed. `scaffold-stale` stays
  * `coverage` with its staleness family: a stale anchor is a re-declare

package/dist/lib/catalogue/schema-compat.js

@@ -1,8 +1,7 @@
 /**
  * Per-schema compatibility ranges declared by this sdd-cli build.
  *
- * Per resolution of adopt-canonical-catalogue-builder.md §7.5, the three
- * sdd-method-distributed schemas version independently. The CLI declares
+ * The three sdd-method-distributed schemas version independently. The CLI declares
  * the version range it accepts for each and fails fast at read time on
  * out-of-range manifests.
  *

package/dist/lib/catalogue/screen-validation-loader.js

@@ -15,7 +15,7 @@
  *       - Divider
  *     archetype_overlays:               # per-platform overlay (ADR 0169 §4.3)
  *       web-generic:
- *         strip_prefixes: [Mdc, Mde]    # render-only: stripped when humanising labels
+ *         strip_prefixes: [Nwc, Nwe]    # render-only: stripped when humanising labels
  *         overrides:
  *           VBespokeGrid: grid
  *       swiftui:

package/dist/lib/catalogue/staleness-verdicts.js

@@ -1,5 +1,5 @@
-// Staleness VERDICTS — the second half of M-ADR 0205 §4.5's staleness scope
-// (ledger §3o): "staleness meaning corpus_ref older than the target's last
+// Staleness VERDICTS — the second half of M-ADR 0205 §4.5's staleness scope:
+// "staleness meaning corpus_ref older than the target's last
 // content change". The scores-coverage predicate computes each row's BASIS;
 // this module computes the VERDICT the basis supports. A stale score is worse
 // than a missing one, because it reads as coverage — the predicate otherwise

package/dist/lib/catalogue/traceability-loader.js

@@ -262,8 +262,7 @@ function extractContracts(raw) {
     // entries used to raise disappeared — the declarations became invisible
     // to row emission and to finding emission at once. The builder had been
     // taught the object form (contracts.ts) while its only feeder had not:
-    // the F36 shape again, one surface ahead of the pipeline that supplies
-    // it. `spicedb` was likewise never extracted, so `.zed` declarations
+    // a builder one surface ahead of the pipeline that supplies it. `spicedb` was likewise never extracted, so `.zed` declarations
     // never reached any builder even as bare strings.
     const arr = (key) => {
         const v = o[key];
@@ -282,7 +281,7 @@ function extractContracts(raw) {
     const graphql = arr("graphql");
     // `provenance` (3.5.0) MUST be extracted here or the builder that reads it
     // sees nothing — this function reconstructs the block key-by-key rather than
-    // passing the parsed object through, which is precisely the F36 shape the
+    // passing the parsed object through, which is precisely the shape the
     // comment above records. It was re-committed once during 3.5.0's own
     // implementation: the builder was taught to read provenance while this feeder
     // still dropped it, and only an end-to-end catalogue build caught it, because

package/dist/lib/conformance/index.js

@@ -19,7 +19,7 @@ const markdownProviderSignals = async (path, spec) => {
     const out = new Set();
     // `section` (ADR 0180 delta-pilot extension) scopes the scan to one heading block and accepts a plain
     // "Field" header, so a check can read ONE entity table inside a multi-table data-model doc (e.g.
-    // data-model.mermaid.md "### Collection: feature") without duplicating the field list into a bespoke
+    // data-model.mermaid.md "### Collection: orders") without duplicating the field list into a bespoke
     // surface file. With no `section` the behaviour is byte-for-byte the legacy one (whole file, strict
     // header, no `*` stripping) — existing gateway bindings are unaffected.
     const section = spec?.section;
@@ -35,7 +35,7 @@ const markdownProviderSignals = async (path, spec) => {
     for (const raw of (await readFile(path, "utf-8")).split("\n")) {
         const s = raw.trim();
         if (section && s.startsWith("#")) {
-            // strip leading #'s and any markdown code/emphasis in the title (`### Collection: ` + "`feature`")
+            // strip leading #'s and any markdown code/emphasis in the title (`### Collection: ` + "`orders`")
             inSection = s.replace(/^#+\s*/, "").replace(/[`*]/g, "").includes(section);
             inTable = false;
             continue;
@@ -61,7 +61,7 @@ const markdownProviderSignals = async (path, spec) => {
             if (!sig || sig === "—" || sig.startsWith("Computed") || sig.startsWith("MB "))
                 continue;
             sig = sig.replace(/\([^)]*\)/g, "").replace(/\[\]/g, "").trim(); // drop inline "(...)" notes + array markers
-            // Range shorthand: `datacoldTemp1..6` / `setpointTemp1..3` -> one declared name per index.
+            // Range shorthand: `sensor1..6` / `zone1..3` -> one declared name per index.
             const range = sig.match(/^(.*?)(\d+)\.\.(\d+)$/);
             if (range?.[1] !== undefined) {
                 const base = range[1];
@@ -369,7 +369,7 @@ const REGISTRY = {
 function norm(s, mode) {
     if (mode === "leaf") {
         // Match a nested/dotted declared path against a leaf code identifier: take the last dotted
-        // segment, drop array markers, then lower-nosep. `statusInfo.truStatus` ~ `truStatus`.
+        // segment, drop array markers, then lower-nosep. `order.status.code` ~ `code`.
         const leaf = s.split(".").pop() ?? s;
         return leaf.replace(/\[\]/g, "").replace(/[-_./ ]/g, "").toLowerCase();
     }
@@ -474,7 +474,28 @@ function printHuman(r, out) {
             out(`      - ${m}\n`);
     }
 }
-function printReconcile(chk, r, out) {
+/**
+ * Where the regenerated `produces` entries live: the spec's schema_dir, else the directory the binding's own
+ * declared entries already use (so a regenerated block keeps the adopter's layout), else `events`.
+ */
+async function reconcileSchemaDir(targetRepo, rc) {
+    if (rc.schema_dir)
+        return rc.schema_dir.replace(/\/+$/, "");
+    const path = isAbsolute(rc.binding) ? rc.binding : resolve(targetRepo, rc.binding);
+    try {
+        const doc = parseYaml(await readFile(path, "utf-8"));
+        for (const p of doc?.events?.produces ?? []) {
+            const s = p?.schema;
+            if (typeof s === "string" && s.includes("/"))
+                return s.slice(0, s.lastIndexOf("/"));
+        }
+    }
+    catch {
+        /* an unreadable binding falls through to the default */
+    }
+    return "events";
+}
+function printReconcile(chk, r, schemaDir, out) {
     if (!chk.reconcile || r.target !== "binding-vs-reality")
         return;
     const rc = chk.reconcile;
@@ -486,7 +507,7 @@ function printReconcile(chk, r, out) {
     out(`${rc.block.split(".")[0]}:\n`);
     out(`  produces:  # ${full.length} schemas (was ${r.declared} declared)\n`);
     for (const name of full)
-        out(`    - schema: party/events/${name}.avsc\n`);
+        out(`    - schema: ${schemaDir}/${name}.avsc\n`);
     if (r.declaredNotObserved.length) {
         out(`  # DROP (dangling — no such schema in code/contracts): ${r.declaredNotObserved.join(", ")}\n`);
     }
@@ -546,8 +567,8 @@ export async function runConformance(opts, stdout = (line) => process.stdout.wri
             printHuman(r, stdout);
             if (opts.reconcile) {
                 const chk = reconcileByline.get(r.id);
-                if (chk)
-                    printReconcile(chk, r, stdout);
+                if (chk?.reconcile)
+                    printReconcile(chk, r, await reconcileSchemaDir(opts.targetRepo, chk.reconcile), stdout);
             }
         }
         for (const id of skipped)

package/dist/lib/lock-file.js

@@ -215,7 +215,7 @@ function parseVersioned(raw) {
             // a YAML reader parses 113 of 325 entries in one real lock as MAPPINGS
             // rather than strings — silently, with no error. Quoting on write is the
             // fix; reading both forms ships first so no lock can be written that an
-            // older reader cannot parse. See method-open-items §3l.
+            // older reader cannot parse.
             const entry = stripQuotes(line.slice("      - ".length));
             const withDigest = DIGEST_ENTRY_RE.exec(entry);
             if (withDigest) {

package/dist/lib/package-version.js

@@ -83,7 +83,7 @@ export function getVerifyCliVersion() {
 }
 /**
  * The @sdd-method/maintain-cli version released WITH this sdd-cli. The managed CI workflow's
- * catalogue freshness step installs exactly this version (M-ADR 0218 §5; ruled 2026-10-15, sdm-jts.6).
+ * catalogue freshness step installs exactly this version (M-ADR 0218 §5).
  * Read the same way as the verify version, for the same reason (dist/ copy, never scripts/ live).
  */
 export function getMaintainCliVersion() {

package/dist/lib/snapshot/manifest.js

@@ -82,7 +82,7 @@ export async function readManifest(areaRoot, id) {
     }
     if (!Array.isArray(raw.members))
         problems.push("members must be a list");
-    // A hand-written revision of digits only (`50834756022`) parses as a NUMBER, and
+    // A hand-written revision of digits only (`12345678901`) parses as a NUMBER, and
     // a strict comparison with the folder's string suffix then calls an unchanged
     // member changed. Identity fields are strings, whatever YAML made of them.
     for (const m of raw.members ?? []) {

package/dist/lib/snapshot/targets.js

@@ -88,7 +88,7 @@ export function routeFinding(f, artefacts, shared = new Set()) {
     return [...targets.values()].sort((a, b) => (a.grain === b.grain ? a.artefact.localeCompare(b.artefact) : a.grain === "file" ? -1 : 1));
 }
 /**
- * Artefacts that mention a changed file by BASENAME only (`CollectorActor.java:49`) —
+ * Artefacts that mention a changed file by BASENAME only (`OrderHandler.java:49`) —
  * too ambiguous to route, too likely to matter to drop silently. Reported, not routed.
  */
 export function basenameOnly(f, artefacts, routed) {

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

@@ -0,0 +1,351 @@
+// Behaviour-store checks (M-ADR 0221, 0222, 0223): the gates OpenSpec itself does not enforce.
+//
+// An SDD's behaviour store is an OpenSpec project; in the inside-SDD shape it is `openspec/` at the
+// SDD root, with one agreement record per change at `docs/agreements/<change>.yaml`
+// (agreement-record-schema.yaml). OpenSpec checks the format of specs and deltas. It does not check
+// that a change was agreed before it was built, that the requirements it modifies stayed as they
+// were agreed, or that an archived change was judged. These are those checks:
+//
+//   1. records:  every agreement record has the shape the checks below read.
+//   2. agreement: an open change with any completed task has an agreed record and a Gate 0 that
+//                 ends CLEAR (the pre-apply check, M-ADR 0223 §4.3).
+//   3. stale:    for each open, agreed change that MODIFIES, REMOVES or RENAMES requirements, the
+//                 targeted living specs are unchanged since the agreed commit (M-ADR 0223 §4.5).
+//                 With no such targets the check is vacuous, and says so.
+//   4. verdicts: every archived change except a baseline has a verdict.md and a record whose
+//                 verdict is PASS and names it (M-ADR 0223 §4.6).
+//
+// A sibling-repository store (M-ADR 0221 §4.2) is checked in that repository, not here.
+//
+// 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.
+import { execFile } from "node:child_process";
+import { access, readdir, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { promisify } from "node:util";
+import { parseDocument } from "yaml";
+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";
+/** Telemetry off for every OpenSpec run the method makes. */
+export const OPENSPEC_ENV = { OPENSPEC_TELEMETRY: "0", DO_NOT_TRACK: "1" };
+export const STORE_DIR = "openspec";
+export const AGREEMENTS_DIR = "docs/agreements";
+const AGREEMENT_STATUSES = ["proposed", "agreed", "superseded", "withdrawn"];
+const COMMIT_RE = /^[0-9a-f]{7,40}$/;
+// OpenSpec counts a task done when its box holds only `x`, either case, any spacing.
+const TASK_DONE_RE = /^\s*-\s*\[\s*[xX]\s*\]/m;
+const TARGET_HEADING_RE = /^##\s+(MODIFIED|REMOVED|RENAMED)\s+Requirements\b/m;
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function dirs(p) {
+    try {
+        return (await readdir(p, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    }
+    catch {
+        return [];
+    }
+}
+async function readText(p) {
+    try {
+        return await readFile(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Read and shape-check one agreement record. Returns the record, or the problems found. */
+export function parseAgreementRecord(file, text) {
+    const problems = [];
+    const doc = parseDocument(text);
+    if (doc.errors.length > 0) {
+        return { problems: doc.errors.map((e) => `${file}: does not parse: ${e.message.split("\n")[0]}`) };
+    }
+    const root = doc.toJS();
+    const r = root?.agreement_record;
+    if (!r || typeof r !== "object")
+        return { problems: [`${file}: no top-level agreement_record`] };
+    const expected = basename(file).replace(/\.ya?ml$/, "");
+    if (r.change !== expected)
+        problems.push(`${file}: change is ${JSON.stringify(r.change)}, expected "${expected}" (the file name)`);
+    const status = typeof r.status === "string" ? r.status : "";
+    if (!AGREEMENT_STATUSES.includes(status)) {
+        problems.push(`${file}: status ${JSON.stringify(r.status)} is not one of ${AGREEMENT_STATUSES.join(" | ")}`);
+    }
+    const sdd = (r.sdd ?? {});
+    const gates = Array.isArray(r.gates) ? r.gates : [];
+    const gate0 = gates.find((g) => g && g.name === "gate-0");
+    if (status === "agreed") {
+        if (r.agreed_on === undefined || r.agreed_on === null)
+            problems.push(`${file}: agreed, but no agreed_on`);
+        if (typeof r.approved_by !== "string" || r.approved_by.trim() === "")
+            problems.push(`${file}: agreed, but no approved_by`);
+        if (typeof sdd.commit !== "string") {
+            problems.push(`${file}: sdd.commit must be a quoted string, found ${sdd.commit === undefined ? "nothing" : `${typeof sdd.commit} ${String(sdd.commit)}`}` +
+                (typeof sdd.commit === "number" ? " (unquoted, YAML parsed the SHA as a number)" : ""));
+        }
+        else if (!COMMIT_RE.test(sdd.commit)) {
+            problems.push(`${file}: sdd.commit "${sdd.commit}" is not 7-40 hex characters`);
+        }
+        if (!gate0)
+            problems.push(`${file}: agreed, but no gates entry named gate-0`);
+        else if (gate0.result !== "CLEAR")
+            problems.push(`${file}: agreed, but gate-0 result is ${JSON.stringify(gate0.result)}, not CLEAR`);
+    }
+    // Every commit a record pins must survive parsing as a string. YAML 1.2 reads an unquoted
+    // all-digit abbreviation as an integer and one shaped like `1234e567` or `123e456` as a float
+    // (Infinity), and the pin is then lost; checking the PARSED type is the only test that catches
+    // both, since a pattern applied after coercion sees "Infinity" or a number.
+    for (const [path, value] of commitFields(r)) {
+        if (path === "sdd.commit")
+            continue;
+        if (typeof value !== "string") {
+            problems.push(`${file}: ${path} must be a quoted string, found ${typeof value} ${String(value)} (unquoted, YAML parsed the SHA as a number)`);
+        }
+    }
+    const verdict = r.verdict && typeof r.verdict === "object" ? r.verdict : undefined;
+    if (problems.length > 0)
+        return { problems };
+    return {
+        record: {
+            file,
+            change: expected,
+            status,
+            ...(typeof sdd.commit === "string" ? { commit: sdd.commit } : {}),
+            ...(typeof gate0?.result === "string" ? { gate0: gate0.result } : {}),
+            ...(verdict ? { verdict } : {}),
+        },
+        problems,
+    };
+}
+/** Every pinned commit in a record: any key named `commit` or ending `_commit`, and each value under verdict.merged and current. */
+function commitFields(r) {
+    const out = [];
+    const walk = (v, path, pinMap) => {
+        if (Array.isArray(v))
+            v.forEach((x, i) => walk(x, `${path}[${i}]`, false));
+        else if (v && typeof v === "object") {
+            for (const [k, x] of Object.entries(v)) {
+                const p = path === "" ? k : `${path}.${k}`;
+                const isPin = pinMap || k === "commit" || k.endsWith("_commit");
+                if (isPin && (x === null || typeof x !== "object"))
+                    out.push([p, x]);
+                else
+                    walk(x, p, p === "verdict.merged" || p === "current");
+            }
+        }
+    };
+    walk(r, "", false);
+    return out;
+}
+function lastGateLine(text) {
+    const lines = text.split("\n").map((l) => l.trim()).filter((l) => l !== "");
+    return lines.at(-1) ?? "";
+}
+async function gitDiffQuiet(repo, commit, path) {
+    try {
+        await execFileAsync("git", ["-C", repo, "cat-file", "-e", `${commit}^{commit}`]);
+    }
+    catch {
+        return "unresolved";
+    }
+    try {
+        await execFileAsync("git", ["-C", repo, "diff", "--quiet", commit, "HEAD", "--", path]);
+        return "same";
+    }
+    catch (err) {
+        return err.code === 1 ? "changed" : "unresolved";
+    }
+}
+/** The living specs an open change's deltas modify, remove or rename: openspec/specs/<capability>/spec.md. */
+async function targetedSpecs(repo, changeDir) {
+    const out = [];
+    const walk = async (rel) => {
+        const abs = join(repo, changeDir, "specs", rel);
+        let entries;
+        try {
+            entries = await readdir(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const childRel = rel === "" ? e.name : `${rel}/${e.name}`;
+            if (e.isDirectory())
+                await walk(childRel);
+            else if (e.name === "spec.md") {
+                const text = (await readText(join(abs, e.name))) ?? "";
+                if (TARGET_HEADING_RE.test(text))
+                    out.push(`${STORE_DIR}/specs/${rel}/spec.md`);
+            }
+        }
+    };
+    await walk("");
+    return out.sort();
+}
+export async function checkBehaviourStore(repo) {
+    if (!(await exists(join(repo, STORE_DIR)))) {
+        return { exitCode: 0, stdout: `[N/A] no behaviour store (${STORE_DIR}/) in this repository\n` };
+    }
+    const lines = [];
+    const failures = [];
+    // 1. records
+    const records = new Map();
+    let recordFiles = [];
+    try {
+        recordFiles = (await readdir(join(repo, AGREEMENTS_DIR))).filter((f) => /\.ya?ml$/.test(f)).sort();
+    }
+    catch {
+        recordFiles = [];
+    }
+    for (const f of recordFiles) {
+        const rel = `${AGREEMENTS_DIR}/${f}`;
+        const { record, problems } = parseAgreementRecord(rel, (await readText(join(repo, rel))) ?? "");
+        failures.push(...problems);
+        if (record)
+            records.set(record.change, record);
+    }
+    lines.push(`records: ${recordFiles.length} agreement record(s), ${recordFiles.length - records.size} malformed`);
+    // 2 and 3. open changes
+    const open = (await dirs(join(repo, STORE_DIR, "changes"))).filter((d) => d !== "archive");
+    let started = 0;
+    let staleChecked = 0;
+    for (const change of open) {
+        const dir = `${STORE_DIR}/changes/${change}`;
+        const tasks = await readText(join(repo, dir, "tasks.md"));
+        const record = records.get(change);
+        if (tasks !== null && TASK_DONE_RE.test(tasks)) {
+            started++;
+            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`);
+            const gate = await readText(join(repo, dir, "gate-0.md"));
+            if (gate === null)
+                failures.push(`${dir}: has completed tasks but no gate-0.md`);
+            else if (lastGateLine(gate) !== "GATE: CLEAR")
+                failures.push(`${dir}: has completed tasks but gate-0.md ends "${lastGateLine(gate)}", not "GATE: CLEAR"`);
+        }
+        if (record?.status === "agreed" && record.commit) {
+            for (const spec of await targetedSpecs(repo, dir)) {
+                staleChecked++;
+                const r = await gitDiffQuiet(repo, record.commit, spec);
+                if (r === "changed")
+                    failures.push(`${dir}: STALE: ${spec} changed since the agreed commit ${record.commit}`);
+                if (r === "unresolved")
+                    failures.push(`${dir}: stale check unresolved: commit ${record.commit} is not in this clone's history (a shallow clone cannot run it)`);
+            }
+        }
+    }
+    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`);
+    // 4. archived changes
+    const archived = await dirs(join(repo, STORE_DIR, "changes", "archive"));
+    let baselines = 0;
+    for (const name of archived) {
+        const dir = `${STORE_DIR}/changes/archive/${name}`;
+        if (await exists(join(repo, dir, "baseline-evidence.md"))) {
+            baselines++;
+            continue;
+        }
+        const change = name.replace(/^\d{4}-\d{2}-\d{2}-/, "");
+        if (!(await exists(join(repo, dir, "verdict.md"))))
+            failures.push(`${dir}: archived without verdict.md`);
+        const record = records.get(change);
+        if (!record) {
+            failures.push(`${dir}: archived without an agreement record (${AGREEMENTS_DIR}/${change}.yaml)`);
+            continue;
+        }
+        if (record.verdict?.result !== "PASS")
+            failures.push(`${record.file}: change is archived but verdict.result is ${JSON.stringify(record.verdict?.result)}, not PASS`);
+        const vr = record.verdict?.record;
+        if (typeof vr !== "string" || !(await exists(join(repo, vr))))
+            failures.push(`${record.file}: verdict.record ${JSON.stringify(vr)} does not name an existing file`);
+    }
+    lines.push(`verdicts: ${archived.length} archived change(s), ${baselines} baseline(s), ${archived.length - baselines} needing a PASS verdict`);
+    const population = recordFiles.length + open.length + archived.length;
+    const body = lines.map((l) => `  ${l}`).join("\n") + "\n";
+    if (failures.length > 0) {
+        return { exitCode: 1, stdout: body + failures.map((f) => `[FAIL] ${f}`).join("\n") + "\n" };
+    }
+    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 and verdict checks hold\n" };
+}
+async function runOpenspec(repo, args) {
+    try {
+        const { stdout } = await execFileAsync("openspec", args, { cwd: repo, env: { ...process.env, ...OPENSPEC_ENV }, maxBuffer: 16 * 1024 * 1024 });
+        return { code: 0, json: JSON.parse(stdout), raw: stdout };
+    }
+    catch (err) {
+        const e = err;
+        let json;
+        try {
+            json = JSON.parse(e.stdout ?? "");
+        }
+        catch {
+            json = undefined;
+        }
+        return { code: typeof e.code === "number" ? e.code : 127, ...(json ? { json } : {}), raw: (e.stdout ?? "") + (e.stderr ?? "") };
+    }
+}
+/** OpenSpec's own strict validation of the store: specs and open changes, and archived changes' tasks. */
+export async function checkBehaviourStoreOpenspec(repo) {
+    if (!(await exists(join(repo, STORE_DIR)))) {
+        return { exitCode: 0, stdout: `[N/A] no behaviour store (${STORE_DIR}/) in this repository\n` };
+    }
+    let version = "";
+    try {
+        version = (await execFileAsync("openspec", ["--version"], { env: { ...process.env, ...OPENSPEC_ENV } })).stdout.trim();
+    }
+    catch {
+        return {
+            exitCode: 1,
+            stdout: `[FAIL] the OpenSpec CLI is not on PATH; this repository has a behaviour store, so its validation cannot run (install @fission-ai/openspec@${OPENSPEC_VERSION}; the Method Validation module does)\n`,
+        };
+    }
+    if (version !== OPENSPEC_VERSION) {
+        return { exitCode: 1, stdout: `[FAIL] OpenSpec ${version} is installed; the method depends on exactly ${OPENSPEC_VERSION}\n` };
+    }
+    const lines = [];
+    const failures = [];
+    let measured = 0;
+    for (const [label, args] of [
+        ["specs and open changes (--all --strict)", ["validate", "--all", "--strict", "--json", "--no-interactive"]],
+        ["archived changes' tasks (--archived)", ["validate", "--archived", "--json", "--no-interactive"]],
+    ]) {
+        const r = await runOpenspec(repo, [...args]);
+        const t = r.json?.summary?.totals;
+        if (!t) {
+            failures.push(`${label}: OpenSpec returned no report (exit ${r.code}): ${r.raw.trim().split("\n").slice(-3).join(" | ")}`);
+            continue;
+        }
+        measured += t.items ?? 0;
+        lines.push(`${label}: ${t.items ?? 0} item(s), ${t.passed ?? 0} passed, ${t.failed ?? 0} failed`);
+        for (const item of r.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 (r.code !== 0 && (t.failed ?? 0) === 0)
+            failures.push(`${label}: OpenSpec exited ${r.code} with no failed item reported`);
+    }
+    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" };
+    if (measured === 0)
+        return { exitCode: 0, stdout: body + "[N/A] OpenSpec found no specs and no changes to validate\n" };
+    return { exitCode: 0, stdout: body + "[PASS] OpenSpec strict validation holds\n" };
+}
+//# sourceMappingURL=behaviour-store.js.map