@sdd-method/author-cli 0.12.1 → 0.14.0

package/dist/lib/structure/extract.js

@@ -0,0 +1,123 @@
+// An SDD's first structural model, extracted from its sources (M-ADR 0230 §5.3, §6 step 1). The builders
+// already parse the sources: the diagrams, data models, service tables, configuration, traceability manifests,
+// feature trees and groundings. So extraction builds the catalogue from the sources into a scratch directory, and
+// projects the model it implies (modelFromRows). It writes the partition files and an extraction report beside
+// them, and touches no source file. From the moment openspec/structure/ exists, committed or not, the catalogue is
+// built from the model, so writing it is the admission: review the extraction against the code first, with --dry-run
+// (which writes nothing) or in a scratch copy, and keep the originals until that review is complete.
+import { execFileSync } from "node:child_process";
+import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runCatalogueBuild } from "../catalogue/build.js";
+import { readCatalogueCsv } from "../catalogue/csv-reader.js";
+import { loadCanonicalSchema } from "../catalogue/schema-loader.js";
+import { modelFileText, modelFromRows } from "./catalogue.js";
+import { STRUCTURE_DIR } from "./model.js";
+import { STRUCTURE } from "./view.js";
+export const REPORT_FILE = "extraction-report.md";
+/** Derived path columns of structure catalogues: the source files the elements were read from. */
+const SOURCE_PATH_COLUMNS = ["doc_path", "diagram_path", "spec_path"];
+function head(sddPath) {
+    try {
+        const sha = execFileSync("git", ["-C", sddPath, "rev-parse", "--short", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        const dirty = execFileSync("git", ["-C", sddPath, "status", "--porcelain"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() !== "";
+        return dirty ? `${sha}, with uncommitted changes` : sha;
+    }
+    catch {
+        return "not a git repository";
+    }
+}
+function report(sddId, at, schemaVersion, x, sources, otherFindings) {
+    const lines = [
+        "# Structural model extraction",
+        "",
+        `Extracted by \`sdd-cli migrate structure\` from ${sddId}'s sources at ${at}, against catalogue schema ${schemaVersion} (M-ADR 0230).`,
+        "",
+        "**Writing this model admits it as the baseline** (M-ADR 0230 §6 step 1). From the moment `openspec/structure/` exists, committed or not, it is the record of structure: the catalogue is built from it, and the structural-model check asks every open change for its structural deltas or a `none.yaml`, and fails a change that has neither. Review it against the code before it is written (`sdd-cli migrate structure --dry-run` prints this report and writes nothing), and keep the sources listed below until that review is complete; nothing here changed them. Removing `openspec/structure/` withdraws a model written too soon. After admission, structure changes only through a change's structural deltas, and the diagrams and tables are generated by `sdd-cli structure render`.",
+        "",
+        "## Elements",
+        "",
+        "| Catalogue | Elements |",
+        "| --- | --- |",
+        ...[...x.counts].map(([c, n]) => `| ${c} | ${n} |`),
+        "",
+        `Partitions: ${[...x.files.keys()].map((p) => `\`${p}\``).join(", ") || "none"}.`,
+        "",
+        "## What the extraction could not carry",
+        "",
+    ];
+    if (x.loss.length === 0 && x.extraction.length === 0)
+        lines.push("Nothing: every structural fact the sources state that a builder reads is in the model.", "");
+    for (const l of x.loss)
+        lines.push(`- ${l}`);
+    for (const f of x.extraction)
+        lines.push(`- ${f.summary}`);
+    if (x.loss.length + x.extraction.length > 0)
+        lines.push("");
+    lines.push("Prose, and anything a builder does not read, stays in the original files only. A diagram's layout and styling are not structure, and the generated views do not reproduce them.", "", "## Sources the elements were read from", "", ...(sources.length > 0 ? sources.map((s) => `- \`${s}\``) : ["- (no element names its source file)"]), "", "## Other findings of the build", "", ...(otherFindings.size > 0 ? [...otherFindings].map(([c, n]) => `- ${c}: ${n}`) : ["- none"]), "", "These are the build's findings about the sources. They are reported by `sdd-cli catalogue build` as before, and extraction does not change them.", "");
+    return lines.join("\n");
+}
+/** Extract the model. Writes nothing; `writeExtraction` writes it. `build` is the catalogue build, replaceable in tests. */
+export async function extractStructure(sddPath, build = runCatalogueBuild) {
+    const none = { files: new Map(), counts: new Map(), loss: [], extraction: [], report: "" };
+    try {
+        await readdir(join(sddPath, STRUCTURE_DIR));
+        return { ...none, refused: `${STRUCTURE_DIR}/ already exists; an SDD's first model is extracted once, and after that structure changes through a change's structural deltas` };
+    }
+    catch {
+        // no model yet
+    }
+    const schema = await loadCanonicalSchema();
+    const scratch = await mkdtemp(join(tmpdir(), "sdd-migrate-structure-"));
+    try {
+        const built = await build({ sddPath, outDir: scratch }, () => undefined);
+        if (built.exitCode !== 0) {
+            return { ...none, refused: `the sources do not build cleanly (sdd-cli catalogue build exits ${built.exitCode}: ${built.internalFkPass ? "" : "dangling references, "}${built.pkConflicts} key conflict(s)); a model extracted from them would carry the same faults. Fix the build first` };
+        }
+        const rows = new Map();
+        for (const c of schema.catalogues) {
+            if (c.sourceOfTruth !== STRUCTURE)
+                continue;
+            rows.set(c.name, (await readCatalogueCsv(join(scratch, `${c.name}.csv`)).catch(() => ({ rows: [] }))).rows);
+        }
+        const loss = [];
+        const model = modelFromRows(schema, rows, { platform: built.profile === "platform-profile", sddId: built.sddId }, loss);
+        const files = new Map([...model].sort(([a], [b]) => a.localeCompare(b)).map(([p, els]) => [p, modelFileText(p, els)]));
+        const counts = new Map();
+        for (const els of model.values())
+            for (const [c, list] of Object.entries(els))
+                counts.set(c, (counts.get(c) ?? 0) + list.length);
+        const sortedCounts = new Map([...counts].sort(([a], [b]) => a.localeCompare(b)));
+        const sources = new Set();
+        for (const list of rows.values())
+            for (const r of list)
+                for (const col of SOURCE_PATH_COLUMNS)
+                    if (r[col])
+                        sources.add(String(r[col]));
+        const extraction = built.findings.filter((f) => f.category === "extraction");
+        const other = new Map();
+        for (const f of built.findings)
+            if (f.category !== "extraction")
+                other.set(String(f.category), (other.get(String(f.category)) ?? 0) + 1);
+        const x = { files, counts: sortedCounts, loss, extraction };
+        return { ...x, refused: null, report: report(built.sddId, head(sddPath), schema.schemaVersion, x, [...sources].sort(), new Map([...other].sort())) };
+    }
+    finally {
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+/** Write the partition files and the report under openspec/structure/. Returns the paths written. */
+export async function writeExtraction(sddPath, x) {
+    const dir = join(sddPath, STRUCTURE_DIR);
+    await mkdir(dir, { recursive: true });
+    const written = [];
+    for (const [p, text] of x.files) {
+        await writeFile(join(dir, `${p}.yaml`), text, "utf8");
+        written.push(join(STRUCTURE_DIR, `${p}.yaml`));
+    }
+    await writeFile(join(dir, REPORT_FILE), x.report, "utf8");
+    written.push(join(STRUCTURE_DIR, REPORT_FILE));
+    return written;
+}
+//# sourceMappingURL=extract.js.map

package/dist/lib/structure/intended.js

@@ -0,0 +1,194 @@
+// What an open change adds, for the references its own content makes (M-ADR 0230 §4.7, §4.11 proof 3).
+// A reference made by an open change resolves against the current view plus that change's additions: the elements its
+// structural deltas ADD, those of the changes in its depends_on closure, and the contracts its agreement record agrees
+// as new files. A reference made by anything else resolves against the current view only, so a current reference that
+// resolves only against an addition is still refused.
+// What ties content to a change is never the reference being resolved:
+//   a model element                        the change's own delta (validateDeltas, viewAt)
+//   a source-built row with a change_id    that change
+//   a contract row                         the change whose record agrees its file as new
+//   a row naming such a contract           that change
+// Pure but for reading agreement records.
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseDocument } from "yaml";
+import { closure } from "./compose.js";
+import { elementKey, loadChangeStructure } from "./model.js";
+export const CONTRACTS = "contracts";
+const LIFECYCLES = ["proposed", "agreed", "withdrawn", "superseded"];
+/** The change's agreement record (docs/agreements/<change>.yaml): its status, or `unrecorded`, and its new contract files. */
+export async function readAgreement(repo, change) {
+    let text;
+    try {
+        text = await readFile(join(repo, "docs", "agreements", `${change}.yaml`), "utf8");
+    }
+    catch {
+        return { status: "unrecorded", newContracts: [] };
+    }
+    let record;
+    try {
+        record = parseDocument(text).toJS()?.agreement_record;
+    }
+    catch {
+        return { status: "unrecorded", newContracts: [] };
+    }
+    const status = LIFECYCLES.find((s) => s === String(record?.["status"] ?? "")) ?? "unrecorded";
+    const newContracts = [];
+    const entries = Array.isArray(record?.["contracts"]) ? record["contracts"] : [];
+    for (const raw of entries) {
+        if (raw === null || typeof raw !== "object")
+            continue;
+        const e = raw;
+        if (e["amended_by_this_change"] !== true)
+            continue;
+        const files = Array.isArray(e["files"]) ? e["files"].map(String) : e["file"] !== undefined ? [String(e["file"])] : [];
+        // agreement-record schema 1.2.0 and later: a file the change relies on carries relies_on, so an agreed file
+        // without one is new (1.3.0 states it). An entry with no agrees predates the digests and says nothing either way.
+        const digest = (field, f) => {
+            const v = e[field];
+            return v !== null && typeof v === "object" ? String(v[f] ?? "") : String(v ?? "");
+        };
+        for (const f of files)
+            if (digest("agrees", f) !== "" && digest("relies_on", f) === "")
+                newContracts.push(`${String(e["repo"] ?? "")}/${f}`);
+    }
+    return { status, newContracts };
+}
+/** The open changes (openspec/changes/<change>, not archive/), with their agreement records. */
+export async function loadOpenChanges(repo, problems) {
+    let names;
+    try {
+        names = (await readdir(join(repo, "openspec", "changes"), { withFileTypes: true }))
+            .filter((e) => e.isDirectory() && e.name !== "archive")
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        names = [];
+    }
+    const open = new Map();
+    const newContracts = new Map();
+    for (const name of names) {
+        const agreement = await readAgreement(repo, name);
+        open.set(name, { structure: await loadChangeStructure(repo, name, problems), status: agreement.status });
+        newContracts.set(name, agreement.newContracts);
+    }
+    return { open, newContracts };
+}
+const cell = (v) => (v === null || v === undefined ? "" : String(v));
+/**
+ * Each open change's additions, and the change that adds each. A contract is identified by its built row: the row
+ * whose spec_path is `<repo>/<file>` as the record names it. A new contract with no built row adds nothing, and a
+ * reference to it stays unresolved.
+ */
+export class Additions {
+    open;
+    own = new Map();
+    adder = new Map();
+    constructor(open, newContracts, contractRows) {
+        this.open = open;
+        const idByPath = new Map();
+        for (const r of contractRows)
+            if (cell(r["spec_path"]) !== "")
+                idByPath.set(cell(r["spec_path"]), cell(r["id"]));
+        for (const [name, oc] of open) {
+            const keys = new Set();
+            for (const d of oc.structure.deltas)
+                for (const e of d.added)
+                    keys.add(elementKey(e.catalogue, e.id));
+            for (const p of newContracts.get(name) ?? []) {
+                const id = idByPath.get(p);
+                if (id !== undefined && id !== "")
+                    keys.add(elementKey(CONTRACTS, id));
+            }
+            this.own.set(name, keys);
+            for (const k of keys)
+                if (!this.adder.has(k))
+                    this.adder.set(k, name);
+        }
+    }
+    /** The open change that adds the element or contract, if one does. */
+    addedBy(catalogue, id) {
+        return this.adder.get(elementKey(catalogue, id));
+    }
+    /** Whether the element or contract is the change's own addition or one of its dependency closure's. */
+    within(change, catalogue, id) {
+        const key = elementKey(catalogue, id);
+        return closure(change, this.open).some((c) => this.own.get(c)?.has(key) ?? false);
+    }
+    /** The contracts the given changes add. */
+    contracts(changes) {
+        const out = new Set();
+        for (const c of changes)
+            for (const k of this.own.get(c) ?? [])
+                if (k.startsWith(`${CONTRACTS}/`))
+                    out.add(k.slice(CONTRACTS.length + 1));
+        return out;
+    }
+    /** The open changes a source-built row belongs to: its change_id, or a new contract it is or names. */
+    ownersOf(schema, catalogue, row, sddId) {
+        const out = new Set();
+        const changeId = cell(row["change_id"]);
+        if (changeId !== "") {
+            const name = changeId.startsWith(`${sddId}::`) ? changeId.slice(sddId.length + 2) : changeId;
+            if (this.open.has(name))
+                out.add(name);
+        }
+        const contractOwner = (id) => {
+            const by = this.adder.get(elementKey(CONTRACTS, id));
+            if (by !== undefined)
+                out.add(by);
+        };
+        const cat = schema.catalogues.find((c) => c.name === catalogue);
+        if (catalogue === CONTRACTS && cat)
+            contractOwner(cell(row[cat.primaryKey]));
+        for (const fk of cat?.foreignKeys ?? [])
+            if (fk.references === `${CONTRACTS}.id` && cell(row[fk.column]) !== "")
+                contractOwner(cell(row[fk.column]));
+        return [...out].sort();
+    }
+}
+/**
+ * Sort a build's dangling references: a row an open change owns, naming that change's addition, resolves in that
+ * change's view. Every other stays dangling, including a row nothing ties to the change that adds its target.
+ */
+export function splitDangling(schema, rowsByCatalogue, failures, additions, sddId) {
+    const intended = [];
+    const dangling = [];
+    const index = new Map();
+    const rowOf = (catalogue, pk) => {
+        let byPk = index.get(catalogue);
+        if (!byPk) {
+            const key = schema.catalogues.find((c) => c.name === catalogue)?.primaryKey ?? "id";
+            byPk = new Map((rowsByCatalogue.get(catalogue) ?? []).map((r) => [cell(r[key]), r]));
+            index.set(catalogue, byPk);
+        }
+        return byPk.get(pk);
+    };
+    for (const f of failures) {
+        const [target, column] = f.target.split(".");
+        const targetPk = schema.catalogues.find((c) => c.name === target)?.primaryKey;
+        const row = rowOf(f.catalogue, f.referencingRow);
+        const owner = f.value === "" || column !== targetPk || row === undefined
+            ? undefined
+            : additions.ownersOf(schema, f.catalogue, row, sddId).find((c) => additions.within(c, target, f.value));
+        if (owner !== undefined)
+            intended.push({ failure: f, change: owner });
+        else {
+            const by = f.value === "" ? undefined : additions.addedBy(target, f.value);
+            dangling.push(by === undefined ? { failure: f } : { failure: f, addedBy: by });
+        }
+    }
+    return { intended, dangling };
+}
+/** Element key -> the agreed change that adds or modifies it, and the element as that change states it. */
+export function intendedWrites(open, agreed) {
+    const out = new Map();
+    for (const c of agreed) {
+        for (const d of open.get(c)?.structure.deltas ?? [])
+            for (const e of [...d.added, ...d.modified])
+                out.set(elementKey(e.catalogue, e.id), { change: c, element: e });
+    }
+    return out;
+}
+//# sourceMappingURL=intended.js.map

package/dist/lib/structure/model.js

@@ -1,4 +1,4 @@
-// The structural model and a change's structural deltas (M-ADR 0230 §4.3, §4.4, Proposed). Pure reads, so the
+// The structural model and a change's structural deltas (M-ADR 0230 §4.3, §4.4). Pure reads, so the
 // verify-only CLI can carry them. The format is docs/method/methods/guides/structural-model-format.md:
 //   openspec/structure/<partition>.yaml                    the model, one file per partition
 //   openspec/changes/<change>/structure/<partition>.yaml   a change's delta for that partition

package/dist/lib/structure/render.js

@@ -1,4 +1,4 @@
-// The generated views of the structural model (M-ADR 0230 §4.3, Proposed): projections, never edited. Each file is
+// The generated views of the structural model (M-ADR 0230 §4.3): projections, never edited. Each file is
 // rendered from the current view alone, in id order, so the same model renders the same bytes. Its first line names
 // the generator and the digest of the body below it, which tells three states apart:
 //   missing      the file is absent

package/dist/lib/structure/view.js

@@ -121,7 +121,12 @@ function naturalKey(cat, e) {
  * catalogue of another class, against its built rows), no cycle through a self-reference, natural keys unique, and
  * domain invariants naming their entity's own attributes and relationships.
  */
-export function validateView(schema, view, built, problems, unresolved) {
+export function validateView(schema, view, built, problems, unresolved, addedBy = () => undefined) {
+    // A reference to an open change's addition, from outside that change and its dependants (§4.11 proof 3).
+    const outside = (catalogue, id) => {
+        const by = addedBy(catalogue, id);
+        return by === undefined ? "" : `; open change ${by} adds it, and only that change and those depending on it can name it`;
+    };
     for (const [catalogue, byId] of view) {
         const cat = catalogueOf(schema, catalogue);
         for (const e of byId.values()) {
@@ -133,14 +138,14 @@ export function validateView(schema, view, built, problems, unresolved) {
             for (const r of referencesOf(schema, e)) {
                 if (r.structural) {
                     if (!find(view, r.catalogue, r.targetColumn, r.value))
-                        problems.push(`${e.file}: ${elementKey(catalogue, e.id)}: ${r.column} ${JSON.stringify(r.value)} names no ${r.catalogue} element in this view (${elementKey(r.catalogue, r.value)})`);
+                        problems.push(`${e.file}: ${elementKey(catalogue, e.id)}: ${r.column} ${JSON.stringify(r.value)} names no ${r.catalogue} element in this view (${elementKey(r.catalogue, r.value)})${r.targetColumn === "id" ? outside(r.catalogue, r.value) : ""}`);
                 }
                 else {
                     const rows = built(r.catalogue, r.targetColumn);
                     if (rows === null)
                         unresolved.add(r.catalogue);
                     else if (!rows.has(r.value))
-                        problems.push(`${e.file}: ${elementKey(catalogue, e.id)}: ${r.column} ${JSON.stringify(r.value)} names no row of ${r.catalogue} as built`);
+                        problems.push(`${e.file}: ${elementKey(catalogue, e.id)}: ${r.column} ${JSON.stringify(r.value)} names no row of ${r.catalogue} as built${outside(r.catalogue, r.value)}`);
                 }
             }
         }

package/dist/lib/validate/agreement-evidence.js

@@ -3,7 +3,7 @@
 //
 //   agreed content   the change's proposal, deltas, Gate 0, design, tasks (checkboxes ignored), the test plan's
 //                    scenario-to-test rows (its Before and After cells ignored) and its structural deltas with their
-//                    base revisions (M-ADR 0230 §4.4, Proposed; report only until it is accepted) are what was approved. Each is compared
+//                    base revisions (M-ADR 0230 §4.4; report only until it is accepted) are what was approved. Each is compared
 //                    with its state at the record's pinned commit: the latest amendment's commit, else sdd.commit.
 //   requirement      a requirement's block in a spec: its heading to the next requirement or section heading. The
 //                    stale check compares the blocks a change targets, not the whole file.
@@ -16,7 +16,7 @@ export function boundFile(rel) {
     return /^(proposal|design|gate-0|tasks|test-plan)\.md$/.test(rel) || /^specs\/.+\/spec\.md$/.test(rel) || structuralFile(rel);
 }
 /**
- * A change's structural artifact (M-ADR 0230 §4.4, Proposed): a partition delta or the no-op claim, both agreed
+ * A change's structural artifact (M-ADR 0230 §4.4): a partition delta or the no-op claim, both agreed
  * content, so a delta's base revisions are pinned with it. The effect record (structure/applied.yaml) is written by
  * the archive, after agreement, and is not.
  */

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

@@ -16,10 +16,12 @@
 //                 check is vacuous, and says so.
 //      agreed content: the change's proposal, deltas, Gate 0, design, tasks (checkboxes ignored), test
 //                 plan (its execution results ignored) and structural deltas equal their state at that commit
-//                 (M-ADR 0222 §4.6; a structural delta's change is a [WARN] while M-ADR 0230 is Proposed).
+//                 (M-ADR 0222 §4.6; a structural delta's change fails like the rest, a [WARN] only with ENFORCED false).
 //      kinds:    on a record held to 1.1.0, each test-plan row's Kind (changed or carried) is the one computed
-//                 from the deltas and the living spec, a row naming no scenario of the deltas fails, and a
-//                 filled Before is a fail for changed and a pass for carried (M-ADR 0223 §4.4).
+//                 from the deltas and the living spec, or repaired (declared, on a carried scenario); a row
+//                 naming no scenario of the deltas fails; and a filled Before, read as whole-word results, is a
+//                 fail for changed, a pass for carried, and a fail citing the test double's correcting commit
+//                 for repaired (M-ADR 0223 §4.4).
 //   4. verdicts: every archived change except a baseline has a verdict.md whose verdict line agrees with
 //                 its record's PASS (M-ADR 0223 §4.6). A record held to 1.1.0 (by its own history, or by the
 //                 schema the SDD shipped when the change archived) also needs: an agreed record; archived
@@ -186,6 +188,16 @@ export function parseAgreementRecord(file, text) {
                     noLongerImplements.push({ repo: e.repo, requirement: e.requirement });
             }
     }
+    // Record 1.3.0 (M-ADR 0230 §4.2): a contracts entry may deprecate its version, stating the sunset. A
+    // deprecation that names no date states no runway, so it is refused rather than read as a deprecation without one.
+    for (const [i, x] of (Array.isArray(r.contracts) ? r.contracts : []).entries()) {
+        const d = x?.deprecates;
+        if (d === undefined)
+            continue;
+        const sunset = d?.sunset;
+        if (typeof sunset !== "string" || !isCalendarDate(sunset))
+            problems.push(`${file}: contracts[${i}].deprecates must be {sunset: YYYY-MM-DD}, a calendar date as a string; found ${JSON.stringify(d)}`);
+    }
     if (problems.length > 0)
         return { problems };
     return {
@@ -205,6 +217,13 @@ export function parseAgreementRecord(file, text) {
         problems,
     };
 }
+/** A YYYY-MM-DD string naming a day that exists. */
+function isCalendarDate(s) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(s))
+        return false;
+    const t = new Date(`${s}T00:00:00Z`);
+    return !Number.isNaN(t.getTime()) && t.toISOString().slice(0, 10) === s;
+}
 /** 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 = [];
@@ -489,7 +508,7 @@ export async function checkBehaviourStore(repo, options = {}) {
                         if (a === null || b === null || normaliseBound(f, a) !== normaliseBound(f, b)) {
                             const what = `${dir}: AGREED CONTENT CHANGED: ${f} ${a === null ? "was added" : b === null ? "was removed" : "differs"} since ${base}, with no amendment recording a commit and an approver; amend the agreement or renew it (M-ADR 0222 §4.6)`;
                             if (structuralFile(f) && !STRUCTURE_ENFORCED)
-                                warnings.push(`${what}; a structural delta, report only while M-ADR 0230 is Proposed`);
+                                warnings.push(`${what}; a structural delta, reported only because ENFORCED is off`);
                             else
                                 failures.push(what);
                         }
@@ -497,14 +516,14 @@ export async function checkBehaviourStore(repo, options = {}) {
                 }
             }
         }
-        // A test plan's kinds (M-ADR 0223 §4.4 as amended): changed scenarios go red then green, carried ones stay green.
+        // A test plan's kinds (M-ADR 0223 §4.4 as amended): changed and repaired scenarios go red then green, carried ones stay green.
         if (versionAtLeast(record?.schemaVersion, "1.1.0") && record?.status === "agreed") {
             const plan = await readText(join(repo, dir, "test-plan.md"));
             if (plan !== null) {
                 const header = testPlanHeader(plan);
                 const col = (name) => header.indexOf(name);
                 if (col("kind") < 0)
-                    failures.push(`${dir}/test-plan.md: the scenario table has no Kind column (changed | carried)`);
+                    failures.push(`${dir}/test-plan.md: the scenario table has no Kind column (changed | carried | repaired)`);
                 else {
                     for (const row of testPlanMapping(plan)) {
                         const cell = row[col("requirement")] ?? "";
@@ -533,13 +552,31 @@ export async function checkBehaviourStore(repo, options = {}) {
                             continue;
                         }
                         kindsChecked++;
-                        if (kind !== expected)
+                        // `repaired` is declared, never computed: a carried scenario whose earlier pass was false-green.
+                        const repaired = kind === "repaired";
+                        if (repaired && expected === "changed")
+                            failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is changed against the living spec, so it cannot be repaired: repaired is a scenario carried as the living spec states it, whose code did not meet it`);
+                        else if (!repaired && kind !== expected)
                             failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is ${expected} against the living spec, and the plan says ${JSON.stringify(kind)}`);
                         const before = col("before") >= 0 ? (row[col("before")] ?? "") : "";
-                        if (before !== "" && expected === "changed" && !/fail|red/i.test(before))
-                            failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is changed, so its test fails before the code; the scenario table's Before cell says ${JSON.stringify(before)}`);
-                        if (before !== "" && expected === "carried" && !/pass|green/i.test(before))
-                            failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is carried, so its test passes before the code as regression; the scenario table's Before cell says ${JSON.stringify(before)}`);
+                        if (before !== "") {
+                            // The cell's results, as whole words: "PASS at x; FAIL at y" holds both, and "setup required" or "bypass" holds neither.
+                            const pass = /\b(?:pass(?:es|ed)?|green)\b/i.test(before);
+                            const fail = /\b(?:fail(?:s|ed)?|red)\b/i.test(before);
+                            const said = `the scenario table's Before cell says ${JSON.stringify(before)}`;
+                            if (repaired) {
+                                if (!fail)
+                                    failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is repaired, so its test fails before the code; ${said}`);
+                                else if (!/\b[0-9a-f]{7,40}\b/i.test(before))
+                                    failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is repaired, so its Before cell cites the commit that corrects the test double, with its own red run; ${said}`);
+                            }
+                            else if (expected === "changed" && (!fail || pass)) {
+                                failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is changed, so its test fails before the code${pass && fail ? ", and a cell holding both results is not a result" : ""}; ${said}`);
+                            }
+                            else if (expected === "carried" && (!pass || fail)) {
+                                failures.push(`${dir}/test-plan.md: "${req}" / "${scen}" is carried, so its test passes before the code as regression${fail ? "; if its earlier pass was false-green, declare it repaired and cite the commit that corrects the test double" : ""}; ${said}`);
+                            }
+                        }
                     }
                 }
             }
@@ -640,7 +677,7 @@ export async function checkBehaviourStore(repo, options = {}) {
                 if (a === null || b === null || normaliseBound(f, a) !== normaliseBound(f, b)) {
                     const what = `${dir}: AGREED CONTENT CHANGED: ${f} ${a === null ? "was added" : b === null ? "was removed" : "differs"} from what was agreed at ${base}, with no amendment recording a commit and an approver (M-ADR 0222 §4.6)`;
                     if (structuralFile(f) && !STRUCTURE_ENFORCED)
-                        warnings.push(`${what}; a structural delta, report only while M-ADR 0230 is Proposed`);
+                        warnings.push(`${what}; a structural delta, reported only because ENFORCED is off`);
                     else
                         failures.push(what);
                 }

package/dist/lib/validate/dispatch.js

@@ -37,13 +37,13 @@ const BEHAVIOUR_STORE_VALIDATORS = [
         source: { kind: "native", run: async (ctx) => checkFeatureSpecPointers(ctx.targetRepo) },
         build: () => ({ status: "run", args: [] }),
     },
-    // The journeys a change can break, and whether its proposal names them (M-ADR 0229 §4.5, Proposed). Report only; [N/A] without journeys.
+    // The journeys a change can break, and whether its proposal names them (M-ADR 0229 §4.5). Report only; [N/A] without journeys.
     {
         name: "journey-impact",
         source: { kind: "native", run: async (ctx) => checkJourneyImpact(ctx.targetRepo) },
         build: () => ({ status: "run", args: [] }),
     },
-    // The structural model and each open change's structural artifact (M-ADR 0230, Proposed). Report only; [N/A] without a model.
+    // The structural model and each open change's structural artifact (M-ADR 0230). Report only; [N/A] without a model.
     {
         name: "structural-model",
         source: { kind: "native", run: async (ctx) => checkStructuralModel(ctx.targetRepo) },

package/dist/lib/validate/journey-impact.js

@@ -1,5 +1,5 @@
-// journey-impact: the journeys a change can break, and whether its proposal names them (M-ADR 0229 §4.5, Proposed).
-// Report only (M-ADR 0229 §4.5, Proposed): every finding is a [WARN] and the check exits 0. Gate 0 carries this report; nothing
+// journey-impact: the journeys a change can break, and whether its proposal names them (M-ADR 0229 §4.5).
+// Report only (M-ADR 0229 §4.5): every finding is a [WARN] and the check exits 0. Gate 0 carries this report; nothing
 // blocks on it, and the judge does not fail a change for it.
 //
 // For each open change in the behaviour store (openspec/changes/<change>/, not the archive):
@@ -14,8 +14,8 @@
 // with no reason is reported too.
 //
 // Also reported: a journey citing a requirement of a feature its journey_feature rows do not name (one record or
-// the other is wrong, M-ADR 0229 §4.4, Proposed); and an SDD with catalogued journeys whose manifest declares no journey master and that names no
-// platform it inherits from (an unresolved root, M-ADR 0229 §4.2, Proposed). A member that names its platform inherits the
+// the other is wrong, M-ADR 0229 §4.4); and an SDD with catalogued journeys whose manifest declares no journey master and that names no
+// platform it inherits from (an unresolved root, M-ADR 0229 §4.2). A member that names its platform inherits the
 // root's declaration, which is checked at the root.
 //
 // Reads the aggregated catalogue (catalogues-aggregated/*.csv) where this SDD has one, since a root's changes can
@@ -100,7 +100,7 @@ export async function checkJourneyImpact(repo) {
     else if (platform)
         lines.push(`journey master: not declared here; inherited from platform ${platform}, where it is checked`);
     else
-        warnings.push(`.sdd/sdd-manifest.yaml: ${journeys.length} catalogued journey(s) and no journey master (journeys.master: test-file or store), and no platform to inherit one from: unresolved (M-ADR 0229 §4.2, Proposed)`);
+        warnings.push(`.sdd/sdd-manifest.yaml: ${journeys.length} catalogued journey(s) and no journey master (journeys.master: test-file or store), and no platform to inherit one from: unresolved (M-ADR 0229 §4.2)`);
     const jr = await csv(repo, "journey_requirement", dir);
     const jf = (await csv(repo, "journey_feature", dir)) ?? [];
     const featureKinds = new Map(((await csv(repo, "features", dir)) ?? []).map((f) => [f["id"], f["kind"] ?? ""]));
@@ -137,7 +137,7 @@ export async function checkJourneyImpact(repo) {
         if (touched.get(r["journey_id"])?.has(feature) || mismatched.has(key))
             continue;
         mismatched.add(key);
-        warnings.push(`journey ${r["journey_id"]} cites requirements of ${feature}, which its journey_feature rows do not name: the journey's related features or its tags are wrong (M-ADR 0229 §4.4, Proposed)`);
+        warnings.push(`journey ${r["journey_id"]} cites requirements of ${feature}, which its journey_feature rows do not name: the journey's related features or its tags are wrong (M-ADR 0229 §4.4)`);
     }
     const untracedCount = journeys.filter((j) => !traced.has(j["id"])).length;
     lines.push(`journeys: ${journeys.length} catalogued, ${journeys.length - untracedCount} traced to requirements, ${untracedCount} untraced`);
@@ -203,6 +203,6 @@ export async function checkJourneyImpact(repo) {
     const body = lines.map((l) => `${l}\n`).join("");
     if (warnings.length === 0)
         return { exitCode: 0, stdout: `journey-impact:\n${body}[PASS] journey-impact: every listed journey is named\n` };
-    return { exitCode: 0, stdout: `journey-impact:\n${body}${warnings.map((w) => `[WARN] ${w}\n`).join("")}[WARN] journey-impact: ${warnings.length} finding(s), report only (M-ADR 0229 §4.5, Proposed)\n` };
+    return { exitCode: 0, stdout: `journey-impact:\n${body}${warnings.map((w) => `[WARN] ${w}\n`).join("")}[WARN] journey-impact: ${warnings.length} finding(s), report only (M-ADR 0229 §4.5)\n` };
 }
 //# sourceMappingURL=journey-impact.js.map