@sdd-method/maintain-cli 0.11.0 → 0.13.0

package/dist/lib/catalogue/builders/journey-requirement.js

@@ -0,0 +1,144 @@
+// journey_requirement: the requirements a user journey cites for its steps (M-ADR 0229 §4.4, Proposed; schema 4.4.0).
+//
+// Derived, never authored, from either master (§4.2):
+//   tag       option A: the end-to-end `.feature` files under the manifest's `journeys.test_paths`. A file tagged
+//             `@journey:<journey-id>` cites every `@req:<feature-id>/<requirement-slug>` tag it carries.
+//   citation  option B: the living spec (openspec/specs/<feature-id>/spec.md) of a feature of kind journey names its
+//             journey with the same `@journey:<journey-id>` tag and cites each step's requirement with `@req:`.
+// One tag grammar for both, so the derivation needs only the files and the catalogue's rows. Both are read whenever
+// present, so an estate moving from A to B shows both while it moves.
+//
+// A requirement tag cannot carry spaces, so it names the requirement by slug: its name lower-cased, each run of
+// anything but a-z and 0-9 turned into one hyphen. A tag resolves when exactly one requirement of that feature,
+// living or agreed (not retired), has that slug; a tag naming a retired requirement names none, so it is a finding. A tag that resolves to none or to several, a file with two journey tags, or a test
+// path that does not exist is a finding and produces no row, so no foreign key dangles. A tag naming a feature or a
+// journey this catalogue does not hold is reported as external: journeys are often catalogued in application SDDs
+// and requirements in the platform's store, so the row is derived at aggregation, where both are merged
+// (catalogue aggregate re-runs this builder over each contributor). A journey with no row is untraced, which the
+// journey-impact check reports.
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+const REQ_TAG = /@req:([a-z0-9][a-z0-9-]*)\/([a-z0-9][a-z0-9-]*)/g;
+const JOURNEY_TAG = /@journey:([a-z0-9][a-z0-9-]*)/g;
+/** "Order shipped (REST)" -> "order-shipped-rest". */
+export function requirementSlug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function featureFiles(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (e.name === "node_modules" || e.name.startsWith("."))
+            continue;
+        const p = join(dir, e.name);
+        if (e.isDirectory())
+            out.push(...(await featureFiles(p)));
+        else if (e.isFile() && e.name.endsWith(".feature"))
+            out.push(p);
+    }
+    return out.sort();
+}
+export async function buildJourneyRequirement(inputs) {
+    // At aggregation the member builds have already reported every finding about their own files and features.
+    const atAggregate = inputs.reportedFeatureIds !== undefined;
+    const { sddPath, findings } = inputs;
+    const bySlug = new Map();
+    for (const r of inputs.requirements) {
+        if (String(r["stage"] ?? "") === "retired")
+            continue; // a journey step cannot rely on behaviour that has been removed
+        const key = `${String(r["feature_id"])}/${requirementSlug(String(r["name"]))}`;
+        const ids = bySlug.get(key) ?? [];
+        if (!ids.includes(String(r["id"])))
+            ids.push(String(r["id"]));
+        bySlug.set(key, ids);
+    }
+    const rows = new Map();
+    const knownFeatures = new Set(inputs.features.map((f) => String(f["id"])));
+    const cite = (journeyId, text, where, basis) => {
+        for (const m of text.matchAll(REQ_TAG)) {
+            const quiet = atAggregate && inputs.reportedFeatureIds.has(m[1]);
+            if (!knownFeatures.has(m[1])) {
+                findings.add("external", `${where}: @req:${m[1]}/${m[2]} names a feature this catalogue does not hold; resolves at aggregation (M-ADR 0229 §4.4, Proposed)`);
+                continue;
+            }
+            const ids = bySlug.get(`${m[1]}/${m[2]}`) ?? [];
+            if (ids.length !== 1) {
+                if (!quiet)
+                    findings.add("orphan", `${where}: @req:${m[1]}/${m[2]} ${ids.length === 0 ? "names no requirement of that feature" : `matches ${ids.length} requirements of that feature`}; no journey_requirement row (M-ADR 0229 §4.4, Proposed)`);
+                continue;
+            }
+            const id = `${journeyId}__${ids[0]}`;
+            if (!rows.has(id))
+                rows.set(id, { id, journey_id: journeyId, requirement_id: ids[0], basis, source_sdd_id: "", platform_sdd_id: "" });
+        }
+    };
+    // Option A: tagged end-to-end files.
+    for (const rel of inputs.testPaths) {
+        const dir = join(sddPath, rel);
+        const exists = await stat(dir).then((s) => s.isDirectory(), () => false);
+        if (!exists) {
+            if (!atAggregate)
+                findings.add("orphan", `.sdd/sdd-manifest.yaml: journeys.test_paths names ${rel}, which is not a directory in this SDD`);
+            continue;
+        }
+        for (const file of await featureFiles(dir)) {
+            const where = relative(sddPath, file);
+            const text = await readFile(file, "utf8");
+            const journeys = [...new Set([...text.matchAll(JOURNEY_TAG)].map((m) => m[1]))];
+            if (journeys.length === 0)
+                continue;
+            if (journeys.length > 1) {
+                if (!atAggregate)
+                    findings.add("divergence", `${where}: tagged with ${journeys.length} journeys (${journeys.join(", ")}); one file is one journey's master (M-ADR 0229 §4.2, Proposed)`);
+                continue;
+            }
+            const journeyId = journeys[0];
+            if (!inputs.knownJourneyIds.has(journeyId)) {
+                findings.add("external", `${where}: @journey:${journeyId} is not a user journey this catalogue holds; resolves at aggregation`);
+                continue;
+            }
+            cite(journeyId, text, where, "tag");
+        }
+    }
+    // Option B: journey features in the store, each naming its journey in its living spec.
+    const kindById = new Map(inputs.features.map((f) => [String(f["id"]), String(f["kind"] ?? "")]));
+    let specDirs = [];
+    try {
+        specDirs = (await readdir(join(sddPath, "openspec", "specs"), { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    }
+    catch {
+        // no store here
+    }
+    for (const featureId of specDirs) {
+        if (kindById.get(featureId) !== "journey")
+            continue;
+        const where = join("openspec", "specs", featureId, "spec.md");
+        let spec;
+        try {
+            spec = await readFile(join(sddPath, where), "utf8");
+        }
+        catch {
+            continue;
+        }
+        const journeys = [...new Set([...spec.matchAll(JOURNEY_TAG)].map((m) => m[1]))];
+        if (journeys.length !== 1) {
+            if (!atAggregate)
+                findings.add(journeys.length === 0 ? "orphan" : "divergence", `${where}: a journey feature's living spec ${journeys.length === 0 ? "names no journey (@journey:<journey-id>)" : `names ${journeys.length} journeys`}; one journey feature masters one journey (M-ADR 0229 §4.2, Proposed)`);
+            continue;
+        }
+        const journeyId = journeys[0];
+        if (!inputs.knownJourneyIds.has(journeyId)) {
+            findings.add("external", `${where}: @journey:${journeyId} is not a user journey this catalogue holds; resolves at aggregation`);
+            continue;
+        }
+        cite(journeyId, spec, where, "citation");
+    }
+    return [...rows.values()].sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+}
+//# sourceMappingURL=journey-requirement.js.map

package/dist/lib/catalogue/builders/quality-scores.js

@@ -118,6 +118,19 @@ const num = (v) => {
     }
     return null;
 };
+/**
+ * The review's other assessed inputs (M-ADR 0230 §4.9, Proposed): `inputs:` as a list of paths, or of `{path}`
+ * entries, each read at the review's corpus_ref. ';'-joined; null when the review names none.
+ */
+function inputPaths(v) {
+    if (!Array.isArray(v))
+        return null;
+    const paths = v
+        .map((x) => (typeof x === "string" ? x : isRecord(x) && typeof x["path"] === "string" ? x["path"] : ""))
+        .map((x) => x.trim())
+        .filter((x) => x !== "");
+    return paths.length > 0 ? paths.join(";") : null;
+}
 /**
  * Count raised flags across the two authored dialects:
  *   `flags: { over_scope_risk: true, ... }`  -> count the true ones
@@ -258,6 +271,7 @@ function bandedRows(block, ctx) {
         band_total: num(block["total"]),
         scored_at: ctx.scoredAt,
         corpus_ref: ctx.corpusRef,
+        input_paths: ctx.inputPaths,
         staleness_basis: stalenessBasis,
         review_run_id: null,
         selection_method: null,
@@ -371,6 +385,7 @@ export async function buildQualityScores(inputs) {
                             targetPath,
                             scoredAt: fileScoredAt,
                             corpusRef,
+                            inputPaths: inputPaths(unitVal["inputs"]),
                             assessedBy: fileAssessedBy,
                             sddId,
                         });
@@ -396,6 +411,7 @@ export async function buildQualityScores(inputs) {
                         targetPath: str(unitVal["doc_path"]),
                         scoredAt: str(current["scored_at"]) ?? fileScoredAt,
                         corpusRef,
+                        inputPaths: inputPaths(current["inputs"] ?? unitVal["inputs"]),
                         assessedBy: fileAssessedBy,
                         sddId,
                     });
@@ -540,6 +556,7 @@ export async function buildQualityScores(inputs) {
                 band_total: null,
                 scored_at: str(current["scored_at"]) ?? str(entryVal["scored_at"]),
                 corpus_ref: corpusRef,
+                input_paths: inputPaths(current["inputs"] ?? entryVal["inputs"]),
                 staleness_basis: stalenessBasis,
                 review_run_id: str(current["review_run_id"]),
                 selection_method: selectionMethod,

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

@@ -7,18 +7,28 @@
 //   requirements        one row per `### Requirement:` in a living spec (stage living), keyed by the spec's
 //                       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, under any name a later RENAMED gave it. A change carrying
+//   requirement_lineage each archived change, in archive order, whose delta ADDED, MODIFIED, RENAMED or REMOVED a
+//                       requirement, under any name a later RENAMED gave it. A change carrying
 //                       baseline-evidence.md is a baseline. Statuses follow renames the same way.
+//                       A requirement REMOVED by an archived change and not in a living spec now is kept in
+//                       requirements as stage retired (schema 4.3.0), so its lineage ends in the REMOVED row;
+//                       it carries no status.
 //   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;
+//   requirement_revisions  one row per distinct text of a requirement (schema 6.0.0, M-ADR 0230 §4.7, Proposed): the
+//                       living spec's is current, an agreed open change's ADDED or MODIFIED block intended, an
+//                       archived change's block the living spec no longer holds history. Identified by its digest.
+//   requirement_assertions per (revision, 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.
-//                       The latest event wins, archived changes in archive order, then open changes.
+//                       its work orders' `implements` lists; each about the revision that change's delta states, so
+//                       evidence about one revision is never read as evidence about another. The latest wins, in
+//                       archive order. An agreed change is not an assertion: it is an intended revision.
+//   change_effects      per (change, element): each requirement a change's delta writes, from its base revision to
+//                       its target, open and archived changes alike; and each structural element its structural
+//                       deltas write (an archived change's from its effect record, structure/applied.yaml).
 //
 // Archive order is ../../behaviour-store/archive.ts's; same-day archives the history cannot order are a finding.
 //
@@ -26,8 +36,25 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { observedIn, orderArchives, parseRequirements, renamePairs } from "../../behaviour-store/archive.js";
-export { observedIn, parseRequirements };
+import { createHash } from "node:crypto";
+import { observedIn, orderArchives, parseRequirements, renamePairs, resolveImplements } from "../../behaviour-store/archive.js";
+import { effectsOf, parseAppliedRecord } from "../../structure/effects.js";
+import { APPLIED_FILE, loadChangeStructure, loadModel } from "../../structure/model.js";
+import { viewOf } from "../../structure/view.js";
+import { requirementBlock } from "../../validate/agreement-evidence.js";
+export { observedIn, parseRequirements, resolveImplements };
+/** `sha256:` of a requirement block, its lines trimmed and blank lines dropped (M-ADR 0230 §4.7). */
+export function requirementDigest(spec, name) {
+    const block = requirementBlock(spec, name);
+    if (block === null)
+        return undefined;
+    const normal = block.split("\n").map((l) => l.trim()).filter((l) => l !== "").join("\n");
+    return `sha256:${createHash("sha256").update(normal, "utf8").digest("hex")}`;
+}
+/** A revision's id: <requirement_id>@<the digest's first 12 hex digits>. */
+export function revisionId(requirementId, digest) {
+    return `${requirementId}@${digest.slice("sha256:".length, "sha256:".length + 12)}`;
+}
 const STORE = "openspec";
 const AGREEMENTS = join("docs", "agreements");
 async function isDir(p) {
@@ -62,8 +89,10 @@ async function deltaOf(changeDir) {
         if (text === null)
             continue;
         for (const r of parseRequirements(text)) {
-            if (r.operation)
-                out.push({ feature, name: r.name, operation: r.operation, file, scenarios: r.scenarios });
+            if (!r.operation)
+                continue;
+            const digest = r.operation === "ADDED" || r.operation === "MODIFIED" ? requirementDigest(text, r.name) : undefined;
+            out.push({ feature, name: r.name, operation: r.operation, file, scenarios: r.scenarios, ...(digest ? { digest } : {}) });
         }
     }
     return out;
@@ -123,13 +152,24 @@ export function parseWorkItems(proposal) {
     return ids;
 }
 const rel = (sddPath, p) => p.slice(sddPath.length + 1).split("\\").join("/");
+/** One effect per (change, element): a change that renames and modifies a requirement records MODIFIED, as its lineage does. */
+function dedupeEffects(rows) {
+    const byId = new Map();
+    for (const r of rows) {
+        const prior = byId.get(String(r["id"]));
+        byId.set(String(r["id"]), prior && r["operation"] === "RENAMED" ? prior : r);
+    }
+    return [...byId.values()];
+}
 export async function buildRequirements(inputs) {
     const { sddPath, findings } = inputs;
-    const empty = { requirements: [], lineage: [], status: [], changes: [], workOrders: [], workItems: [] };
+    const scoped = (change) => `${inputs.sddId}::${change}`;
+    const empty = { requirements: [], lineage: [], revisions: [], assertions: [], effects: [], changes: [], workOrders: [], workItems: [] };
     const store = join(sddPath, STORE);
     if (!(await isDir(store)))
         return empty;
     const requirements = new Map();
+    const livingDigest = new Map();
     const unknownFeatures = new Set();
     const known = (feature) => {
         if (inputs.knownFeatureIds.has(feature))
@@ -150,17 +190,35 @@ export async function buildRequirements(inputs) {
                 continue;
             }
             requirements.set(id, { id, feature_id: feature, name: r.name, stage: "living", spec_path: rel(sddPath, file), scenario_count: r.scenarios, source_sdd_id: "", platform_sdd_id: "" });
+            const digest = requirementDigest(text, r.name);
+            if (digest)
+                livingDigest.set(id, digest);
         }
     }
     const events = [];
+    const revisions = new Map();
+    const requirementEffects = [];
+    const structureEffects = [];
+    const effectRow = (changeId, kind, element, operation, base, target) => ({
+        id: `${changeId}__${kind}__${element}`,
+        change_id: changeId,
+        element_kind: kind,
+        element_id: element,
+        operation,
+        base_revision: base,
+        target_revision: target,
+        source_sdd_id: "",
+        platform_sdd_id: "",
+    });
     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 recordChange = async (localId, name, kind, status, archivedOn, changeDir, record) => {
         const verdict = record?.verdict?.result === "PASS" || record?.verdict?.result === "FAIL" ? record.verdict.result : "";
+        const id = scoped(localId);
         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)
@@ -174,7 +232,7 @@ export async function buildRequirements(inputs) {
         }
         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: "" });
+            workItems.push({ id: `${scoped(name)}__${item}`, change_id: id, change_name: name, work_item_id: item, source_sdd_id: "", platform_sdd_id: "" });
         }
     };
     const pushEvent = (e) => {
@@ -182,7 +240,8 @@ export async function buildRequirements(inputs) {
             unknownRepos.add(e.repo);
             return;
         }
-        if (requirements.has(e.requirementId))
+        // A retired requirement has no status: it is not where any repository's behaviour is.
+        if (requirements.has(e.requirementId) && requirements.get(e.requirementId)["stage"] !== "retired")
             events.push(e);
     };
     // 2. Archived changes, in archive order. A requirement is named as it was when each change archived, so its
@@ -201,10 +260,20 @@ export async function buildRequirements(inputs) {
         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;
-            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: "" } });
+            archived.push({
+                index,
+                feature: d.feature,
+                name: d.name,
+                lineage: { change_id: scoped(dir), change_kind: kind, operation: d.operation, archived_on: archivedOn, source_sdd_id: "", platform_sdd_id: "" },
+                ...(d.operation === "REMOVED" ? { removedIn: rel(sddPath, d.file) } : {}),
+            });
+            archived.push({ index, feature: d.feature, name: d.name, effect: { change: scoped(dir), operation: d.operation, ...(d.digest ? { digest: d.digest } : {}) } });
         }
+        // Structural effects, from the effect record the method's archive wrote (M-ADR 0230 §4.6).
+        const applied = await readText(join(changeDir, "structure", APPLIED_FILE));
+        const rec = applied === null ? null : parseAppliedRecord(applied);
+        for (const e of rec?.effects ?? [])
+            structureEffects.push(effectRow(scoped(dir), "structure", e.element, e.operation, e.base ?? "", e.target ?? ""));
         if (evidence !== null) {
             const repos = observedIn(evidence);
             if (repos.length === 0) {
@@ -212,8 +281,8 @@ export async function buildRequirements(inputs) {
             }
             for (const repo of repos)
                 for (const d of delta)
-                    if (d.operation !== "REMOVED")
-                        archived.push({ index, feature: d.feature, name: d.name, event: { repo, status: "observed", basis: dir } });
+                    if (d.digest)
+                        archived.push({ index, feature: d.feature, name: d.name, event: { repo, status: "observed", basis: scoped(dir), digest: d.digest } });
             continue;
         }
         const record = await agreementRecord(sddPath, change);
@@ -223,12 +292,17 @@ export async function buildRequirements(inputs) {
             if (!wo.repo)
                 continue;
             for (const name of wo.implements ?? []) {
-                const match = delta.filter((d) => d.name === name && d.operation !== "REMOVED");
-                if (match.length === 0) {
+                const { matches, ambiguous } = resolveImplements(delta.filter((d) => d.operation !== "REMOVED"), name);
+                const match = matches;
+                if (ambiguous.length > 0) {
+                    findings.add("divergence", `${AGREEMENTS}/${change}.yaml: work order for ${wo.repo} implements "${name}", a name ${ambiguous.length} features in the change share (${ambiguous.join(", ")}); qualify it as <feature>::<name>. No status is derived from it`);
+                }
+                else if (match.length === 0) {
                     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)
-                    archived.push({ index, feature: d.feature, name: d.name, event: { repo: wo.repo, status: "declared-shipped", basis: dir } });
+                    if (d.digest)
+                        archived.push({ index, feature: d.feature, name: d.name, event: { repo: wo.repo, status: "declared-shipped", basis: scoped(dir), digest: d.digest } });
             }
         }
     }
@@ -240,11 +314,37 @@ export async function buildRequirements(inputs) {
                     n = r.to;
         return `${feature}::${n}`;
     };
+    // A requirement removed and not living now is retired: kept, so its lineage can end in the removal.
+    for (const a of archived) {
+        if (!a.removedIn)
+            continue;
+        const id = current(a.feature, a.name, a.index);
+        if (requirements.has(id) || !known(a.feature))
+            continue;
+        requirements.set(id, { id, feature_id: a.feature, name: id.slice(a.feature.length + 2), stage: "retired", spec_path: a.removedIn, scenario_count: 0, source_sdd_id: "", platform_sdd_id: "" });
+    }
     // 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();
+    // Revisions in archive order: each ADDED or MODIFIED block is a revision its change introduced; the last one of a
+    // requirement is the base of the next change's effect on it.
+    const latest = new Map();
     for (const a of archived) {
         const requirementId = current(a.feature, a.name, a.index);
+        if (a.effect) {
+            if (!requirements.has(requirementId))
+                continue;
+            const base = latest.get(requirementId);
+            const target = a.effect.digest ? revisionId(requirementId, a.effect.digest) : undefined;
+            if (a.effect.digest && target) {
+                revisions.set(target, { id: target, requirement_id: requirementId, digest: a.effect.digest, state: "history", change_id: a.effect.change, source_sdd_id: "", platform_sdd_id: "" });
+                latest.set(requirementId, target);
+            }
+            if (a.effect.operation === "REMOVED")
+                latest.delete(requirementId);
+            requirementEffects.push(effectRow(a.effect.change, "requirement", requirementId, a.effect.operation, base ?? "", a.effect.operation === "RENAMED" ? base ?? "" : target ?? ""));
+            continue;
+        }
         if (a.event)
             pushEvent({ requirementId, ...a.event });
         else if (a.lineage && requirements.has(requirementId)) {
@@ -255,6 +355,12 @@ export async function buildRequirements(inputs) {
         }
     }
     lineage.push(...lineageById.values());
+    // The living text is the current revision, whichever change introduced it (none, for an edit no change made).
+    for (const [id, digest] of livingDigest) {
+        const rid = revisionId(id, digest);
+        const prior = revisions.get(rid);
+        revisions.set(rid, { id: rid, requirement_id: id, digest, state: "current", change_id: prior?.["change_id"] ?? "", source_sdd_id: "", platform_sdd_id: "" });
+    }
     // 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);
@@ -265,40 +371,70 @@ export async function buildRequirements(inputs) {
             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));
+        const agreed = record?.status === "agreed";
         for (const d of delta) {
             const id = `${d.feature}::${d.name}`;
-            if (d.operation === "ADDED" && !requirements.has(id) && known(d.feature)) {
+            if (agreed && d.operation === "ADDED" && !requirements.has(id) && known(d.feature)) {
                 requirements.set(id, { id, feature_id: d.feature, name: d.name, stage: "agreed", spec_path: rel(sddPath, d.file), scenario_count: d.scenarios, source_sdd_id: "", platform_sdd_id: "" });
             }
+            // An effect for every element the change writes: a requirement a change not yet agreed ADDs has no
+            // requirements row yet, and still has its effect (change_effects.element_id names no foreign key).
+            if (!requirements.has(id) && !(d.operation === "ADDED" && known(d.feature)))
+                continue;
+            const living = livingDigest.get(id);
+            const base = living ? revisionId(id, living) : "";
+            const target = d.digest ? revisionId(id, d.digest) : "";
+            // An agreed change's text is an intended revision; one not yet agreed has an effect and no revision row.
+            if (agreed && d.digest && !revisions.has(target)) {
+                revisions.set(target, { id: target, requirement_id: id, digest: d.digest, state: "intended", change_id: scoped(dir), source_sdd_id: "", platform_sdd_id: "" });
+            }
+            requirementEffects.push(effectRow(scoped(dir), "requirement", id, d.operation, d.operation === "ADDED" ? "" : base, d.operation === "REMOVED" ? "" : d.operation === "RENAMED" ? base : target));
         }
+        if (!agreed)
+            continue;
         for (const wo of record.work_orders ?? []) {
             if (!wo.repo)
                 continue;
             for (const name of wo.implements ?? []) {
-                for (const d of delta.filter((x) => x.name === name && x.operation !== "REMOVED")) {
-                    pushEvent({ requirementId: `${d.feature}::${d.name}`, repo: wo.repo, status: "agreed", basis: dir });
+                const { ambiguous } = resolveImplements(delta.filter((x) => x.operation !== "REMOVED"), name);
+                if (ambiguous.length > 0) {
+                    findings.add("divergence", `${AGREEMENTS}/${dir}.yaml: work order for ${wo.repo} implements "${name}", a name ${ambiguous.length} features in the change share (${ambiguous.join(", ")}); qualify it as <feature>::<name>`);
                 }
             }
         }
     }
+    // Open changes' structural effects, against the model as it stands (M-ADR 0230 §4.4, §4.7).
+    {
+        const problems = [];
+        const files = await loadModel(sddPath, problems);
+        const view = viewOf(files ?? [], problems);
+        for (const dir of (await dirs(join(store, "changes"))).filter((d) => d !== "archive")) {
+            const s = await loadChangeStructure(sddPath, dir, problems);
+            for (const e of effectsOf(s, view))
+                structureEffects.push(effectRow(scoped(dir), "structure", e.element, e.operation, e.base ?? "", e.target ?? ""));
+        }
+    }
     for (const f of unknownFeatures)
         findings.add("convention", `${STORE}/: a spec keyed "${f}" names no catalogue feature, so its requirements are not catalogued (M-ADR 0221 §4.7)`);
     for (const r of unknownRepos)
-        findings.add("convention", `${STORE}/: a status names repository "${r}", which the catalogue does not hold; no status row`);
-    // Latest event per (requirement, repository) wins.
-    const status = new Map();
+        findings.add("convention", `${STORE}/: an assertion names repository "${r}", which the catalogue does not hold; no assertion row`);
+    // Latest assertion per (revision, repository) wins.
+    const assertions = new Map();
     for (const e of events) {
-        const id = `${e.requirementId}__${e.repo}`;
-        status.set(id, { id, requirement_id: e.requirementId, repo_id: e.repo, status: e.status, basis: e.basis, source_sdd_id: "", platform_sdd_id: "" });
+        const rid = revisionId(e.requirementId, e.digest);
+        if (!revisions.has(rid))
+            continue;
+        const id = `${rid}__${e.repo}`;
+        assertions.set(id, { id, revision_id: rid, requirement_id: e.requirementId, repo_id: e.repo, kind: e.status, basis: e.basis, source_sdd_id: "", platform_sdd_id: "" });
     }
     const byId = (a, b) => String(a["id"]).localeCompare(String(b["id"]));
     return {
         requirements: [...requirements.values()].sort(byId),
         lineage,
-        status: [...status.values()].sort(byId),
+        revisions: [...revisions.values()].sort(byId),
+        assertions: [...assertions.values()].sort(byId),
+        effects: [...dedupeEffects(requirementEffects), ...structureEffects].sort(byId),
         changes: changes.sort(byId),
         workOrders: workOrders.sort(byId),
         workItems: workItems.sort(byId),