@sdd-method/verify-cli 5.5.1 → 5.7.0

package/dist/lib/derived-specs/source-path.js

@@ -0,0 +1,275 @@
+// The Source-path grammar of M-ADR 0232 §4.2: the address of one node in a derived source, on a derived spec's `Source:`
+// line, in a features map and in `shared:`. It is the grammar the first adopter's declaration module measured over its
+// declarations, adopted here unchanged so that a path its deriver writes parses and resolves identically in this check:
+//
+//   path     = "" | step *( "." name | "[" selector "]" )
+//   step     = name | "[" selector "]"
+//   name     = 1*( any character but "." "[" "]" )      ; a map entry under that string key
+//   selector = quoted                                    ; a map entry under a string key a name cannot spell
+//            | "#" 1*DIGIT                               ; a list element by its 0-based position
+//            | key *( ";" field "=" value )              ; a list element by its declared key and qualifiers, or, with no
+//                                                        ;   qualifiers and under a map, the entry under a NON-string key
+//   quoted   = DQUOTE *( "\" ( DQUOTE | "\" ) | any but DQUOTE and "\" ) DQUOTE
+//
+// A list's key fields are declared (the source's `keys:`, by the list's pattern: its path with every element step written
+// `[]`), first the key, then the qualifiers; no field is guessed. A selector that matches no element or more than one is
+// refused, never a first match. The canonical form of a list element is its key with the fewest leading qualifiers that make
+// it unique, else its position; a position where a key would do is refused, and so is any position where `positions` is false
+// (the features map and `shared:`, which a reorder would silently re-point).
+const BARE = /^[A-Za-z0-9_\-/$@]+$/;
+/** Parse any valid spelling; throws, naming the offset, on anything else. */
+export function parsePath(text) {
+    const out = [];
+    const bad = (at, expected) => new Error(`source path \`${text}\`: expected ${expected} at offset ${at}`);
+    const n = text.length;
+    let i = 0;
+    while (i < n) {
+        if (text[i] === "[") {
+            i = selector(text, i, out, bad);
+        }
+        else {
+            let j = i;
+            while (j < n && !"[].".includes(text[j]))
+                j++;
+            if (j === i)
+                throw bad(i, text[i] === "]" ? "a `]` with no `[`" : "an empty name");
+            out.push({ kind: "key", name: text.slice(i, j) });
+            i = j;
+        }
+        if (i < n) {
+            if (text[i] === ".") {
+                i++;
+                if (i >= n || text[i] === "." || text[i] === "[")
+                    throw bad(i, "a name after `.`");
+            }
+            else if (text[i] !== "[")
+                throw bad(i, "`.` or `[` after a step");
+        }
+    }
+    return out;
+}
+function selector(text, open, out, bad) {
+    const n = text.length;
+    let i = open + 1;
+    if (i >= n)
+        throw bad(i, "a selector after `[`");
+    if (text[i] === '"') {
+        let s = "";
+        i++;
+        for (;;) {
+            if (i >= n)
+                throw bad(i, 'a closing `"`');
+            const c = text[i];
+            if (c === "\\") {
+                if (i + 1 >= n || (text[i + 1] !== '"' && text[i + 1] !== "\\"))
+                    throw bad(i, '`\\"` or `\\\\` (the only escapes)');
+                s += text[i + 1];
+                i += 2;
+            }
+            else if (c === '"') {
+                i++;
+                break;
+            }
+            else {
+                s += c;
+                i++;
+            }
+        }
+        if (i >= n || text[i] !== "]")
+            throw bad(i, "`]` after a quoted key");
+        out.push({ kind: "key", name: s });
+        return i + 1;
+    }
+    const close = text.indexOf("]", i);
+    if (close < 0)
+        throw bad(i, "a closing `]`");
+    const body = text.slice(i, close);
+    if (body.startsWith("#")) {
+        if (!/^[0-9]{1,9}$/.test(body.slice(1)))
+            throw bad(i, "a position `#<digits>`");
+        out.push({ kind: "position", index: Number(body.slice(1)) });
+        return close + 1;
+    }
+    const parts = body.split(";");
+    if (parts[0] === "")
+        throw bad(i, "a key in `[...]`");
+    const qualifiers = [];
+    for (const p of parts.slice(1)) {
+        const eq = p.indexOf("=");
+        if (eq <= 0 || eq === p.length - 1)
+            throw bad(i, "a qualifier `field=value`, both non-empty");
+        if (qualifiers.some(([f]) => f === p.slice(0, eq)))
+            throw bad(i, "each qualifier field once");
+        qualifiers.push([p.slice(0, eq), p.slice(eq + 1)]);
+    }
+    out.push({ kind: "element", key: parts[0], qualifiers });
+    return close + 1;
+}
+function renderStep(s, first) {
+    if (s.kind === "key") {
+        if (BARE.test(s.name))
+            return (first ? "" : ".") + s.name;
+        return `["${s.name.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`;
+    }
+    if (s.kind === "element")
+        return `[${s.key}${s.qualifiers.map(([f, v]) => `;${f}=${v}`).join("")}]`;
+    return `[#${s.index}]`;
+}
+/** The canonical spelling of these steps. */
+export function renderPath(steps) {
+    return steps.map((s, k) => renderStep(s, k === 0)).join("");
+}
+const isMap = (x) => x instanceof Map;
+/** A key or qualifier value as both readers print it; null when it cannot be one (not a scalar, or a non-integer number). */
+function scalar(o) {
+    if (typeof o === "string" || typeof o === "boolean")
+        return String(o);
+    if (typeof o === "number")
+        return Number.isInteger(o) ? String(o) : null;
+    return null;
+}
+const usableValue = (v) => v !== null && v !== "" && !v.includes("]") && !v.includes(";");
+const usableKey = (v) => usableValue(v) && !v.startsWith("#") && !v.startsWith('"');
+function matches(el, keyField, key, qualifiers) {
+    if (!isMap(el) || scalar(el.get(keyField)) !== key)
+        return false;
+    return qualifiers.every(([f, v]) => scalar(el.get(f)) === v);
+}
+/** The pattern text a step adds, given its container: a map entry keeps its key; any list element is `[]`. */
+function patternStep(container, s, first) {
+    if (s.kind === "key")
+        return renderStep(s, first);
+    return isMap(container) && s.kind === "element" ? `[${s.key}]` : "[]";
+}
+/** The canonical step to element `i` of `list` (its key and fewest qualifiers, else its position). */
+function canonicalElement(list, i, fields) {
+    const el = list[i];
+    if (fields.length > 0 && isMap(el)) {
+        const key = scalar(el.get(fields[0]));
+        if (usableKey(key)) {
+            const qualifiers = [];
+            for (let q = 0;; q++) {
+                if (list.filter((o) => matches(o, fields[0], key, qualifiers)).length === 1)
+                    return { kind: "element", key, qualifiers };
+                if (q + 1 >= fields.length)
+                    break;
+                const v = scalar(el.get(fields[q + 1]));
+                if (!usableValue(v))
+                    break;
+                qualifiers.push([fields[q + 1], v]);
+            }
+        }
+    }
+    return { kind: "position", index: i };
+}
+/**
+ * Resolve `path` in `doc` (parsed with typed map keys: `toJS({ mapAsMap: true })`). Null when it names exactly one node,
+ * else the reason.
+ */
+export function resolvePath(doc, path, opts = {}) {
+    const r = resolveNode(doc, path, opts);
+    return "error" in r ? r.error : null;
+}
+/** As resolvePath, returning the one node the path names. */
+export function resolveNode(doc, path, opts = {}) {
+    let steps;
+    try {
+        steps = parsePath(path);
+    }
+    catch (e) {
+        return { error: e.message };
+    }
+    const keys = opts.keys ?? new Map();
+    let node = doc;
+    let pattern = "";
+    for (const [at, s] of steps.entries()) {
+        const why = (w) => ({ error: `does not resolve at step ${at + 1}: ${w}` });
+        const container = node;
+        if (s.kind === "key") {
+            if (!isMap(node) || !node.has(s.name))
+                return why(isMap(node) ? `no key '${s.name}'` : `a key step on a ${kind(node)}`);
+            node = node.get(s.name);
+        }
+        else if (s.kind === "position") {
+            if (opts.positions === false)
+                return why(`positional '[#${s.index}]' (a features map or shared path never addresses by position: a reorder would re-point it; map the whole list)`);
+            if (!Array.isArray(node) || s.index >= node.length)
+                return why(Array.isArray(node) ? `position ${s.index} of ${node.length}` : `a position on a ${kind(node)}`);
+            const canon = canonicalElement(node, s.index, keys.get(pattern) ?? []);
+            if (canon.kind !== "position")
+                return why(`'[#${s.index}]' where its key would do: address it as '${renderStep(canon, false)}'`);
+            node = node[s.index];
+        }
+        else if (isMap(node)) {
+            if (s.qualifiers.length > 0)
+                return why("qualifiers on a map entry");
+            const hits = [...node.keys()].filter((k) => typeof k !== "string" && String(k) === s.key);
+            if (hits.length !== 1)
+                return why(`${hits.length} non-string keys printing as '${s.key}'`);
+            node = node.get(hits[0]);
+        }
+        else {
+            if (!Array.isArray(node))
+                return why(`a selector on a ${kind(node)}`);
+            const fields = keys.get(pattern) ?? [];
+            if (fields.length === 0)
+                return why(`the list '${pattern}' declares no key (keys:), so its elements are addressed by position`);
+            const bad = s.qualifiers.find(([q]) => !fields.slice(1).includes(q));
+            if (bad)
+                return why(`'${bad[0]}' is not a qualifier of '${pattern}' (${fields.join(", ")})`);
+            const hits = node.filter((el) => matches(el, fields[0], s.key, s.qualifiers));
+            if (hits.length !== 1)
+                return why(`${hits.length} elements of '${pattern}' match (exactly one must)`);
+            node = hits[0];
+        }
+        pattern += patternStep(container, s, at === 0);
+    }
+    return { node };
+}
+function kind(node) {
+    return node === null || node === undefined ? "null" : isMap(node) ? "map" : Array.isArray(node) ? "list" : "scalar";
+}
+/** Is `path` the same node as, or inside, `prefix` (step-wise, compared in canonical spelling)? Unparseable: false. */
+export function pathWithin(path, prefix) {
+    try {
+        const a = parsePath(path).map((s) => renderStep(s, false));
+        const b = parsePath(prefix).map((s) => renderStep(s, false));
+        return b.length <= a.length && b.every((x, k) => x === a[k]);
+    }
+    catch {
+        return false;
+    }
+}
+/** The paths on a `Source:` line: one per line is canonical; `, ` between paths is split outside brackets and quotes. */
+export function splitSourceLine(text) {
+    const out = [];
+    let depth = 0;
+    let quoted = false;
+    let cur = "";
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quoted) {
+            cur += c;
+            if (c === "\\" && i + 1 < text.length)
+                cur += text[++i];
+            else if (c === '"')
+                quoted = false;
+            continue;
+        }
+        if (c === '"' && depth > 0)
+            quoted = true;
+        else if (c === "[")
+            depth++;
+        else if (c === "]")
+            depth = Math.max(0, depth - 1);
+        else if (c === "," && depth === 0) {
+            out.push(cur.trim());
+            cur = "";
+            continue;
+        }
+        cur += c;
+    }
+    out.push(cur.trim());
+    return out.filter((x) => x !== "");
+}
+//# sourceMappingURL=source-path.js.map

package/dist/lib/structure/catalogue.js

@@ -9,6 +9,7 @@
 // element as an agreed open change adds or modifies it is that change's intended element, not a disagreement: it is
 // listed apart, and catalogued once the change archives. Pure: no file is read or written.
 import { stringify } from "yaml";
+import { maturityFromRunway } from "../catalogue/builders/features.js";
 import { elementKey, FORMAT_VERSION } from "./model.js";
 import { STRUCTURE } from "./view.js";
 /** The view each generated file renders, for a derived path column of an element only the model holds. */
@@ -26,7 +27,14 @@ function modelDerived(catalogue, e, view) {
     switch (catalogue) {
         case "features":
         case "capabilities":
+        case "feature_groups":
             return { source: "structural-model" };
+        // A link the model states is a declared one (sdm-0enc): an ADR the capability cites, an event it publishes or
+        // consumes. The heuristic values (high, medium; derived) belong to links a builder infers from the sources.
+        case "capability_adr":
+            return { confidence: "spec" };
+        case "capability_event":
+            return { source: "authored" };
         case "domain_models":
             return { doc_path: VIEW_PATHS.dataModel };
         case "c4_systems":
@@ -56,6 +64,7 @@ export function overlayModel(schema, view, rows, findings, intended = new Map(),
             continue;
         const pk = cat.primaryKey;
         const structural = structureColumns(cat);
+        const derivesMaturity = cat.name === "features" && ["maturity", "runway"].every((n) => cat.columns.some((c) => c.name === n));
         const source = new Map();
         for (const r of rows.get(cat.name) ?? []) {
             const id = cell(r[pk]);
@@ -101,6 +110,10 @@ export function overlayModel(schema, view, rows, findings, intended = new Map(),
             row[pk] = e.id;
             for (const c of structural)
                 row[c] = e.columns[c];
+            // A derived column follows its input as catalogued, not as the source stated it: a feature's maturity is read
+            // from the runway the model holds, so the two never disagree in one row (sdm-dlb9).
+            if (derivesMaturity)
+                row["maturity"] = maturityFromRunway(cell(row["runway"]));
             built.push(row);
         }
         const missing = [...source.keys()].filter((id) => id !== "" && !elements.has(id) && !asIntended(id, source.get(id))).sort();

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

@@ -3,8 +3,10 @@
 //
 //   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; 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.
+//                    base revisions (M-ADR 0230 §4.4; report only until it is accepted) and a derived change's proposed
+//                    sources under derived/ (M-ADR 0232; byte for byte, since archive writes them to the source path) 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.
 //   scenario kind    changed (a scenario of an ADDED requirement, or one of a MODIFIED requirement that is new or
@@ -13,7 +15,14 @@
 //   verdict line     verdict.md's own verdict: `Verdict: PASS|FAIL` or a leading `**PASS**`/`**FAIL**`.
 /** The files under a change directory that agreement binds, relative to the change directory. */
 export function boundFile(rel) {
-    return /^(proposal|design|gate-0|tasks|test-plan)\.md$/.test(rel) || /^specs\/.+\/spec\.md$/.test(rel) || structuralFile(rel);
+    return /^(proposal|design|gate-0|tasks|test-plan)\.md$/.test(rel) || /^specs\/.+\/spec\.md$/.test(rel) || structuralFile(rel) || derivedFile(rel);
+}
+/**
+ * A derived change's proposed source (M-ADR 0232): archive writes it to the source path, so an edit after agreement would
+ * archive content nobody agreed, even where no derived spec reads the edited path (found by a judge's mutant in the first adopter pilot, sdm-bocd).
+ */
+export function derivedFile(rel) {
+    return /^derived\/.+/.test(rel);
 }
 /**
  * A change's structural artifact (M-ADR 0230 §4.4): a partition delta or the no-op claim, both agreed
@@ -29,6 +38,8 @@ export function normaliseBound(rel, text) {
         return text.replace(/^(\s*-\s*\[)\s*[xX~]?\s*(\])/gm, "$1 $2").trimEnd();
     if (rel === "test-plan.md")
         return normaliseTestPlan(text);
+    if (derivedFile(rel))
+        return text;
     return text.trimEnd();
 }
 /**

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

@@ -78,6 +78,7 @@ import { contractMoves, generatedByProblems, observedIn, observedInProblems, ord
 import { parseCatalogueCsv } from "../catalogue/csv-reader.js";
 import { boundFile, conditionProblems, structuralFile, isCommit, normaliseBound, requirementBlock, sameCommit, scenarioKind, taskGroups, testPlanHeader, testPlanMapping, verdictLine, versionAtLeast } from "./agreement-evidence.js";
 import { ENFORCED as STRUCTURE_ENFORCED } from "./structural-model.js";
+import { derivedChangeProblems, loadDerivedSources } from "../derived-specs/index.js";
 import { BASELINE_SCHEMA_NAME, compareStoreSchema, SCHEMA_NAME, SHIPPED_SCHEMA_DIR, shippedSchemaDir, STORE_CONFIG, STORE_SCHEMA_DIR, storeSchemaDir, storeSchemaName } from "../behaviour-store/schema.js";
 const execFileAsync = promisify(execFile);
 /** The OpenSpec release the method depends on (M-ADR 0223 ruling 2). The module installs exactly this. */
@@ -891,6 +892,16 @@ export async function checkBehaviourStore(repo, options = {}) {
         }
         movesAt.push(found);
     }
+    // Derived features (M-ADR 0232 §4.1, §4.5): no authored delta to a feature a derived source owns, and a change carrying
+    // a proposed source holds exactly the regenerated deltas.
+    let derivedChecked = 0;
+    for (const change of open) {
+        const p = await derivedChangeProblems(repo, change);
+        failures.push(...p);
+        derivedChecked++;
+    }
+    if ((await loadDerivedSources(repo).catch(() => null))?.length)
+        lines.push(`derived: ${derivedChecked} open change(s) checked against the derived sources' ownership`);
     // An open change's moves count too, after every archive: the catalogue it is built with already holds the new
     // identity, so the lists that named the old one follow the move while it is open, not only once it archives.
     const openMoves = [];
@@ -942,6 +953,13 @@ export async function checkBehaviourStore(repo, options = {}) {
         }
         return false;
     };
+    /**
+     * What the gate asks of this baseline (sdm-bjy3). Every baseline records **Baseline gate:**, a structure-only one
+     * too; for it the gate is its structural deltas evidenced in the code it observes, not requirements and tests.
+     */
+    const gateRule = async (dir) => (await admitsBehaviour(dir))
+        ? "a baseline archives once its gate passes: every requirement cites its evidence, characterization tests exist where the code has none, and every covered surface is evidenced at its transport"
+        : "every baseline records **Baseline gate:**, a structure-only one too (it admits no behaviour): PASS once its structural deltas are evidenced in the code it observes";
     /** What is wrong with a baseline's Surfaces list against the catalogue (M-ADR 0222 §4.3, §4.4). */
     const surfaceProblems = async (dir, evidence, after = -1) => {
         const out = [];
@@ -1089,7 +1107,7 @@ export async function checkBehaviourStore(repo, options = {}) {
                 if (versionAtLeast(await shippedRecordSchema(repo, archivedAt), "1.4.0")) {
                     const gate = baselineGate(evidence);
                     if (gate !== "PASS")
-                        failures.push(`${dir}/baseline-evidence.md: archived ${gate === null ? "with no **Baseline gate:** line" : `with **Baseline gate:** ${gate}`}; a baseline archives once its gate passes: every requirement cites its evidence, characterization tests exist where the code has none, and every covered surface is evidenced at its transport (M-ADR 0222 §4.3)`);
+                        failures.push(`${dir}/baseline-evidence.md: archived ${gate === null ? "with no **Baseline gate:** line" : `with **Baseline gate:** ${gate}`}; ${await gateRule(dir)} (M-ADR 0222 §4.3)`);
                 }
             }
         }
@@ -1145,7 +1163,7 @@ export async function checkBehaviourStore(repo, options = {}) {
         }
         const gate = baselineGate(evidence);
         if (gate !== "PASS")
-            found.push(`${dir}/baseline-evidence.md: ${gate === null ? "no **Baseline gate:** line yet" : `**Baseline gate:** ${gate}`}; it archives once the gate passes (M-ADR 0222 §4.3)`);
+            found.push(`${dir}/baseline-evidence.md: ${gate === null ? "no **Baseline gate:** line yet" : `**Baseline gate:** ${gate}`}; ${await gateRule(dir)} (M-ADR 0222 §4.3)`);
         warnings.push(...found.map((w) => `open baseline: ${w}`));
     }
     if (openBaselines.length > 0)

package/dist/lib/validate/carve-citations.js

@@ -18,13 +18,17 @@
 // itself is an event of the estate's, not recorded in the store, so a requirement both SDDs hold before the old one is
 // removed is "in flight" and is reported in the inventory, not failed.
 import { readdir, readFile } from "node:fs/promises";
+import { parse as parseYaml } from "yaml";
 import { basename, dirname, join } from "node:path";
 const STORE = "openspec";
 const REQ_HEAD = /^###\s+Requirement:\s*(.+?)\s*$/;
 const SECTION = /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements\s*$/i;
-const CITE_START = /^\s*(Replaces|Departs from)\s/;
+const CITE_START = /^\s*(Replaces|Departs from|Succeeds)\s/;
 const REPLACES = /^\s*Replaces\s+([A-Za-z0-9._-]+):([A-Za-z0-9._-]+)::(.+?)\.\s*$/;
 const DEPARTS = /^\s*Departs from\s+([A-Za-z0-9._-]+):([A-Za-z0-9._-]+)::(.+?):\s+\S.*$/;
+// A feature that left the other SDD before it was baselined has no requirement to cite (sdm-a31j): the citation is
+// feature-level and names the delta finding that records the removal, as <baseline-id>/<finding-id>.
+const SUCCEEDS = /^\s*Succeeds\s+([A-Za-z0-9._-]+):([A-Za-z0-9._-]+)\s+\(removed before baseline;\s*([^)\s]+)\s*\)\.?\s*$/;
 const REPLACED_BY = /replaced by\s+`?([A-Za-z0-9._-]+):([A-Za-z0-9._-]+)::([^`\n]+?)`?\s*(?:[.;,)]\s*)?$/im;
 const key = (r) => `${r.sdd}:${r.feature}::${r.name}`;
 async function read(p) {
@@ -94,7 +98,24 @@ async function view(repo) {
     }
     return { living, removed };
 }
-export async function checkCarveCitations(repo) {
+/** The classification of finding `<baseline>/<id>` in an SDD's snapshot area, "" when absent, null when unreachable. */
+async function deltaFinding(repo, ref, store) {
+    const area = /^snapshot_area:\s*["']?([^"'\n]+?)["']?\s*$/m.exec((await read(join(repo, ".sdd", "implementation-binding.yaml"))) ?? "")?.[1];
+    if (!area || store === "")
+        return null;
+    const slash = ref.indexOf("/");
+    if (slash <= 0)
+        return "";
+    const text = await read(join(store, area, ref.slice(0, slash), "delta.yaml"));
+    if (text === null)
+        return "";
+    const y = parseYaml(text);
+    const f = (y?.findings ?? []).find((x) => x?.id === ref.slice(slash + 1));
+    return f === undefined ? "" : String(f.classification ?? "");
+}
+export async function checkCarveCitations(repo, 
+/** Snapshot store root the other SDD's snapshot_area is relative to (the verb passes $SDD_SNAPSHOT_STORE). */
+snapshotStore = "") {
     const own = await sddId(repo);
     const failures = [];
     const warnings = [];
@@ -113,6 +134,19 @@ export async function checkCarveCitations(repo) {
             for (const line of b.text.split("\n")) {
                 if (!CITE_START.test(line))
                     continue;
+                const sc = SUCCEEDS.exec(line);
+                if (/^\s*Succeeds\s/.test(line)) {
+                    cites.push({
+                        where: `${rel}: '${b.name}'`,
+                        open,
+                        line: line.trim(),
+                        ref: sc ? { sdd: sc[1], feature: sc[2], name: "" } : null,
+                        kind: "succeeds",
+                        owner: "",
+                        ...(sc ? { evidence: sc[3] } : {}),
+                    });
+                    continue;
+                }
                 const r = REPLACES.exec(line);
                 const d = r ? null : DEPARTS.exec(line);
                 const m = r ?? d;
@@ -147,7 +181,7 @@ export async function checkCarveCitations(repo) {
         }
     }
     if (cites.length === 0 && removals.length === 0) {
-        return { exitCode: 0, stdout: "[N/A] no carve citations (Replaces / Departs from lines, or removals replaced by another SDD) in this repository\n" };
+        return { exitCode: 0, stdout: "[N/A] no carve citations (Replaces / Departs from / Succeeds lines, or removals replaced by another SDD) in this repository\n" };
     }
     // The other SDDs, found beside this one by their sdd_id.
     const siblings = new Map();
@@ -173,11 +207,36 @@ export async function checkCarveCitations(repo) {
     const report = (open, msg) => (open ? warnings : failures).push(msg);
     let inFlight = 0;
     let carved = 0;
+    let succeeded = 0;
     let unresolved = 0;
     const replacedBy = new Map();
     for (const c of cites) {
         if (c.ref === null) {
-            report(c.open, `${c.where}: "${c.line}" is not "Replaces <sdd-id>:<feature>::<requirement name>." or "Departs from <sdd-id>:<feature>::<requirement name>: <why>."`);
+            report(c.open, `${c.where}: "${c.line}" is not "Replaces <sdd-id>:<feature>::<requirement name>.", "Departs from <sdd-id>:<feature>::<requirement name>: <why>." or "Succeeds <sdd-id>:<feature> (removed before baseline; <baseline-id>/<finding-id>)."`);
+            continue;
+        }
+        if (c.kind === "succeeds") {
+            const p = siblings.get(c.ref.sdd);
+            const v = await other(c.ref.sdd);
+            if (!p || v === null) {
+                unresolved++;
+                warnings.push(`${c.where}: Succeeds ${c.ref.sdd}:${c.ref.feature} unresolved: no checkout beside this SDD has sdd_id "${c.ref.sdd}"; check it out beside this one (failed under --strict)`);
+                continue;
+            }
+            if (v.living.has(c.ref.feature)) {
+                report(c.open, `${c.where}: Succeeds ${c.ref.sdd}:${c.ref.feature}, but ${c.ref.sdd} still has a living spec for ${c.ref.feature}: cite its requirement with Replaces`);
+                continue;
+            }
+            const cls = await deltaFinding(p, c.evidence, snapshotStore);
+            if (cls === null) {
+                unresolved++;
+                warnings.push(`${c.where}: Succeeds ${c.ref.sdd}:${c.ref.feature}: its evidence ${c.evidence} is not checked: ${c.ref.sdd} declares no snapshot_area, or no snapshot store was given (SDD_SNAPSHOT_STORE) (failed under --strict)`);
+            }
+            else if (cls === "" || !/^capability-removed/.test(cls)) {
+                report(c.open, `${c.where}: Succeeds ${c.ref.sdd}:${c.ref.feature}: ${c.evidence} ${cls === "" ? `is not a finding in ${c.ref.sdd}'s snapshot area` : `is a ${cls} finding, not capability-removed`}`);
+            }
+            else
+                succeeded++;
             continue;
         }
         const v = await other(c.ref.sdd);
@@ -215,7 +274,7 @@ export async function checkCarveCitations(repo) {
         }
     }
     const lines = [
-        `  citations: ${cites.length} Replaces / Departs line(s): ${inFlight} in flight (still living where they came from), ${carved} carved (removed there), ${unresolved} unresolved`,
+        `  citations: ${cites.length} Replaces / Departs / Succeeds line(s): ${inFlight} in flight (still living where they came from), ${carved} carved (removed there), ${succeeded ? `${succeeded} succeeded (removed there before its baseline), ` : ""}${unresolved} unresolved`,
         `  removals: ${removals.length} replaced by another SDD`,
     ];
     const body = lines.join("\n") + "\n";