@sdd-method/verify-cli 0.1.1 → 0.3.0

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

@@ -78,6 +78,9 @@ export function renderRepoCapability(findings, metrics) {
             }));
         }
     }
+    if (metrics.total === 0 && findings.length === 0) {
+        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 pct = fmt1f((100.0 * resolved) / metrics.total);
@@ -125,6 +128,9 @@ export function renderServiceCapability(findings, metrics, tier) {
                 `capability_service.csv); check the aggregate next${leverageNote(f)}`);
         }
     }
+    if (metrics.total === 0 && findings.length === 0) {
+        lines.push(`[metric] service_capability_resolution (tier=${tier}): n/a — 0 service rows, nothing to resolve`);
+    }
     if (metrics.total > 0) {
         const resolved = metrics.claimed + metrics.exempt;
         const pct = fmt1f((100.0 * resolved) / metrics.total);
@@ -426,6 +432,14 @@ export function renderScoresCoverage(res, tier) {
                 `catalogue row — the assessment describes something the model no longer ` +
                 `holds; re-key the registry entry or withdraw the score`);
         }
+        else if (f.kind === "recorded-path-mismatch") {
+            // COVERAGE class — report-only by ruling (decision #3, 2026-09-29): it
+            // becomes gate-acting only once both estates read zero, and that is a
+            // deliberate later change to this one word, as for orphaned-score above.
+            out.push(`[finding] coverage: ${f.rubricId} score for ${f.subject} — the recorded file ` +
+                `is not the target's catalogue path, so the assessment may describe a copy the ` +
+                `catalogue cannot see; re-score against the catalogue path or re-point file_path`);
+        }
         else {
             out.push(`[finding] coverage: ${f.subject}`);
         }
@@ -470,6 +484,22 @@ export function renderScoresCoverage(res, tier) {
         out.push(`[metric] scores_coverage.${m.rubricId}: ${m.covered}/${m.eligible} ` +
             `${m.targetKind}(s) scored, ${m.scored} score(s) present, ${m.orphaned} orphaned`);
     }
+    // Recorded-path check (decision #3): stated for every rubric with scores,
+    // including the ones it cannot check — n/a is named, never read as agreement.
+    const scoredMetrics = res.metrics.filter((m) => m.scored > 0);
+    const checkable = scoredMetrics.filter((m) => m.recordedPath !== null);
+    const notCheckable = scoredMetrics.filter((m) => m.recordedPath === null);
+    if (scoredMetrics.length > 0) {
+        const sum = (k) => checkable.reduce((a, m) => a + (m.recordedPath?.[k] ?? 0), 0);
+        out.push(`[metric] scores_coverage.recorded_path: ${sum("agree")} agree, ${sum("mismatch")} mismatch, ` +
+            `${sum("noRecordedPath")} with no recorded path — across ${checkable.length} rubric(s) whose ` +
+            `catalogue holds the scored file's path` +
+            (notCheckable.length > 0
+                ? `; n/a for ${notCheckable.length} (${notCheckable.map((m) => m.rubricId).join(", ")}) — ` +
+                    `the catalogue does not hold the path of the file those rubrics score`
+                : "") +
+            ` (report-only; a path filled in from the catalogue agrees by construction)`);
+    }
     // The excluded population is printed BESIDE the denominator it shrank, never
     // folded into it. A reader comparing this run against a pre-filter baseline
     // must be able to see why the denominator moved without re-deriving it, and

package/dist/lib/catalogue/engine-validator.js

@@ -219,4 +219,21 @@ async function findTypeNonconformances(conn, schema, rowsByCatalogue) {
     }
     return out;
 }
+/**
+ * The population a PASS was measured over, for the verdict line. An FK or enum
+ * PASS over zero rows is true of nothing (empty-set sweep, R2): the count makes
+ * the zero visible. The `PASS` token itself is kept for anything that greps it.
+ */
+export function validatedPopulation(rowsByCatalogue) {
+    let rows = 0;
+    let nonEmpty = 0;
+    for (const r of rowsByCatalogue.values()) {
+        rows += r.length;
+        if (r.length > 0)
+            nonEmpty += 1;
+    }
+    return rows === 0
+        ? "0 rows — nothing was validated"
+        : `${rows} row(s) across ${nonEmpty} non-empty catalogue(s)`;
+}
 //# sourceMappingURL=engine-validator.js.map

package/dist/lib/catalogue/graph-projection.js

@@ -58,7 +58,24 @@ const THREE_FK_ENDPOINTS = {
     // capability→service dependency — the contract it is against — not an endpoint. The
     // edge stays capability→service; the contract rides as a property.
     capability_service: ["capability_id", "service_id"],
+    // schema 3.9.0 (M-ADR 0211) added entity_id as a third FK. M-ADR 0158 decides the
+    // edge: "entity_glossary is entity-to-term". domain_id is the row's scope, a
+    // property; a row with no entity_id degrades to a property of its glossary term.
+    entity_glossary: ["entity_id", "glossary_item_id"],
+    // schema 3.18.0 (M-ADR 0216): coverage is feature→integration; limiting_item_id is the
+    // PROPERTY that says why an unsupported pair is unsupported, not an endpoint.
+    feature_integration_support: ["feature_id", "integration_id"],
 };
+/**
+ * The catalogues a tier reads when no directory is named. The aggregate tier's
+ * data is the aggregator's output, `catalogues-aggregated/`: defaulting it to the
+ * member `catalogues/` made `--tier aggregate` run the aggregate rules over MEMBER
+ * rows — measured at a platform root, 1 reachable node instead of 2,316, a clean-
+ * looking miss of every cross-SDD consumer.
+ */
+export function defaultCataloguesDir(tier) {
+    return tier === "aggregate" ? "catalogues-aggregated" : "catalogues";
+}
 /**
  * Kinds must cover every schema catalogue — a catalogue without a kind
  * cannot be classified and the projection must not guess (the map is

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

@@ -34,7 +34,7 @@ import { join, resolve } from "node:path";
 import { readCatalogueCsv } from "./csv-reader.js";
 import { loadCanonicalSchema } from "./schema-loader.js";
 import { loadCatalogueKinds, loadRelationshipSemantics, } from "./relationship-semantics.js";
-import { projectGraph } from "./graph-projection.js";
+import { defaultCataloguesDir, projectGraph, } from "./graph-projection.js";
 function resolveFlow(edge, semantics) {
     const decl = edge.type.includes(".")
         ? semantics.entityFks.get(edge.type)
@@ -156,8 +156,8 @@ export async function computeImpactClosure(propagation, seed) {
 }
 export async function runCatalogueImpact(inputs, write) {
     const sddRoot = resolve(inputs.sddPath ?? process.cwd());
-    const dir = resolve(sddRoot, inputs.cataloguesDir ?? "catalogues");
     const tier = inputs.tier ?? "member";
+    const dir = resolve(sddRoot, inputs.cataloguesDir ?? defaultCataloguesDir(tier));
     if (!existsSync(dir)) {
         write(`catalogues directory not found at ${dir}\n` +
             `  Run \`sdd-cli catalogue build\` (or aggregate) first.\n`);

package/dist/lib/catalogue/manifest-loader.js

@@ -164,6 +164,12 @@ const ManifestSchema = z.object({
     // M-ADR 0208 §4.3: the platform this member is contained by. Canonical name;
     // `ecosystem_root` above is its deprecated alias (schema 1.10.0, removed at 2.0.0).
     platform_sdd_id: z.string().optional(),
+    // M-ADR 0056 (amended 2026-09-29, manifest schema 1.11.0): the SDD whose
+    // feature-tree.md holds this SDD's runway classifications, when it has none.
+    feature_tree_anchor: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/)
+        .optional(),
     aggregation_manifest_path: z.string().optional(),
     description: z.string().optional(),
     // Optional canonical C4 system id. Defaults to `{sdd_id}-system`. Set this
@@ -360,6 +366,9 @@ export async function loadSddManifest(sddPath, options) {
         ...(parsed.data.aggregation_manifest_path !== undefined
             ? { aggregationManifestPath: parsed.data.aggregation_manifest_path }
             : {}),
+        ...(parsed.data.feature_tree_anchor !== undefined
+            ? { featureTreeAnchor: parsed.data.feature_tree_anchor }
+            : {}),
         ...(parsed.data.description !== undefined ? { description: parsed.data.description } : {}),
         ...(parsed.data.lifecycle !== undefined ? { lifecycle: parsed.data.lifecycle } : {}),
         ...(parsed.data.surface !== undefined ? { surface: parsed.data.surface } : {}),

package/dist/lib/catalogue/platform-scope.js

@@ -0,0 +1,7 @@
+// Catalogues whose key is platform-scoped at organisation tier (M-ADR 0208 §4.4): two
+// platforms may each own a row of one id, so the key is (platform_sdd_id, id). Its own
+// module so a read-only verb (catalogue validate, reached by verify-cli) can use it
+// without importing the aggregator.
+// data_items (M-ADR 0216): each platform owns its vocabulary, as it owns its domains.
+export const PLATFORM_SCOPED_AT_ORGANISATION = ["domains", "data_items"];
+//# sourceMappingURL=platform-scope.js.map

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

@@ -754,11 +754,108 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
-  conformance_role:
+  implementation_role:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
-  conformance_lifecycle:
+  implementation_lifecycle:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
+  repo_scope:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  implementations:
+    kind: entity
+    scoring: scored-at-source
+    instrument: the binding is scored inside the integration SDD quality rubric (implementation-binding criteria); its identity against the snapshot manifests is a builder finding
+  implementation_members:
+    kind: edge
+    scoring: derived-edge
+    class: realisation
+    impact_flow: both
+    reason: derived from entity rows or manifest blocks scored at the owning entity
+  snapshots:
+    kind: entity
+    scoring: predicate
+    instrument: the snapshot record itself — scoring it with a rubric would be circular. Its integrity is sdd-cli snapshot verify (manifest shape, member folders, companion fields) and the builder's implementation-identity finding
+    relationships:
+      implementation_id:
+        class: membership
+        impact_flow: toward-target
+      prior_snapshot_id:
+        class: lineage
+        impact_flow: none
+  snapshot_members:
+    kind: edge
+    scoring: derived-edge
+    class: membership
+    impact_flow: none
+    reason: derived from entity rows or manifest blocks scored at the owning entity
+  evidence_direction:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  member_presence:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  conformance_disposition:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  delta_disposition:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  data_items:
+    kind: entity
+    scoring: predicate
+    instrument: FK resolution of every supply and demand row against it at aggregation, and the coverage derivation that reads canonical_field (M-ADR 0216 §4.4)
+  integration_data_item:
+    kind: edge
+    scoring: predicate
+    class: realisation
+    impact_flow: both
+    instrument: the supply contradiction check (a positive and a negative row for one item is a divergence finding) and the reported section age (M-ADR 0216 §4.2)
+  feature_data_requirement:
+    kind: edge
+    scoring: predicate
+    class: dependency
+    impact_flow: toward-source
+    instrument: FK resolution against the platform's data_items at aggregation, and the fraction of features declaring any requirement, reported beside coverage (M-ADR 0216 §5)
+  feature_integration_support:
+    kind: edge
+    scoring: derived-edge
+    class: traceability
+    impact_flow: none
+    reason: derived at aggregation from supply and demand, each checked at its source
+  supply_verdict:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  supply_basis:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  data_necessity:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  support_verdict:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  limiting_reason:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  evidence_target_repo:
+    kind: entity
+    scoring: predicate
+    instrument: "FK resolution against repositories at aggregation: a reference that names no repository fails like any other foreign key (M-ADR 0214 §4.10)"
+    relationships:
+      repo_id:
+        class: xref
+        impact_flow: toward-source

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

@@ -193,6 +193,7 @@ export const RUBRIC_ELIGIBILITY = [
         refTransform: (r) => `regexp_replace(${r}, '^[A-Z]+-ADR-', 'ADR-')`,
         eligibilityFilter: "status = 'Accepted'",
         managedPathColumn: "doc_path",
+        canonicalPathColumn: "doc_path",
         eligibilityNote: "Accepted only, and adopter-owned only. A Proposed ADR is mid-decision and a Superseded one is history; requiring a current score on either would manufacture a gap nobody should close. The managed-path rule adds the second half of the same argument, ruled 2026-08-07: an adopter cannot remediate an ADR that sync overwrites, so a method-managed ADR is not in the adopter's denominator — its quality belongs to the producer's own registry, and an adopter's assessment of it is feedback to raise rather than a row to maintain. Measured at both estates 2026-08-08 (committed catalogues, member tier): forward 203 Accepted -> 83 adopter-owned (120 excluded); reverse 182 Accepted -> 62 adopter-owned (120 excluded). Zero rows under a producer path escaped the lock at either estate, so the lock and a path heuristic agree on today's data — the lock is used anyway, because agreement today is not the same as being the right rule.",
     },
     {
@@ -202,6 +203,7 @@ export const RUBRIC_ELIGIBILITY = [
         joinColumn: "spec_path",
         refTransform: null,
         eligibilityFilter: "status <> 'deprecated'",
+        canonicalPathColumn: "spec_path",
         eligibilityNote: "Every non-deprecated contract. Deprecated contracts are excluded for the same reason the contract-coverage predicate excludes them — they are on the way out, and scoring them is work with no consumer.",
     },
     {
@@ -429,6 +431,7 @@ export async function runScoresCoverage(session, options) {
                     orphaned: 0,
                     managedExcluded: 0,
                     managedExcludedByBundle: {},
+                    recordedPath: null,
                 });
             }
             continue;
@@ -473,6 +476,7 @@ export async function runScoresCoverage(session, options) {
                 orphaned: 0,
                 managedExcluded,
                 managedExcludedByBundle,
+                recordedPath: spec.canonicalPathColumn !== undefined ? { agree: 0, mismatch: 0, noRecordedPath: 0 } : null,
             });
             continue;
         }
@@ -518,6 +522,39 @@ export async function runScoresCoverage(session, options) {
                 });
             }
         }
+        // Direction 4 — a resolved score whose RECORDED path is not the target's
+        // canonical path (decision #3, report-only). Paths are normalised on both
+        // sides (leading `./` stripped, backslashes to `/`) before comparison. A
+        // path the builder filled in from the catalogue agrees by construction —
+        // the metric says "agree", not "verified".
+        let recordedPath = null;
+        if (spec.canonicalPathColumn !== undefined) {
+            const pairs = await rows(session, `SELECT s.target_ref, s.target_path, c."${spec.canonicalPathColumn}"
+           FROM (${scoreSet}) s
+           JOIN "${spec.catalogue}" c ON c."${spec.joinColumn}" = ${ref}
+          ORDER BY s.target_ref;`);
+            let agree = 0;
+            let mismatch = 0;
+            let noRecordedPath = 0;
+            const n = (v) => String(v ?? "").replace(/\\/g, "/").replace(/^(\.\/)+/, "");
+            for (const [targetRef, recorded, canonical] of pairs) {
+                const r = n(recorded);
+                const c = n(canonical);
+                if (r === "")
+                    noRecordedPath++;
+                else if (c === "" || r === c)
+                    agree++;
+                else {
+                    mismatch++;
+                    findings.push({
+                        kind: "recorded-path-mismatch",
+                        rubricId: spec.rubricId,
+                        subject: `${String(targetRef)} — recorded "${r}", catalogue "${c}"`,
+                    });
+                }
+            }
+            recordedPath = { agree, mismatch, noRecordedPath };
+        }
         const eligible = Number((await rows(session, `SELECT COUNT(*) FROM "${spec.catalogue}" WHERE (${eligibleWhere});`))[0][0]);
         metrics.push({
             rubricId: spec.rubricId,
@@ -528,6 +565,7 @@ export async function runScoresCoverage(session, options) {
             orphaned: orphaned.length,
             managedExcluded,
             managedExcludedByBundle,
+            recordedPath,
         });
     }
     return { findings, metrics, undeclaredRubrics, notAdopted, stalenessBasis, totalScores, transformBridgedRefs };

package/dist/lib/catalogue/validate.js

@@ -11,19 +11,28 @@
 // Outputs the same shape of findings as `build` so consumers can pipe
 // either through the same parser. Exit 0 on PASS; non-zero on shape
 // drift OR internal-FK FAIL.
-import { stat } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { CLI_VERSION } from "./cli-version.js";
 import { readCatalogueCsv } from "./csv-reader.js";
 import { writeCatalogue } from "./csv-writer.js";
-import { validateWithEngineToLog } from "./engine-validator.js";
+import { validatedPopulation, validateWithEngineToLog } from "./engine-validator.js";
 import { FindingsLog } from "./findings.js";
+import { PLATFORM_SCOPED_AT_ORGANISATION } from "./platform-scope.js";
 import { loadCanonicalSchema } from "./schema-loader.js";
 export async function runCatalogueValidate(inputs, write) {
     const sddPath = resolve(inputs.sddPath ?? process.cwd());
-    const cataloguesDir = join(sddPath, "catalogues");
+    // An organisation root is aggregate-only by construction (M-ADR 0208): its own
+    // catalogues/ is deliberately empty and catalogues-aggregated/ is all it produces.
+    // Validating the empty member directory reported every file missing — a check
+    // that could only fail on such a root. Validate what it actually publishes.
+    const orgRoot = await isOrganisationRoot(sddPath);
+    const dirName = orgRoot ? "catalogues-aggregated" : "catalogues";
+    const cataloguesDir = join(sddPath, dirName);
     const schema = await loadCanonicalSchema();
     write(`sdd-cli catalogue validate (canonical schema ${schema.schemaVersion}, cli ${CLI_VERSION})\n`);
+    if (orgRoot)
+        write(`organisation root: validating ${dirName}/ (an organisation root publishes only its aggregate)\n`);
     // Existence check on catalogues/ — fail fast with a clear message.
     try {
         const s = await stat(cataloguesDir);
@@ -51,7 +60,7 @@ export async function runCatalogueValidate(inputs, write) {
             if (err.code === "ENOENT") {
                 // Missing file is a shape failure — every catalogue declared in
                 // the schema MUST have a CSV (headers-only acceptable).
-                findings.add("convention", `catalogues/${cat.name}.csv missing — every schema catalogue must have a file (headers-only acceptable)`);
+                findings.add("convention", `${dirName}/${cat.name}.csv missing — every schema catalogue must have a file (headers-only acceptable)`);
                 columnShapeOk = false;
                 rowsByCatalogue.set(cat.name, []);
                 continue;
@@ -61,7 +70,7 @@ export async function runCatalogueValidate(inputs, write) {
         const expected = cat.columns.map((c) => c.name);
         const drift = compareColumns(expected, parsed.columns);
         if (drift !== null) {
-            findings.add("convention", `catalogues/${cat.name}.csv: column shape drift — ${drift}`);
+            findings.add("convention", `${dirName}/${cat.name}.csv: column shape drift — ${drift}`);
             columnShapeOk = false;
         }
         rowsByCatalogue.set(cat.name, parsed.rows);
@@ -77,19 +86,24 @@ export async function runCatalogueValidate(inputs, write) {
     // cutover; same semantics, findings text unchanged — the A2/A3 dual-run
     // record is the evidence). Enum hard-fail behaviour per M-ADR 0203 §4.1
     // is unchanged: an out-of-set value is an error-severity finding.
-    const { fk, enums } = await validateWithEngineToLog(schema, rowsByCatalogue, findings, { ...(profile !== undefined ? { profile } : {}) });
+    const { fk, enums } = await validateWithEngineToLog(schema, rowsByCatalogue, findings, {
+        ...(profile !== undefined ? { profile } : {}),
+        // At organisation tier `domains` is keyed (platform_sdd_id, id): two platforms may
+        // each own a domain of one name, exactly as the aggregator validates it.
+        ...(orgRoot ? { platformScopedTargets: PLATFORM_SCOPED_AT_ORGANISATION } : {}),
+    });
     // Report.
     const findingsText = findings.render();
     if (findingsText)
         write(`\n${findingsText}\n`);
     if (columnShapeOk) {
-        write(`\nColumn-shape check: PASS\n`);
+        write(`\nColumn-shape check: PASS (${validatedPopulation(rowsByCatalogue)})\n`);
     }
     else {
         write(`\nColumn-shape check: FAIL\n`);
     }
     if (fk.internalPass) {
-        write(`FK validation (internal): PASS\n`);
+        write(`FK validation (internal): PASS (${validatedPopulation(rowsByCatalogue)})\n`);
     }
     else {
         write(`FK validation (internal): FAIL (${fk.internalFailures.length} dangling)\n`);
@@ -98,7 +112,7 @@ export async function runCatalogueValidate(inputs, write) {
         }
     }
     if (enums.pass) {
-        write(`Enum validation (column_enums): PASS\n`);
+        write(`Enum validation (column_enums): PASS (${validatedPopulation(rowsByCatalogue)})\n`);
     }
     else {
         write(`Enum validation (column_enums): FAIL (${enums.violations.length} out-of-set)\n`);
@@ -173,4 +187,14 @@ function compareColumns(expected, actual) {
         parts.push(`unexpected: ${extra.join(",")}`);
     return parts.join("; ");
 }
+/** True when the SDD's manifest declares it an organisation root (aggregate-only). */
+async function isOrganisationRoot(sddPath) {
+    try {
+        const raw = await readFile(join(sddPath, ".sdd", "sdd-manifest.yaml"), "utf8");
+        return /^category:\s*"?organisation-root"?\s*$/m.test(raw);
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=validate.js.map

package/dist/lib/validate/aggregate.js

@@ -1,28 +1,43 @@
 const WARN_MARKER = "[WARN]";
+// A validator that ran over an EMPTY population says so with an `[N/A]` line
+// and prints no `[PASS]`. Counting it as passed is the vacuous pass the
+// empty-set sweep measured (an empty platform SDD validated `passed=8`); it is
+// counted apart instead (R1, ruled 2026-09-29). Exit codes are unchanged: a
+// run that measured nothing neither passes nor fails the gate — it is named.
+// A script that measured PART of its population prints real `[PASS]` lines,
+// so a stray `[N/A]` on one sub-check never demotes a real pass.
+const NA_LINE = /^\[N\/A\]/m;
+const PASS_LINE = /^\[PASS\]/m;
+export function classifyResult(r, opts) {
+    if (r.status === "skip")
+        return "skipped";
+    if (r.exitCode !== 0)
+        return "failed";
+    const hasWarn = r.stdout.includes(WARN_MARKER);
+    if (opts.strict && hasWarn)
+        return "failed";
+    if (NA_LINE.test(r.stdout) && !PASS_LINE.test(r.stdout))
+        return "not-measured";
+    return hasWarn ? "warned" : "passed";
+}
 export function aggregateResults(results, opts) {
     let passed = 0;
     let failed = 0;
     let skipped = 0;
     let warned = 0;
+    let notMeasured = 0;
     for (const r of results) {
-        if (r.status === "skip") {
+        const outcome = classifyResult(r, opts);
+        if (r.status === "run" && r.exitCode === 0 && r.stdout.includes(WARN_MARKER))
+            warned++;
+        if (outcome === "skipped")
             skipped++;
-            continue;
-        }
-        const hasWarn = r.stdout.includes(WARN_MARKER);
-        if (r.exitCode !== 0) {
+        else if (outcome === "failed")
             failed++;
-        }
-        else if (hasWarn) {
-            warned++;
-            if (opts.strict)
-                failed++;
-            else
-                passed++;
-        }
-        else {
+        else if (outcome === "not-measured")
+            notMeasured++;
+        else
             passed++;
-        }
     }
     return {
         exitCode: failed > 0 ? 1 : 0,
@@ -30,6 +45,7 @@ export function aggregateResults(results, opts) {
         failed,
         skipped,
         warned,
+        notMeasured,
     };
 }
 //# sourceMappingURL=aggregate.js.map

package/dist/lib/validate/bundle-coherence.js

@@ -52,8 +52,13 @@ export async function checkBundleCoherence(targetRepo) {
     }
     const expected = EXPECTED_FORWARD_BASE[profile];
     if (expected === undefined) {
-        lines.push(`[PASS] bundle-coherence: profile '${profile}' declares no forward-base expectation\n`);
-        return { exitCode: 0, stdout: lines.join("") };
+        // Nothing to compare is not a pass: counting it as one inflated the
+        // suite's "passed" figure for profiles that carry no expectation.
+        return {
+            exitCode: 0,
+            stdout: "",
+            skipped: `profile '${profile}' declares no forward-base expectation — nothing to compare`,
+        };
     }
     if (forwardBase.name === expected) {
         lines.push(`[PASS] bundle-coherence: profile '${profile}' ↔ forward base '${forwardBase.name}'\n`);

package/dist/lib/validate/dispatch.js

@@ -1,4 +1,5 @@
 import { checkBundleCoherence } from "./bundle-coherence.js";
+import { checkYamlParse } from "./yaml-parse.js";
 // Validators that accept --app-root / --repo-root flags work fine from the
 // bundled location because they override their internal ROOT_DIR via the
 // flag. Validators without that flag (adr-structure, runway-classification,
@@ -65,6 +66,14 @@ const APP_VALIDATORS = [
         },
         build: () => ({ status: "run", args: [] }),
     },
+    {
+        name: "yaml-parse",
+        source: {
+            kind: "native",
+            run: async (ctx) => checkYamlParse(ctx.targetRepo),
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
     // Note: validate-runway-classification is intentionally NOT in the app set.
     // It requires platform-level files (docs/platform/feature-tree.md,
     // architecture-runway-index.md) that app repos don't own. Per ADR 0089,
@@ -109,6 +118,14 @@ const INTEGRATION_VALIDATORS = [
         },
         build: () => ({ status: "run", args: [] }),
     },
+    {
+        name: "yaml-parse",
+        source: {
+            kind: "native",
+            run: async (ctx) => checkYamlParse(ctx.targetRepo),
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
 ];
 const PLATFORM_VALIDATORS = [
     {
@@ -183,6 +200,14 @@ const PLATFORM_VALIDATORS = [
         },
         build: () => ({ status: "run", args: [] }),
     },
+    {
+        name: "yaml-parse",
+        source: {
+            kind: "native",
+            run: async (ctx) => checkYamlParse(ctx.targetRepo),
+        },
+        build: () => ({ status: "run", args: [] }),
+    },
     // Optional: the upstream validate-docs.sh dispatcher covers the 6
     // conditional validators (backward-compatibility, deprecation-runway,
     // migration-completeness, ddd-artifacts, glossary-alignment,

package/dist/lib/validate/index.js

@@ -1,5 +1,5 @@
 import { profileFromRepoKind, readRepoKind } from "../repo-kind.js";
-import { aggregateResults } from "./aggregate.js";
+import { aggregateResults, classifyResult } from "./aggregate.js";
 import { selectValidators } from "./dispatch.js";
 import { runValidator } from "./runner.js";
 const SECTION_RULE = "═".repeat(59);
@@ -35,13 +35,17 @@ export async function runValidate(opts, stdout = (line) => process.stdout.write(
             stdout(result.stdout);
         if (result.stderr)
             stdout(result.stderr);
-        if (result.exitCode === 0)
-            stdout(pass(`${cfg.name}: ok`));
-        else
+        if (result.exitCode !== 0)
             stdout(fail(`${cfg.name}: exit ${result.exitCode}`));
+        else if (classifyResult(result, { strict: opts.strict }) === "not-measured") {
+            stdout(na(`${cfg.name}: nothing measured — its population is empty`));
+        }
+        else
+            stdout(pass(`${cfg.name}: ok`));
     }
     const summary = aggregateResults(results, { strict: opts.strict });
-    stdout(info(`Summary: passed=${summary.passed} failed=${summary.failed} skipped=${summary.skipped} warned=${summary.warned}${opts.strict ? " (strict)" : ""}`));
+    stdout(info(`Summary: passed=${summary.passed} failed=${summary.failed} skipped=${summary.skipped} ` +
+        `not-measured=${summary.notMeasured} warned=${summary.warned}${opts.strict ? " (strict)" : ""}`));
     stdout(verdict(summary, validators.length));
     return { exitCode: summary.exitCode, summary };
 }
@@ -55,14 +59,29 @@ function verdict(summary, selected) {
     if (summary.exitCode !== 0)
         return fail("One or more validators failed");
     const ran = summary.passed + summary.failed;
-    if (summary.skipped === 0)
+    const nm = summary.notMeasured;
+    if (summary.skipped === 0 && nm === 0)
         return pass("All validators passed");
-    if (ran === 0) {
+    if (ran === 0 && nm === 0) {
         return warn(`0 of ${selected} validators ran — all ${summary.skipped} skipped. ` +
             `This is an absence of evidence, not a pass.`);
     }
-    return warn(`${ran} of ${selected} validators passed — ${summary.skipped} skipped, ` +
-        `and a skipped validator is not covered by this verdict.`);
+    if (nm === 0) {
+        return warn(`${ran} of ${selected} validators passed — ${summary.skipped} skipped, ` +
+            `and a skipped validator is not covered by this verdict.`);
+    }
+    const uncovered = [
+        summary.skipped > 0 ? `${summary.skipped} skipped` : "",
+        nm > 0 ? `${nm} measured nothing (an empty population)` : "",
+    ]
+        .filter(Boolean)
+        .join(", ");
+    if (ran === 0) {
+        return warn(`0 of ${selected} validators measured anything — ${uncovered}. ` +
+            `This is an absence of evidence, not a pass.`);
+    }
+    return warn(`${ran} of ${selected} validators passed — ${uncovered}; ` +
+        `neither is covered by this verdict.`);
 }
 function section(title) {
     return `\n${SECTION_RULE}\n  ${title}\n${SECTION_RULE}\n\n`;
@@ -79,10 +98,13 @@ function fail(msg) {
 function skip(msg) {
     return `[SKIP] ${msg}\n`;
 }
+function na(msg) {
+    return `[N/A] ${msg}\n`;
+}
 function warn(msg) {
     return `[WARN] ${msg}\n`;
 }
 function emptySummary() {
-    return { exitCode: 1, passed: 0, failed: 0, skipped: 0, warned: 0 };
+    return { exitCode: 1, passed: 0, failed: 0, skipped: 0, warned: 0, notMeasured: 0 };
 }
 //# sourceMappingURL=index.js.map