@sdd-method/author-cli 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,552 @@
+/**
+ * Coverage renderers — M-ADR 0205 §4.4 (A4 CS-2).
+ *
+ * Each function renders a predicate's structured result into the EXACT
+ * stdout lines its reference shell script prints. The text is a
+ * compatibility contract: adopters' findings baselines hold these literal
+ * lines, so every string here is copied from the reference, never
+ * paraphrased. Line ORDER within a predicate follows the reference's
+ * print order (metrics/controls/findings blocks); WITHIN a block the
+ * engine's total ORDER BY governs, which may differ from the reference's
+ * file-row order — baselines compare by membership, and the line-parity
+ * driver compares sorted multisets.
+ *
+ * Percentages use Python's %.1f semantics (round-half-even on the scaled
+ * value), because the references print through Python f-strings.
+ */
+import { renderFindingLine } from "./finding-identity.js";
+/** Python `%.1f` — half to even at an exact scaled .5, else nearest. */
+export function fmt1f(x) {
+    const scaled = x * 10;
+    const floor = Math.floor(scaled);
+    const diff = scaled - floor;
+    let n;
+    if (diff > 0.5)
+        n = floor + 1;
+    else if (diff < 0.5)
+        n = floor;
+    else
+        n = floor % 2 === 0 ? floor : floor + 1;
+    return (n / 10).toFixed(1);
+}
+export function renderRepoCapability(findings, metrics) {
+    const lines = [];
+    // These four templates are the measured reason identity is EMITTED rather
+    // than recovered: they embed the subject in prose, and between them they
+    // account for all 243 baseline lines across 62 repos that no general parse
+    // can key. The subject was structurally available at every one of them all
+    // along — `f.subjectId` — it simply never reached the line.
+    for (const f of findings) {
+        const subject = `repo:${f.subjectId}`;
+        if (f.classification === "conflict") {
+            lines.push(renderFindingLine({
+                category: "divergence",
+                subject,
+                summary: `repo ${f.subjectId} declares capability_exemption ` +
+                    `(${f.exemptionReason ?? ""}) but also has a repo_capability edge — an exempt repository ` +
+                    `must not claim a capability (per M-ADR 0188 §4.1)`,
+            }));
+        }
+        else if (f.classification === "shape_a") {
+            const names = (f.unclaimedServices ?? []).join(", ") +
+                ((f.unclaimedCount ?? 0) > 3 ? " …" : "");
+            lines.push(renderFindingLine({
+                category: "orphan",
+                subject,
+                summary: `repo ${f.subjectId} resolves to no capability in this SDD's ` +
+                    `own catalogues; its service(s) [${names}] have no capability_service row ` +
+                    `here — check the aggregate's capability_service.csv for this service_id ` +
+                    `before assuming the edge is missing (per M-ADR 0188 §6.2b)`,
+            }));
+        }
+        else if (f.classification === "claimed_unresolved") {
+            lines.push(renderFindingLine({
+                category: "orphan",
+                subject,
+                summary: `repo ${f.subjectId} resolves to no capability although its ` +
+                    `service(s) are claimed — check services.primary_repo_id is populated ` +
+                    `(per M-ADR 0157 §4.3)`,
+            }));
+        }
+        else {
+            lines.push(renderFindingLine({
+                category: "orphan",
+                subject,
+                summary: `repo ${f.subjectId} resolves to no capability, has no service ` +
+                    `row, and declares no capability_exemption — declare capabilities: or ` +
+                    `capability_exemption (per M-ADR 0188 §4.1)`,
+            }));
+        }
+    }
+    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);
+        lines.push(`[metric] repo_capability_resolution: ${resolved}/${metrics.total} (${pct}%) ` +
+            `— ${metrics.byCapability} by capability, ${metrics.byExemption} by exemption, ` +
+            `${metrics.conflicting} conflicting, ${metrics.unresolved} unresolved`);
+        if (metrics.unresolved > 0) {
+            lines.push(`[metric] repo_capability_orphan_shape: ${metrics.shapeA} with no local ` +
+                `capability_service row for the service (check the aggregate before ` +
+                `assuming the edge is missing), ${metrics.shapeB} with no service row (declare ` +
+                `capabilities: or capability_exemption), ${metrics.other} other`);
+        }
+    }
+    return lines;
+}
+function leverageNote(f) {
+    if (f.leverage === undefined)
+        return "";
+    if (f.leverage === "na")
+        return " [leverage: n/a — no primary_repo_id]";
+    if (f.leverage === "yes") {
+        return (` [leverage: yes — claiming this service would also resolve ` +
+            `repo ${f.primaryRepo}'s repo_capability shape-(a) orphan via Path X]`);
+    }
+    return ` [leverage: no — repo ${f.primaryRepo} already resolves]`;
+}
+export function renderServiceCapability(findings, metrics, tier) {
+    const lines = [];
+    for (const f of findings) {
+        if (f.classification === "conflict") {
+            lines.push(`[finding] divergence: service ${f.subjectId} declares service_capability_exemption ` +
+                `(${f.exemptionReason ?? ""}) but also has a capability_service edge — an exempt service ` +
+                `must not claim a capability (per M-ADR 0133 §4.2b)`);
+        }
+        else if (tier === "aggregate") {
+            lines.push(`[finding] orphan: service ${f.subjectId} resolves to no capability anywhere in ` +
+                `the merged estate and declares no exemption — M-ADR 0196 §4.1 gap class ` +
+                `unauthored-surface (not itself a method defect; remedy is to claim, ` +
+                `exempt, or accept the surface)${leverageNote(f)}`);
+        }
+        else {
+            lines.push(`[finding] coverage: service ${f.subjectId} has no capability_service row and no ` +
+                `exemption in this SDD's own catalogues — classification cannot complete ` +
+                `at member tier (a claim may exist in a sibling SDD's own ` +
+                `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);
+        const label = tier === "aggregate" ? "orphaned" : "unresolved-locally";
+        lines.push(`[metric] service_capability_resolution (tier=${tier}): ${resolved}/${metrics.total} ` +
+            `(${pct}%) — ${metrics.claimed} claimed, ${metrics.exempt} exempt, ` +
+            `${metrics.conflicting} conflicting, ${metrics.unresolved} ${label}`);
+        if (metrics.leverage !== undefined && metrics.unresolved > 0) {
+            lines.push(`[metric] service_capability_leverage (tier=${tier}): ${metrics.leverage.yes} would ` +
+                `also resolve a repo_capability shape-(a) orphan via Path X, ${metrics.leverage.no} ` +
+                `would not (repo already resolves), ${metrics.leverage.na} n/a (no primary_repo_id)`);
+        }
+    }
+    return lines;
+}
+export function renderEventCoverage(res, tier) {
+    if (res.na) {
+        return [
+            `[metric] event_coverage (tier=${tier}): n/a — this unit holds no events.csv ` +
+                `rows. Both event sources (contracts/avro discovery; per-domain ` +
+                `event-catalog.yaml) are platform-profile surfaces, so for app/integration ` +
+                `units this cell classifies BY-METAMODEL (M-ADR 0196 §4.1): no event node ` +
+                `surface exists here. For a platform unit, this is an unauthored/undiscovered ` +
+                `surface instead — check contracts/avro/ and docs/domains/*/contracts/events/.`,
+        ];
+    }
+    const m = res.metrics;
+    const c = res.controls;
+    const label = tier === "member" ? "unresolved-locally" : "orphaned";
+    const lines = [
+        `[metric] event_coverage (tier=${tier}): ${m.covered + m.viaContract}/${m.total} covered ` +
+            `(${m.covered} attributed, ${m.viaContract} covered-as-contract), ` +
+            `${m.unresolved} ${label}`,
+        `[metric] capability-reach (chain readout, never a verdict): ${m.capReach}/${m.total} ` +
+            `events whose attributed service is claimed by a capability`,
+        `[metric] consumer-enumerability (M-ADR 0057 analogue, never a verdict): ` +
+            `${m.consumerEnum}/${m.total} events with at least one role=consumes attribution`,
+    ];
+    if (c.colUnresolving.length > 0) {
+        lines.push(`[control] publisher column set but UNRESOLVING against services.csv: ` +
+            `${c.colUnresolving.length}`);
+        for (const x of c.colUnresolving) {
+            lines.push(`  - ${x.eventId} (publisher_service_id=${x.publisher})`);
+        }
+    }
+    if (c.colNoEdge.length > 0) {
+        lines.push(`[control] column-vs-edge disagreement — publisher resolves but no ` +
+            `publishes edge exists: ${c.colNoEdge.length}`);
+        for (const x of c.colNoEdge)
+            lines.push(`  - ${x}`);
+    }
+    if (c.edgeNoCol.length > 0) {
+        lines.push(`[control] column-vs-edge disagreement — publishes edge exists but the ` +
+            `row's publisher column is empty: ${c.edgeNoCol.length}`);
+        for (const x of c.edgeNoCol)
+            lines.push(`  - ${x}`);
+    }
+    for (const f of res.findings) {
+        if (tier === "aggregate") {
+            lines.push(`[finding] orphan: event ${f.subjectId} is attributed to nothing in the merged ` +
+                `estate — no service_event row and no resolving publisher_service_id. ` +
+                `Next checks, by authoring direction: forward — is a repo-config ` +
+                `\`events:\` block authored for its producer, or is this an avsc-only ` +
+                `discovery? reverse — is the event-catalog.yaml \`publisher\` field ` +
+                `empty, or the catalog file absent for its domain (the 0156 class)? ` +
+                `Do not 'declare the event' — the row already exists; what is missing ` +
+                `is attribution.`);
+        }
+        else {
+            lines.push(`[report] unresolved-locally: event ${f.subjectId} carries no local attribution. ` +
+                `A sibling's event-catalog consumers[] may attribute it at aggregate ` +
+                `tier; absence is not assertable here (M-ADR 0199 §4.3).`);
+        }
+    }
+    return lines;
+}
+export function renderContractCoverage(res, tier) {
+    if (res.na) {
+        return [
+            `[metric] contract_coverage (tier=${tier}): n/a — this unit holds no ` +
+                `contracts.csv rows, so there is no population to score. The contracts ` +
+                `discoverer is unconditional across profiles, so this is an unauthored ` +
+                `surface at the node catalogue (M-ADR 0196 §4.1), not out of scope by profile.`,
+        ];
+    }
+    const lines = [];
+    if (res.availability !== undefined) {
+        lines.push(`[info] availability manifest: ${res.availability.attested} attested artefact(s), ` +
+            `${res.availability.unmodelled.length} with no contract row (attested but not ` +
+            `declared-external — participation is a separate claim, M-ADR 0202)`);
+        for (const pp of res.availability.unmodelled)
+            lines.push(`  - ${pp}`);
+    }
+    if (res.availabilityWarning !== undefined) {
+        lines.push(`[warn] availability manifest unreadable: ${res.availabilityWarning}`);
+    }
+    for (const f of res.findings) {
+        if (f.kind === "divergence") {
+            lines.push(`[finding] divergence: contract ${f.subjectId} is excluded from scoring ` +
+                `(${f.classification}) but also carries a live ` +
+                `capability_contract or service_contract edge — the exclusion asserts it ` +
+                `is not expected to be reachable and the edge says it is; check which is ` +
+                `stale`);
+        }
+        else if (tier === "aggregate") {
+            lines.push(`[finding] orphan: contract ${f.subjectId} is reachable from nothing in the ` +
+                `merged estate — no capability_contract row (no owner in the product ` +
+                `model) and no service_contract row (no runtime attribution). Under ` +
+                `M-ADR 0057 lock semantics its consumers cannot be enumerated, so it ` +
+                `can be neither safely changed nor safely retired. Next checks: is a ` +
+                `traceability.contracts entry authored but unresolved (see the ` +
+                `capability_contract orphan findings from the build), and does this ` +
+                `estate have an exposes surface at all (repo-config contracts: ` +
+                `blocks)? If this contract is legitimately unreachable, none of the ` +
+                `four scoped-out states covers it — raise it, because that case is ` +
+                `the trigger for opening an exemption vocabulary`);
+        }
+        else {
+            lines.push(`[finding] coverage: contract ${f.subjectId} has no capability_contract and no ` +
+                `service_contract row in this SDD's own catalogues — classification ` +
+                `cannot complete at member tier, because a service_contract row about ` +
+                `this contract may be authored in a sibling SDD (both its FKs are ` +
+                `external). Check the aggregate next`);
+        }
+    }
+    const m = res.metrics;
+    const resolved = m.covered + m.viaEvent + m.excluded;
+    const label = tier === "aggregate" ? "orphaned" : "unresolved-locally";
+    lines.push(`[metric] contract_coverage (tier=${tier}): ${resolved}/${m.total} ` +
+        `(${fmt1f((100.0 * resolved) / m.total)}%) — ${m.covered} covered, ${m.viaEvent} ` +
+        `covered-as-event, ${m.excluded} excluded, ${m.conflicting} conflicting, ` +
+        `${m.unresolved} ${label}`);
+    const exclusionKeys = Object.keys(m.byExclusion).sort();
+    if (exclusionKeys.length > 0) {
+        lines.push(`[metric] contract_excluded (tier=${tier}): ` +
+            exclusionKeys.map((k) => `${k} ${m.byExclusion[k]}`).join(", "));
+    }
+    lines.push(`[metric] contract_consumer_enumerable (tier=${tier}): ${m.consumersNamed}/${m.total} ` +
+        `(${fmt1f((100.0 * m.consumersNamed) / m.total)}%) carry a service_contract role=consumes ` +
+        `row. This is the property M-ADR 0057 lock semantics need and it is REPORTED, NOT ` +
+        `VERDICTED: the consumes surface is reverse-method only (an adopter alias map over ` +
+        `service-architecture.md), so a forward-authored estate scores zero here by ` +
+        `construction rather than by neglect`);
+    lines.push(`[metric] contract_attribution_shape (tier=${tier}): ${m.ownedOnly} owner-only, ` +
+        `${m.attrOnly} runtime-only, ${m.both} both — a population covered wholly by one edge ` +
+        `rests on one authoring surface`);
+    return lines;
+}
+// ─── the nine Phase-0 gate checks ────────────────────────────────────────
+export function renderEventCatalogueCheck(gaps) {
+    return gaps.map((g) => `[finding] coverage: domain ${g.domain} event-catalog.yaml declares ${g.declared} events but events.csv contains ${g.emitted} rows for that domain (per ADR 0156 Phase 0)`);
+}
+export function renderRepoEdgesCheck(res) {
+    const lines = [];
+    if (res.repoCapabilityGap) {
+        const g = res.repoCapabilityGap;
+        lines.push(`[finding] coverage: repo_capability.csv is empty but ${g.capabilityService} capability_service rows + ${g.servicesWithRepo} services with primary_repo_id present — reverse-method derivation likely missing (per ADR 0157 §4.3, Phase 0)`);
+    }
+    if (res.repoContractForwardGap) {
+        const g = res.repoContractForwardGap;
+        lines.push(`[finding] coverage: repo_contract.csv is empty but ${g.contracts} contracts and ${g.repoConfigsWithContracts} repo-configs with contracts: blocks present — forward-method derivation likely missing (per ADR 0157 §4.2, Phase 0)`);
+    }
+    if (res.repoContractPathXGap) {
+        const g = res.repoContractPathXGap;
+        lines.push(`[finding] coverage: repo_contract.csv is empty but ${g.serviceContracts} service_contract rows + ${g.servicesWithRepo} services with primary_repo_id present — reverse-method Path X (service_contract ⋈ services.primary_repo_id) derivation likely missing (per ADR 0157 §4.2, Phase 0)`);
+    }
+    if (res.repoContractReverseGap) {
+        const g = res.repoContractReverseGap;
+        lines.push(`[finding] coverage: repo_contract.csv is empty with ${g.contracts} contracts present and no repo-config.contracts: blocks or service_contract rows — reverse-method derivation via contracts.source_repo_id likely missing (per ADR 0157 §4.2, Phase 0)`);
+    }
+    return lines;
+}
+export function renderGlossaryXrefCheck(finding) {
+    return finding
+        ? [
+            `[finding] coverage: docs/platform/reference/glossary-alignment-manifest.yaml exists but glossary_xref.csv emits 0 rows — multi-source derivation likely missing (per ADR 0158 §4.5, Phase 0)`,
+        ]
+        : [];
+}
+export function renderDataModelEntitiesCheck(res) {
+    const lines = [];
+    if (res.entitiesGap) {
+        lines.push(`[finding] coverage: ${res.entitiesGap.domainModels} domain-model files catalogued but entities.csv emits 0 rows — reverse-method entity extraction missing (per ADR 0159 Phase 0)`);
+    }
+    if (res.serviceEntityGap) {
+        const g = res.serviceEntityGap;
+        lines.push(`[finding] coverage: ${g.entities} entities + ${g.services} services catalogued but service_entity.csv emits 0 rows — Data Store Mapping ingestion missing (per ADR 0159 Phase 0)`);
+    }
+    if (res.containerEntityGap) {
+        const g = res.containerEntityGap;
+        lines.push(`[finding] coverage: ${g.containersWithService} containers map to services + ${g.serviceEntity} service_entity edges present but c4_container_entity.csv emits 0 rows — Phase 3 derivation missing (per ADR 0159 Phase 0)`);
+    }
+    return lines;
+}
+export function renderCapabilityEventCheck(res) {
+    const lines = [];
+    if (res.derivableGap) {
+        const g = res.derivableGap;
+        lines.push(`[finding] coverage: service_event (${g.serviceEvent}) + capability_service (${g.capabilityService}) populated but capability_event emits 0 rows — reverse-derivable edge missing (per ADR 0160 Phase 0)`);
+    }
+    if (res.authoredGap) {
+        lines.push(`[finding] coverage: capability_event has ${res.authoredGap.derived} derived rows but 0 authored rows — no traceability.events[] or traceability.contracts.{published,consumed}_events declarations are landing in the catalogue. Governance queries filtering to source=authored will return empty (per ADR 0160 Phase 0)`);
+    }
+    return lines;
+}
+export function renderFeatureEventCheck(res) {
+    return res.gap
+        ? [
+            `[finding] coverage: service_event (${res.gap.serviceEvent}) + feature_service (${res.gap.featureService}) populated but feature_event emits 0 rows — reverse-derivable edge missing (per ADR 0161 Phase 0)`,
+        ]
+        : [];
+}
+export function renderPlatformDependenciesCheck(finding) {
+    return finding
+        ? [
+            `[finding] coverage: app-platform-dependencies.yaml declares a platform_dependencies block but product_platform_dependencies.csv emits 0 rows — forward-method ingestion missing (per ADR 0162 Phase 0). Resolves once the builder reads the forward source.`,
+        ]
+        : [];
+}
+export function renderFeatureSpecPromotionCheck(res) {
+    if (!res.finding)
+        return [];
+    const f = res.finding;
+    return [
+        `[finding] coverage: ${f.intermediate} of ${f.total} features are reverse-intermediate ` +
+            `(capability-spec/feature-grounding) not yet promoted to feature-spec — ` +
+            `unresolvable as realises:/FK targets (${f.pctResolvable}% resolvable, ${f.note}; ` +
+            `per ADR 0177 §4.2)`,
+    ];
+}
+export function renderFeatureSurfaceDuplicationCheck(res) {
+    if (!res.finding)
+        return [];
+    const f = res.finding;
+    const capWord = f.capabilities === 1 ? "capability" : "capabilities";
+    return [
+        `[finding] coverage: ${f.pairs} near-duplicate feature surface(s) across ` +
+            `${f.capabilities} ${capWord} — a capability-spec (rollup) and feature-grounding ` +
+            `(detailed) slug naming the same surface; reconcile to one slug per surface, ` +
+            `detailed slug canonical (per ADR 0177 §4.3)`,
+    ];
+}
+// ─── Scores coverage (M-ADR 0205 §4.5, B2 — the fourteenth check) ─────────
+/**
+ * Unlike the thirteen predicates above, this text has NO reference shell
+ * script to be byte-identical with — it is a new surface, so the lines are
+ * chosen rather than reproduced. Two rules they follow, both paid for
+ * elsewhere in this arc:
+ *
+ *   - every count states its basis in the same breath as the number, so a
+ *     figure can never be read against the wrong denominator;
+ *   - a number the predicate CANNOT reach is printed beside the number it
+ *     reports, so a gap is never mistaken for backlog. Here that is the
+ *     rubrics with no catalogued population and the scores whose currency is
+ *     unknowable — both stated, never dropped.
+ */
+export function renderScoresCoverage(res, tier) {
+    // Only silent when there is genuinely nothing to say. An SDD that measured
+    // NOTHING still reports which rubrics it skipped and why — suppressing that
+    // was this renderer's own first draft, and it is precisely the silent-cap
+    // shape the predicate exists to remove.
+    if (res.totalScores === 0 && res.metrics.length === 0 && res.notAdopted.length === 0) {
+        return [];
+    }
+    const out = [];
+    for (const f of res.findings) {
+        if (f.kind === "uncovered") {
+            out.push(`[finding] coverage: ${f.subject} carries no ${f.rubricId} score — ` +
+                `unscored is not passed; assess it or record why it is exempt ` +
+                `(no exemption vocabulary exists yet, per M-ADR 0199)`);
+        }
+        else if (f.kind === "out-of-scope-score") {
+            // Named remedy, and it is deliberately NOT "delete this". M-ADR 0199 §4.4
+            // binds a remedy to be true at the emitting tier: the assessment itself is
+            // real work and a real judgment, and the ruled disposition (2026-08-07) is
+            // that it travels to the producer as feedback rather than being discarded.
+            // The forward estate's 24 rows moved that way — packaged, ingested,
+            // auditable — and a remedy line reading "withdraw" would have advised
+            // throwing away exactly what was worth transferring.
+            out.push(`[finding] coverage: ${f.rubricId} score for '${f.subject}' targets a ` +
+                `method-managed artefact — sync overwrites any remediation made here, so it ` +
+                `is out of this repo's scope to maintain; raise the assessment with the ` +
+                `producer and retire the row (it is counted in neither coverage nor orphans)`);
+        }
+        else if (f.kind === "orphaned-score") {
+            // COVERAGE class, not orphan, and the choice is governed rather than
+            // stylistic. M-ADR 0205 §4.5 ships this instrument "reporting-only at
+            // both tiers first"; M-ADR 0132 §4.3 makes `orphan` and `divergence`
+            // gate-acting. Emitting orphan here would have made the predicate gate
+            // on its first run, silently reversing the ADR's staging decision for a
+            // whole finding class — and on a real estate that meant 85 lines going
+            // straight into a findings baseline as grandfathered debt.
+            //
+            // Promotion to gate-acting is a deliberate later act: change this one
+            // word, and say so in the change-set. Until then the line still names
+            // the defect plainly — a score pointing at nothing is not softened by
+            // being informational.
+            out.push(`[finding] coverage: ${f.rubricId} score for '${f.subject}' resolves to no ` +
+                `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}`);
+        }
+    }
+    for (const r of res.undeclaredRubrics) {
+        out.push(`[finding] coverage: scores exist for rubric '${r}', which declares no ` +
+            `eligibility mapping — its coverage cannot be computed and its targets are ` +
+            `not resolution-checked; add it to RUBRIC_ELIGIBILITY`);
+    }
+    // The keying-rule sunset gauge (ruled 2026-08-07): the ADR prefix-strip is
+    // a migration aid, and this line is how "both estates read 0" gets measured
+    // rather than asserted. Silent when already 0 — a retired bridge needs no
+    // gauge.
+    if (res.transformBridgedRefs > 0) {
+        out.push(`[metric] scores_keying: ${res.transformBridgedRefs} adr-quality ref(s) still resolve via the ` +
+            `prefix-strip transform — re-key to the catalogue's own ids (scoring-registry guide, keying rule); ` +
+            `the transform sunsets when every estate reads 0`);
+    }
+    if (res.metrics.length === 0) {
+        out.push(`[metric] scores_coverage (${tier}): n/a — no rubric measurable in this SDD ` +
+            `(${res.notAdopted.length} not adopted, ${res.totalScores} score(s) present)`);
+        out.push(`[metric] scores_coverage.not_adopted: ${res.notAdopted.length} rubric(s) have no ` +
+            `registry in this SDD and are n/a here — ${res.notAdopted.join(", ")}; ` +
+            `absence of the surface is not a gap in it, but an EMPTY registry is`);
+        return out;
+    }
+    const withPop = res.metrics.filter((m) => m.eligible !== null);
+    const noPop = res.metrics.filter((m) => m.eligible === null);
+    const eligible = withPop.reduce((a, m) => a + (m.eligible ?? 0), 0);
+    const covered = withPop.reduce((a, m) => a + m.covered, 0);
+    const orphaned = res.metrics.reduce((a, m) => a + m.orphaned, 0);
+    const pct = eligible === 0 ? "n/a" : `${fmt1f((covered / eligible) * 100)}%`;
+    out.push(
+    // The denominator is (artefact, rubric) PAIRS, not distinct artefacts — one
+    // domain is eligible under domain-architecture, intent-quality AND glossary,
+    // so 14 domains contribute 42 eligible pairs. Naming the unit here is the
+    // difference between a measurement and a number that reads 3x too large.
+    `[metric] scores_coverage (${tier}): ${covered}/${eligible} eligible ` +
+        `(artefact, rubric) pair(s) scored (${pct}) across ${withPop.length} rubric(s) ` +
+        `with a catalogued population; ${orphaned} score(s) orphaned of ${res.totalScores} total`);
+    for (const m of withPop) {
+        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
+    // the bundle breakdown answers the immediate next question — which producer's
+    // content is it — in the same line rather than in a follow-up investigation.
+    const excluded = withPop.filter((m) => m.managedExcluded > 0);
+    for (const m of excluded) {
+        const byBundle = Object.entries(m.managedExcludedByBundle)
+            .sort((a, b2) => b2[1] - a[1] || a[0].localeCompare(b2[0]))
+            .map(([name, n]) => `${name} ${n}`)
+            .join(", ");
+        out.push(`[metric] scores_coverage.${m.rubricId}.method_managed: ${m.managedExcluded} ` +
+            `${m.targetKind}(s) excluded from the denominator as method-managed ` +
+            `(${byBundle}) — sync overwrites remediation here, so their quality belongs ` +
+            `to the producer's registry; NOT netted against the gap count above`);
+    }
+    if (noPop.length > 0) {
+        out.push(`[metric] scores_coverage.no_denominator: ${noPop.length} rubric(s) score ` +
+            `artefacts the catalogue does not model — ` +
+            `${noPop.map((m) => `${m.rubricId}(${m.scored})`).join(", ")}; ` +
+            `their coverage is NOT measurable here and is not counted above`);
+    }
+    if (res.notAdopted.length > 0) {
+        out.push(`[metric] scores_coverage.not_adopted: ${res.notAdopted.length} rubric(s) have no ` +
+            `registry in this SDD and are n/a here — ${res.notAdopted.join(", ")}; ` +
+            `absence of the surface is not a gap in it, but an EMPTY registry is`);
+    }
+    const b = res.stalenessBasis;
+    out.push(`[metric] scores_staleness_basis: ${b.corpusRef} corpus_ref, ${b.scoredAt} scored_at, ` +
+        `${b.none} none — a row with basis 'none' has UNKNOWN currency, not fresh`);
+    return out;
+}
+export function renderRelationshipCoherenceCheck(res) {
+    const out = [];
+    for (const f of res.ownedUntraced) {
+        out.push(`[finding] coverage: features/${f.featureId} is owned by capabilities/${f.capabilityId} but capability_feature carries no trace — owned-but-untraced (M-ADR 0206 §4.5)`);
+    }
+    for (const d of res.publisherDrift) {
+        out.push(d.missing === "publisher-fk"
+            ? `[finding] coverage: service_event declares ${d.serviceId} publishes ${d.eventId} but events.publisher_service_id disagrees — publisher-projection drift (M-ADR 0206 §4.5)`
+            : `[finding] coverage: events/${d.eventId} names publisher ${d.serviceId} but service_event has no publishes row — publisher-projection drift (M-ADR 0206 §4.5)`);
+    }
+    for (const s of res.supersessionDrift) {
+        out.push(s.missing === "fk-backfill"
+            ? `[finding] coverage: adr_supersedes ${s.supersedingId} -> ${s.supersededId} has no superseded_by_id backfill — supersession drift (M-ADR 0206 §4.5)`
+            : `[finding] coverage: adrs/${s.supersededId} carries superseded_by_id ${s.supersedingId} but adr_supersedes has no row — supersession drift (M-ADR 0206 §4.5)`);
+    }
+    return out;
+}
+//# sourceMappingURL=coverage-render.js.map