@sdd-method/verify-cli 5.5.0 → 5.6.0

package/dist/lib/catalogue/canonical-schema.yaml

@@ -7,7 +7,7 @@
 # Emitted by sdd-cli's YAML emitter with no line folding; the three header scalars are quoted for the
 # textual readers downstream. The one deliberate difference from the authored form is schema_status:
 # the authored form says canonical; a projection never does.
-schema_version: "7.3.0"
+schema_version: "7.4.0"
 schema_owner: "sdd-method"
 schema_status: "generated"
 enums:
@@ -785,6 +785,11 @@ enums:
     - value: description
       description: A catalogue-entry description that many things share.
     description: An entity's Party-Place-Thing archetype, as the capability spec template classifies it (schema 7.1.0).
+  repository_status:
+    values:
+    - value: empty
+      description: "Registered, and observed empty on the date its repo-config gives: nothing to snapshot, scan or attribute yet."
+    description: Whether a registered repository holds anything yet (7.4.0).
 catalogues:
   domains:
     primary_key: id
@@ -1599,6 +1604,10 @@ catalogues:
       nullable: true
       description: The platform this row belongs to — sdd_id of its platform-root. Stamped by the aggregator per M-ADR 0208 §4.4 (preserve-if-set, fill rule by pull path); left empty by per-SDD builders. Added in 3.7.0.
       source_of_truth: execution
+    - name: variant
+      type: string
+      nullable: true
+      description: "The variant a feature group belongs to, from a [variant: <id>] marker on its heading (or inherited from the heading above it), as features.variant. Added in 7.4.0."
     description: |
       Hierarchical grouping for features. First-class entity — replaces the previous reverse-only synthetic `feature-tree-group` rows in features.csv. Both forward and reverse can use feature_groups: forward application-product SDDs whose `feature-tree.md` has H2/H3 structure, reverse SDDs whose extracted feature trees are inherently hierarchical, and any SDD that promotes groups to first-class with authored metadata. Groups can nest via `parent_group_id`.
     foreign_keys:
@@ -1673,6 +1682,10 @@ catalogues:
       nullable: true
       description: The platform this row belongs to — sdd_id of its platform-root. Stamped by the aggregator per M-ADR 0208 §4.4 (preserve-if-set, fill rule by pull path); left empty by per-SDD builders. Added in 3.7.0.
       source_of_truth: execution
+    - name: variant
+      type: string
+      nullable: true
+      description: "The customer-specific or segment variant the feature belongs to, from a [variant: <id>] marker in feature-tree.md on its bullet or on a group heading above it (inherited by everything beneath a marked group). The id is one the SDD declares in feature-variant-vocabulary.yaml at its root; an undeclared id is a convention finding and is not recorded. Empty for a feature of the product itself. Added in 7.4.0."
     foreign_keys:
     - column: product_id
       references: products.id
@@ -2160,6 +2173,10 @@ catalogues:
       type: string
       nullable: true
       description: "Whether the repository is inside the scope of what THIS SDD specifies, from its reverse-metadata.yaml (M-ADR 0213 §4.2): component (part of what the SDD specifies) or support (supports a component without being one). Empty for a repository with no reverse metadata. Its kind is component_type; the SDD's profile is products/applications.profile."
+    - name: status
+      type: string
+      nullable: true
+      description: "Whether the repository holds anything yet, from its repo-config: empty for a repository registered while it is empty (status: empty, with the date it was observed so in observed_empty_at, required), which coverage checks report as not applicable rather than as gaps; otherwise empty. A delta-reverse re-checks it: a repository declared empty that is exported with content is a finding. Added in 7.4.0."
     foreign_keys:
     - column: domain_id
       references: domains.id
@@ -2170,6 +2187,7 @@ catalogues:
     column_enums:
       component_type: enums.service_type
       repo_scope: enums.repo_scope
+      status: enums.repository_status
   domain_models:
     primary_key: id
     source_of_truth: structure

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

@@ -62,12 +62,15 @@ SELECT
    WHERE s."primary_repo_id" = r."id"
      AND s."id" IS NOT NULL AND s."id" <> ''
      AND NOT EXISTS (SELECT 1 FROM "capability_service" cs
-                     WHERE cs."service_id" = s."id")) AS unclaimed_ids
+                     WHERE cs."service_id" = s."id")) AS unclaimed_ids,
+  __IS_EMPTY__ AS is_empty
 FROM "repositories" r
 WHERE r."id" IS NOT NULL AND r."id" <> ''
 ORDER BY repo_id;`;
 export async function runRepoCapabilityCoverage(session) {
-    const reader = await session.conn.runAndReadAll(REPO_FLAGS_SQL);
+    // repositories.status arrived in schema 7.4.0; a catalogue set built earlier has no such column.
+    const hasStatus = (await session.conn.runAndReadAll(`SELECT 1 FROM information_schema.columns WHERE table_name = 'repositories' AND column_name = 'status'`)).getRows().length > 0;
+    const reader = await session.conn.runAndReadAll(REPO_FLAGS_SQL.replace("__IS_EMPTY__", hasStatus ? `COALESCE(r."status", '') = 'empty'` : "FALSE"));
     const rows = reader.getRows().map((r) => ({
         repoId: String(r[0]),
         hasCap: r[1] === true,
@@ -78,6 +81,7 @@ export async function runRepoCapabilityCoverage(session) {
         unclaimedIds: r[6] === null || r[6] === undefined
             ? []
             : String(r[6]).split("\x1f"),
+        empty: r[7] === true,
     }));
     const findings = [];
     let byCapability = 0;
@@ -86,7 +90,19 @@ export async function runRepoCapabilityCoverage(session) {
     let unresolved = 0;
     let shapeA = 0;
     let shapeB = 0;
+    let registeredEmpty = 0;
     for (const row of rows) {
+        // A repository registered while empty has nothing to resolve to a capability yet (sdm-py85); one that claims a
+        // capability while declaring itself empty contradicts itself, and is reported.
+        if (row.empty && !row.hasCap) {
+            registeredEmpty++;
+            continue;
+        }
+        if (row.empty && row.hasCap) {
+            conflicting++;
+            findings.push({ predicate: "repo_capability", kind: "divergence", subjectId: row.repoId, classification: "empty_with_capability" });
+            continue;
+        }
         if (row.hasCap && row.hasExempt) {
             conflicting++;
             findings.push({
@@ -146,6 +162,7 @@ export async function runRepoCapabilityCoverage(session) {
             shapeA,
             shapeB,
             other: unresolved - shapeA - shapeB,
+            ...(registeredEmpty > 0 ? { registeredEmpty } : {}),
         },
     };
 }

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

@@ -47,6 +47,14 @@ export function renderRepoCapability(findings, metrics) {
                     `must not claim a capability (per M-ADR 0188 §4.1)`,
             }));
         }
+        else if (f.classification === "empty_with_capability") {
+            lines.push(renderFindingLine({
+                category: "divergence",
+                subject,
+                summary: `repo ${f.subjectId} is registered empty (repo-config status: empty) but has a repo_capability edge — ` +
+                    `an empty repository implements nothing yet; drop the status once it has content`,
+            }));
+        }
         else if (f.classification === "shape_a") {
             const names = (f.unclaimedServices ?? []).join(", ") +
                 ((f.unclaimedCount ?? 0) > 3 ? " …" : "");
@@ -82,10 +90,11 @@ export function renderRepoCapability(findings, metrics) {
         lines.push(`[metric] repo_capability_resolution: n/a — 0 repository rows, nothing to resolve`);
     }
     if (metrics.total > 0) {
-        const resolved = metrics.byCapability + metrics.byExemption;
+        const resolved = metrics.byCapability + metrics.byExemption + (metrics.registeredEmpty ?? 0);
         const pct = fmt1f((100.0 * resolved) / metrics.total);
         lines.push(`[metric] repo_capability_resolution: ${resolved}/${metrics.total} (${pct}%) ` +
             `— ${metrics.byCapability} by capability, ${metrics.byExemption} by exemption, ` +
+            `${metrics.registeredEmpty ? `${metrics.registeredEmpty} registered empty (not applicable), ` : ""}` +
             `${metrics.conflicting} conflicting, ${metrics.unresolved} unresolved`);
         if (metrics.unresolved > 0) {
             lines.push(`[metric] repo_capability_orphan_shape: ${metrics.shapeA} with no local ` +

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

@@ -82,11 +82,11 @@ export function buildImpactPropagation(edges, semantics) {
             continue;
         }
         if (flow === "toward-source" || flow === "both") {
-            out.push({ from: e.target, to: e.source, type: e.type });
+            out.push({ from: e.target, to: e.source, type: e.type, flow });
             notePair(e.target, e.source, e.type);
         }
         if (flow === "toward-target" || flow === "both") {
-            out.push({ from: e.source, to: e.target, type: e.type });
+            out.push({ from: e.source, to: e.target, type: e.type, flow });
             notePair(e.source, e.target, e.type);
         }
     }
@@ -159,6 +159,43 @@ export async function computeImpactClosure(propagation, seed) {
         conn.disconnectSync();
     }
 }
+/**
+ * Consumers of `seed` (sdm-6npk): who depends on it, directly or through a chain of dependencies. Only dependency-
+ * shaped steps (declared flow toward-source: a change at the target reaches the source that depends on it) are
+ * followed; membership (toward-target) and realisation (both) are not, so a shared hub's parts and wholes do not flood
+ * the answer. Breadth-first, so each consumer is reported with a shortest dependency path from the seed.
+ */
+export function consumersOf(propagation, seed) {
+    const next = new Map();
+    for (const e of propagation) {
+        if (e.flow !== "toward-source")
+            continue;
+        (next.get(e.from) ?? next.set(e.from, []).get(e.from)).push(e);
+    }
+    const prev = new Map();
+    const seen = new Set([seed]);
+    const queue = [seed];
+    const order = [];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        for (const e of (next.get(cur) ?? []).slice().sort((a, b) => a.to.localeCompare(b.to))) {
+            if (seen.has(e.to))
+                continue;
+            seen.add(e.to);
+            prev.set(e.to, cur);
+            order.push(e.to);
+            queue.push(e.to);
+        }
+    }
+    return order
+        .map((id) => {
+        const path = [id];
+        for (let p = prev.get(id); p !== undefined; p = prev.get(p))
+            path.unshift(p);
+        return { id, path };
+    })
+        .sort((a, b) => a.path.length - b.path.length || a.id.localeCompare(b.id));
+}
 export async function runCatalogueImpact(inputs, write) {
     const sddRoot = resolve(inputs.sddPath ?? process.cwd());
     const tier = inputs.tier ?? "member";
@@ -200,6 +237,21 @@ export async function runCatalogueImpact(inputs, write) {
         return { exitCode: 2 };
     }
     const prop = buildImpactPropagation(edges, semantics);
+    if (inputs.consumers === true) {
+        const found = consumersOf(prop.edges, inputs.of);
+        const byCat = new Map();
+        for (const c of found)
+            byCat.set(c.id.slice(0, c.id.indexOf("/")), (byCat.get(c.id.slice(0, c.id.indexOf("/"))) ?? 0) + 1);
+        write(`consumers of ${inputs.of} (${tier} tier, schema ${schema.schemaVersion})\n`);
+        write(`  semantics: who depends on it, directly or through dependencies: only dependency-shaped relationships\n` +
+            `    (declared flow toward-source) are followed, never membership or realisation; each consumer with a shortest path\n`);
+        write(`  consumers: ${found.length}\n`);
+        for (const [cat, n] of [...byCat.entries()].sort())
+            write(`    ${cat}: ${n}\n`);
+        for (const c of found)
+            write(`  ${c.id}  (${c.path.join(" <- ")})\n`);
+        return { exitCode: 0, result: { seed: inputs.of, closure: found.map((c) => c.id), byCatalogue: byCat } };
+    }
     const closure = await computeImpactClosure(prop.edges, inputs.of);
     const byCatalogue = new Map();
     for (const id of closure) {

package/dist/lib/catalogue/rubric-coverage-map.yaml

@@ -1043,3 +1043,7 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
+  repository_status:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact

package/dist/lib/structure/catalogue.js

@@ -26,7 +26,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":

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

@@ -273,6 +273,25 @@ async function gitShow(repo, commit, path) {
         return null;
     }
 }
+/** Files under a directory on disk, relative to it, sorted. */
+async function filesUnder(root, rel = "") {
+    const out = [];
+    let entries;
+    try {
+        entries = await readdir(join(root, rel), { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory())
+            out.push(...(await filesUnder(root, p)));
+        else
+            out.push(p);
+    }
+    return out.sort();
+}
 /** Paths under a directory at a commit, relative to that directory. */
 async function gitFiles(repo, commit, dir) {
     try {
@@ -923,6 +942,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 = [];
@@ -1070,7 +1096,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)`);
                 }
             }
         }
@@ -1126,13 +1152,53 @@ 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)
         lines.push(`open baselines: ${openBaselines.length}, asked the archive's questions as warnings`);
     const unseen = servedBy === null ? "" : `; repositories with no catalogue contracts: ${[...new Set(await observedInAll(repo, archiveRel, order))].filter((r) => (servedBy.get(r)?.served ?? []).length === 0).join(", ") || "none"}`;
     lines.push(baselines === 0 ? "surfaces: vacuous (no baseline)" : `surfaces: ${baselines} baseline(s), ${surfacesChecked} served contract(s) checked against catalogues/repo_contract.csv less what service_contract records only consumed${unseen}${structureOnly ? `; ${structureOnly} structure-only baseline(s) admitting no behaviour, Surfaces: none` : ""}${generatedBaselines ? `; ${generatedBaselines} generator baseline(s) serving no contract, Surfaces: generated` : ""}${noneServedBaselines ? `; ${noneServedBaselines} baseline(s) of services serving no contract, Surfaces: none served` : ""}${historical.size ? `; ${historical.size} historical baseline(s) not checked (every requirement they baselined has left the living specs)` : ""}`);
+    // Archive integrity (sdm-9sk1): what MERGED is not edited. An archived change's spec deltas and structural deltas
+    // (specs/**, structure/** with applied.yaml) are what entered the living model and what the history catalogues are
+    // derived from (requirement_lineage, revisions, change_effects); editing one after it archived makes the history
+    // claim something entered that never did. A mistake there is fixed by a new change (a corrective baseline, for a
+    // baseline). Every other file of an archived change is bookkeeping (evidence notes, errata, tasks, a deferral) and may
+    // be corrected; git is the record of who changed what. Each archived change is compared with its tree at the commit
+    // that added it; without git history the check is unresolved, never a pass.
+    if (history) {
+        let checkedArchives = 0;
+        let payloadFiles = 0;
+        let bookkeepingEdits = 0;
+        const payload = (f) => f.startsWith("specs/") || f.startsWith("structure/");
+        for (const name of order) {
+            const dir = `${archiveRel}/${name}`;
+            const at = await integratedAt(repo, dir);
+            if (at === null)
+                continue; // not yet committed: nothing archived to compare with
+            checkedArchives++;
+            const then = new Set(await gitFiles(repo, at, dir));
+            const now = new Set(await filesUnder(join(repo, dir)));
+            for (const f of [...new Set([...then, ...now])].sort()) {
+                const before = then.has(f) ? await gitShow(repo, at, `${dir}/${f}`) : null;
+                const after = now.has(f) ? await readText(join(repo, dir, f)) : null;
+                if (payload(f))
+                    payloadFiles++;
+                if (before === after)
+                    continue;
+                if (!payload(f)) {
+                    bookkeepingEdits++;
+                    continue;
+                }
+                const what = before === null ? "added to" : after === null ? "removed from" : "edited in";
+                failures.push(`${dir}/${f}: ${what} an archived change after it archived (at ${at.slice(0, 12)}); its spec and structural deltas are what merged into the living model, so a mistake there is fixed by a new change (a corrective baseline, for a baseline), not by editing the archive`);
+            }
+        }
+        lines.push(`archive integrity: ${checkedArchives} archived change(s), ${payloadFiles} merged delta file(s) compared with the commit that archived them${bookkeepingEdits ? `; ${bookkeepingEdits} later correction(s) to bookkeeping files (evidence, tasks, notes), which may be corrected` : ""}`);
+    }
+    else if (archived.length > 0) {
+        lines.push("archive integrity: not checked (no git history: run from a clone)");
+    }
     lines.push(scopeChecked === 0 ? "scope: vacuous (no baseline removes, modifies or renames a requirement)" : `scope: ${scopeChecked} requirement(s) a baseline removes, modifies or renames, checked against their lineage`);
     if (!history && archived.length > 0)
         lines.push("order: no git history (not a git work tree, or git log failed), so same-day archives cannot be ordered");

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";

package/dist/lib/validate/dispatch.js

@@ -29,7 +29,7 @@ const BEHAVIOUR_STORE_VALIDATORS = [
     // Behaviour carved into another SDD keeps one home at a time (the carving guide); without citations it reports [N/A].
     {
         name: "carve-citations",
-        source: { kind: "native", run: async (ctx) => checkCarveCitations(ctx.targetRepo) },
+        source: { kind: "native", run: async (ctx) => checkCarveCitations(ctx.targetRepo, process.env.SDD_SNAPSHOT_STORE ?? "") },
         build: () => ({ status: "run", args: [] }),
     },
     // Intents (M-ADR 0227) can sit in an SDD of any profile; without any the check reports [N/A].

package/dist/maintain-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.19.0",
-  "built_against_sdd_cli": "5.5.0"
+  "version": "0.20.0",
+  "built_against_sdd_cli": "5.6.0"
 }

package/dist/verbs/catalogue-verify.js

@@ -59,6 +59,7 @@ export function registerCatalogueImpact(catalogue) {
         .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
         .option("--catalogues-dir <dir>", "Catalogues directory relative to the SDD root (default: catalogues, or catalogues-aggregated at --tier aggregate)")
         .option("--tier <tier>", "Tier, explicit never inferred (member | aggregate; default member)")
+        .option("--consumers", "Report the node's consumers instead: only dependency relationships, in the consumer direction, each with a shortest path", false)
         .action(async (opts) => {
         if (opts.tier !== undefined &&
             opts.tier !== "member" &&
@@ -75,6 +76,7 @@ export function registerCatalogueImpact(catalogue) {
             ...(opts.tier !== undefined
                 ? { tier: opts.tier }
                 : {}),
+            ...(opts.consumers ? { consumers: true } : {}),
         }, (s) => process.stdout.write(s));
         if (result.exitCode !== 0)
             process.exit(result.exitCode);

package/dist/verify-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "5.5.0",
-  "built_against_sdd_cli": "5.5.0"
+  "version": "5.6.0",
+  "built_against_sdd_cli": "5.6.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sdd-method/verify-cli",
-  "version": "5.5.0",
-  "sddCliVersion": "5.5.0",
+  "version": "5.6.0",
+  "sddCliVersion": "5.6.0",
   "description": "Verify an SDD repository without changing it — validate, list, and read-only catalogue and pack checks. Ships only the code those verbs reach; it cannot write to the repository it is pointed at. Authoring and maintenance are in @sdd-method/sdd-cli.",
   "license": "UNLICENSED",
   "type": "module",