@sdd-method/verify-cli 5.5.1 → 5.7.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