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

package/dist/lib/catalogue/build.js

@@ -0,0 +1,1502 @@
+/**
+ * Per-SDD catalogue builder — `sdd-cli catalogue build` orchestrator.
+ *
+ * Per ADR 0134 §4.6, the canonical builder reads method-defined declarative
+ * inputs and emits `catalogues/*.csv` matching the canonical schema.
+ *
+ * This is Phase 1 of the canonical-builder implementation per
+ * adopt-canonical-catalogue-builder.md Step F. Phase 1 ships:
+ *   - manifest loading + schema-version compat check,
+ *   - schema loading,
+ *   - headers-only emission for every catalogue declared in the schema,
+ *   - internal FK validation,
+ *   - findings + row-count reporting.
+ *
+ * Per-source discoverers (domains, repos, services, capabilities, features,
+ * etc.) land in subsequent phases. Until then the builder produces a valid
+ * but empty `catalogues/` directory — useful as a smoke test that the
+ * infrastructure works end-to-end on any SDD repo.
+ */
+import { checkCapabilityServicePopulation } from "./population-checks.js";
+import { basename, join, relative, resolve } from "node:path";
+import { copyFile, mkdir, readFile, stat } from "node:fs/promises";
+import { buildLegacyContractIdMap } from "./contract-id.js";
+import { buildLegacyExtIdMap } from "./ext-id.js";
+import { CLI_VERSION } from "./cli-version.js";
+import { loadCanonicalSchema } from "./schema-loader.js";
+import { loadSddManifest } from "./manifest-loader.js";
+import { UNCLASSIFIED } from "./application-archetype/vocabulary.js";
+import { checkDataPlanePlatformDepCoherence, checkPublishSurfaceCoherence, } from "./data-plane-coherence.js";
+import { writeCatalogue } from "./csv-writer.js";
+import { validatedPopulation, validateWithEngineToLog } from "./engine-validator.js";
+import { dedupeKeyedTables } from "./dedupe-keyed-tables.js";
+import { FindingsLog } from "./findings.js";
+import { readCatalogueCsv } from "./csv-reader.js";
+import { buildDataItems, buildFeatureDemand, buildIntegrationSupply } from "./builders/data-items.js";
+import { buildEvidenceTargetRepos } from "./builders/evidence-target-repo.js";
+import { buildRepoDependencies } from "./builders/repo-dependency.js";
+import { buildDomains, buildProducts, buildApplicationDataPlaneBindings, buildApplicationDataPlaneDeviations, buildApplicationConformanceCoverage, buildImplementations, buildRepositories, buildServices, buildCapabilities, buildCapabilityService, buildCapabilityAdr, buildCapabilityFeature, buildCapabilityContract, buildAdrs, buildAdrSupersedes, buildFeatures, buildFeatureGroups, buildFeatureGrounding, buildCapabilitySpec, buildContracts, buildDeclaredExternalContracts, buildRepoEdges, deriveFeatureRepoFromServices, buildRepoCapabilityExemption, buildServiceCapabilityExemption, buildEvents, buildServiceEvent, buildCapabilityEvent, buildFeatureEvent, buildServiceContract, buildServiceContractConsumes, buildFeatureContract, buildDomainModels, buildCapabilityDomainModel, buildFeatureDomainModel, buildFeatureSubscriptionChannels, buildProductPlatformDependencies, buildGlossaryItems, backfillGlossaryRelations, buildGlossaryXref, buildC4Systems, buildC4Containers, buildC4Components, buildC4ExternalSystems, buildExternalSystemExemption, buildContainerDependency, reportEntryIdReferentCollisions, buildSystemExternalDependency, buildPersonaC4System, buildPersonaContainer, buildPersonas, buildQualityScores, buildScaffolds, buildScreens, buildUserJourneys, buildPersonaJourney, buildPersonaFeature, buildJourneyFeature, buildProductEdges, buildIntegrations, entitySlug, buildEntitiesFromManifest, buildEntitiesFromMermaid, buildServiceEntityFromTables, enrichEntityPersistenceKind, buildC4ContainerEntity, buildC4SystemEntity, } from "./builders/index.js";
+import { buildIntegrationComponents } from "./builders/integration-components.js";
+import { loadReverseProductQuality } from "./reverse-product-quality.js";
+import { loadTraceabilityManifests } from "./traceability-loader.js";
+import { findFeatureTreeFile, parseFeatureServicesTable, } from "./builders/feature-tree-walker.js";
+import { loadRunwayVocabulary } from "./runway-vocabulary-loader.js";
+import { loadFeatureGroundingAliases } from "./feature-grounding-aliases-loader.js";
+import { loadServiceContractAliases } from "./service-contract-aliases-loader.js";
+import { loadScreenValidationConfig } from "./screen-validation-loader.js";
+import { zeroResolutionSummary } from "./feature-repo-zero-resolution-summary.js";
+export async function runCatalogueBuild(inputs, write) {
+    const sddPath = resolve(inputs.sddPath ?? process.cwd());
+    const outDir = resolve(inputs.outDir ?? join(sddPath, "catalogues"));
+    // 1. Load canonical schema.
+    const schema = await loadCanonicalSchema();
+    write(`sdd-cli catalogue build (canonical schema ${schema.schemaVersion})\n`);
+    // 2. Load SDD manifest + compat check.
+    const manifest = await loadSddManifest(sddPath, { cliVersion: CLI_VERSION });
+    write(`  sdd_id: ${manifest.sddId}  profile: ${manifest.profile}  category: ${manifest.category}\n`);
+    // 3. Build per-catalogue rows via discoverers.
+    const findings = new FindingsLog();
+    // A manifest key this build does not know is REPORTED rather than silently
+    // dropped. The usual cause is a manifest declaring a field from a newer schema
+    // than the installed sdd-cli — which previously validated clean and did
+    // nothing, so an adopter following the schema got no column and no complaint
+    // (M-ADR 0175's version history records exactly that happening).
+    if (manifest.unknownKeys && manifest.unknownKeys.length > 0) {
+        findings.add("convention", `.sdd/sdd-manifest.yaml: ${manifest.unknownKeys.length} key(s) not understood by ` +
+            `sdd-cli ${CLI_VERSION} and therefore IGNORED: ${manifest.unknownKeys.join(", ")}. ` +
+            `If the manifest follows a newer sdd-manifest-schema than this build, upgrade ` +
+            `sdd-cli; otherwise remove or correct the key.`);
+    }
+    const rowsByCatalogue = await collectRows(schema, manifest, findings, sddPath, inputs.snapshotStore);
+    // 3a. Normalise every keyed catalogue to PK-unique rows. Multi-source edge
+    // tables (feature_service, feature_repo) can have the same fact asserted by
+    // more than one walker; each walker's own seen-set only dedupes intra-walker.
+    // This union-dedupes identical rows across sources and hard-fails the build
+    // on same-PK/different-payload, so the per-SDD catalogue is set-correct over
+    // its declared PK before aggregation ever sees it. See
+    // `coordination/feature-edge-cross-source-duplicate-coordination.md`.
+    const dedupe = dedupeKeyedTables(schema, rowsByCatalogue, findings);
+    // 3b. Population collapse, before anything is overwritten. A whole score family can
+    // vanish while its catalogue keeps other rows: one estate's 71 traceability-manifest
+    // scores left quality_scores for a week (an input that stopped parsing) while FK,
+    // shape and validate all passed, because they pass on absence. Compare each family's
+    // row count with the committed file this build is about to replace; one that had rows
+    // and now has none fails the build (severity error): both estates read zero for it at the
+    // 1.38.0 wave, which was the stated condition for promotion (ruled 2026-10-01).
+    await reportCollapsedFamilies(outDir, join(sddPath, "catalogues"), rowsByCatalogue, findings);
+    // 4. Write CSVs (headers + rows).
+    const rowCounts = new Map();
+    const ownCatalogues = resolve(join(sddPath, "catalogues"));
+    for (const cat of schema.catalogues) {
+        const rows = rowsByCatalogue.get(cat.name) ?? [];
+        // A catalogue this build produces nothing for keeps the file on disk (below). Built
+        // with --out into another directory, there is no file there to keep, so a scratch
+        // build reported conformance_finding as emptied while an in-place build kept it —
+        // a measurement tool misreporting the thing measured. Seed it from the SDD's own
+        // catalogues/ first, so --out writes what an in-place build would.
+        if (rows.length === 0 && outDir !== ownCatalogues) {
+            const own = join(ownCatalogues, `${cat.name}.csv`);
+            const there = join(outDir, `${cat.name}.csv`);
+            const exists = async (p) => stat(p).then(() => true, () => false);
+            if ((await exists(own)) && !(await exists(there))) {
+                await mkdir(outDir, { recursive: true });
+                await copyFile(own, there);
+            }
+        }
+        const result = await writeCatalogue({ outDir, catalogue: cat, rows });
+        rowCounts.set(cat.name, result.rowCount);
+        // A preserved file is data this build could not reproduce. Saying nothing
+        // would move the silence rather than close it: the previous behaviour was
+        // also silent, and that is why 26 SDDs lost their conformance evidence
+        // while their registries went on citing it.
+        if (result.preserved) {
+            findings.add("convention", `catalogues/${cat.name}.csv: this build produced NO rows for it, and the file on disk ` +
+                `holds ${result.preservedRows}. The existing file was LEFT UNTOUCHED rather than ` +
+                `replaced with a bare header. Either the catalogue has no producer in this CLI — in ` +
+                `which case its rows are authored data, not build output, and nothing here will ever ` +
+                `regenerate them — or a builder that used to emit rows has stopped. Both are worth ` +
+                `resolving; neither is worth deleting the rows over.`);
+        }
+    }
+    // 5. Internal FK validation (external FKs logged as findings). Pass the
+    // SDD profile so profile-external FKs (schema 2.23.0, e.g. an app/integration
+    // capability's platform-resident domain_id per ADR 0136) resolve at
+    // aggregation instead of failing this local build.
+    const { fk, enums } = await validateWithEngineToLog(schema, rowsByCatalogue, findings, { profile: manifest.profile });
+    // 5b. Bound-enum validation (M-ADR 0203 §4.1): every column_enums-bound
+    // column hard-fails on an out-of-set value, like a dangling internal FK.
+    // The canonical builder cannot emit a non-canonical c4_containers.type
+    // (type derives from the macro), so at build time this is the defensive
+    // guard the 2.x advisory module used to be — with teeth.
+    // 6. Report.
+    write("\nRow counts:\n");
+    for (const [name, count] of rowCounts) {
+        if (count > 0)
+            write(`  ${name}: ${count}\n`);
+    }
+    const emptyCount = [...rowCounts.values()].filter((c) => c === 0).length;
+    write(`  (${emptyCount} headers-only)\n`);
+    if (dedupe.unionedRows > 0) {
+        write(`\nKeyed-table dedup: unioned ${dedupe.unionedRows} duplicate row(s) across multi-source edge tables\n`);
+    }
+    if (dedupe.conflicts.length > 0) {
+        write(`\nPrimary-key conflicts (${dedupe.conflicts.length}) — same PK, different payload:\n`);
+        for (const c of dedupe.conflicts) {
+            write(`  ${c.catalogue}.${c.primaryKey}="${c.value}"\n`);
+        }
+    }
+    const findingsText = findings.render();
+    if (findingsText) {
+        write(`\n${findingsText}\n`);
+    }
+    if (fk.internalPass) {
+        write(`\nFK validation (internal): PASS (${validatedPopulation(rowsByCatalogue)})\n`);
+    }
+    else {
+        write(`\nFK validation (internal): FAIL (${fk.internalFailures.length} dangling)\n`);
+        for (const f of fk.internalFailures) {
+            write(`  ${f.catalogue}.${f.column}: row pk=${f.referencingRow} → ${f.target}=${f.value || "<empty>"}\n`);
+        }
+    }
+    if (enums.pass) {
+        write(`Enum validation (column_enums): PASS (${validatedPopulation(rowsByCatalogue)})\n`);
+    }
+    else {
+        write(`Enum validation (column_enums): FAIL (${enums.violations.length} out-of-set)\n`);
+        for (const v of enums.violations) {
+            write(`  ${v.catalogue}.${v.column}: row pk=${v.rowPk} value "${v.value}" (allowed: ${v.allowed})\n`);
+        }
+    }
+    write(`External findings: ${fk.externalFindings} (validated by aggregator)\n`);
+    const strictFail = inputs.strict === true && findings.count() > 0;
+    // A PK conflict means the build produced a catalogue that cannot satisfy the
+    // declared primary-key uniqueness — always a hard failure, like a dangling
+    // internal FK. (The silent-union path is not a failure: it is the expected
+    // outcome of two sources asserting the same fact.)
+    // Error-severity findings (e.g. the ADR 0168 screen-spec status gate) fail the
+    // build by default, independent of --strict.
+    const exitCode = !fk.internalPass || dedupe.conflicts.length > 0 || findings.errorCount() > 0 || strictFail
+        ? 1
+        : 0;
+    return {
+        exitCode,
+        schemaVersion: schema.schemaVersion,
+        sddId: manifest.sddId,
+        profile: manifest.profile,
+        category: manifest.category,
+        rowCounts,
+        internalFkPass: fk.internalPass,
+        externalFindings: fk.externalFindings,
+        findingsCount: findings.count(),
+        pkConflicts: dedupe.conflicts.length,
+        unionedRows: dedupe.unionedRows,
+        outDir,
+    };
+}
+/**
+ * Collect rows per catalogue. Each per-source discoverer populates one
+ * (or a small group) of catalogues; everything else stays headers-only
+ * until later phases land their builders.
+ *
+ * Order matters for catalogues that depend on each other:
+ *   1. domains (from docs/domains/*) — populates known-domain set
+ *   2. repositories (from orchestration/repo-config) — needs the domain
+ *      set + the SDD's product_id
+ *   3. products (from manifest) — needs repo_count and a domain that
+ *      resolves
+ *   4. final pass: backfill domains.repo_count from the discovered repos
+ */
+async function collectRows(schema, manifest, findings, sddPath, snapshotStore) {
+    const out = new Map();
+    for (const cat of schema.catalogues) {
+        out.set(cat.name, []);
+    }
+    // 1. Domains — pure filesystem read, no dependencies.
+    const domains = await buildDomains({ sddPath, manifest, findings });
+    out.set("domains", domains);
+    const knownDomainIds = new Set(domains.map((d) => String(d["id"])));
+    // 2. Repositories — needs domain set + the SDD's product_id (= sddId).
+    const reposResult = await buildRepositories({
+        sddPath,
+        manifest,
+        schema,
+        findings,
+        knownDomainIds,
+        productId: manifest.sddId,
+    });
+    const repos = reposResult.rows;
+    out.set("repositories", repos);
+    // M-ADR 0214 §4.10: evidence naming repositories another SDD owns (external at build).
+    out.set("evidence_target_repo", await buildEvidenceTargetRepos(sddPath, new Set(repos.map((r) => String(r["id"]))), findings));
+    // 2a. Implementations, their members and snapshots (M-ADR 0214) — from the
+    // binding and its snapshot area; members resolve against the repositories above.
+    const impl = await buildImplementations({
+        sddPath,
+        knownRepoIds: new Set(repos.map((r) => String(r["id"]))),
+        ...(snapshotStore !== undefined ? { snapshotStore } : {}),
+        findings,
+    });
+    out.set("implementations", impl.implementations);
+    out.set("implementation_members", impl.implementationMembers);
+    out.set("snapshots", impl.snapshots);
+    out.set("snapshot_members", impl.snapshotMembers);
+    // 3. Products — emits ONE row for this SDD, with repo_count from above.
+    const products = buildProducts({
+        manifest,
+        repoCount: repos.length,
+        findings,
+        knownDomainIds,
+    });
+    // Product maturity columns from the reverse gate registry. Applied here rather
+    // than inside buildProducts because it needs the SDD path and is async, and
+    // because it is a BACKFILL: it only fills cells the builder left empty, so a
+    // score can never overwrite an emitted value. Empty on a forward estate by
+    // design — the columns are documented reverse-method only.
+    const quality = await loadReverseProductQuality(sddPath, manifest.sddId, findings);
+    const productsWithQuality = products.map((row) => ({
+        ...row,
+        // Backfill only: `?? row[...]` keeps whatever the builder emitted, so a score
+        // can never overwrite an existing value — it fills a blank or does nothing.
+        synthesis_quality: quality.quality ?? row["synthesis_quality"],
+        synthesis_band: quality.band ?? row["synthesis_band"],
+        last_assessed: quality.assessedAt ?? row["last_assessed"],
+    }));
+    out.set("products", productsWithQuality);
+    // Application-archetype coverage (M-ADR 0191 §4.1). At per-SDD build the
+    // `application_archetype` value is emitted OPEN — exactly as integration
+    // `profileType` is (an open enum at build; the closed set is enforced at
+    // authoring/init, the extensible tiers at aggregation). The per-SDD build
+    // does NOT resolve the value against the reference-architecture vocabulary
+    // and does NOT fail on an unknown value: that vocabulary is a platform/
+    // aggregation-tier concern (0173 tiers), and an application SDD legitimately
+    // may not consume the RA bundle at all. Coupling the app build to RA-bundle
+    // presence was wrong (it broke estates that deliver vocabulary at the
+    // aggregation tier). Only the "declare your shape" coverage nudge lives
+    // here — it is vocabulary-independent. Membership validation against the
+    // resolved vocabulary is an aggregation-tier check (fast-follow, where the
+    // RA bundle IS consumed), alongside the expectations overlay.
+    if (manifest.profile === "application-product" &&
+        (manifest.applicationArchetype === undefined ||
+            manifest.applicationArchetype === UNCLASSIFIED)) {
+        findings.add("coverage", `products: application_archetype not declared for ${manifest.sddId} — ` +
+            `defaulted to "unclassified". Declare the product's shape (M-ADR 0191).`);
+    }
+    // `applications.csv` is a filtered view: profile=application-product.
+    out.set("applications", products.filter((p) => p["profile"] === "application-product"));
+    // Application data-plane axis (M-ADR 0193) — bindings + declared deviations,
+    // emitted from the manifest. Malformed bindings/deviations already failed at
+    // manifest load; these shape valid ones into rows. The archetype-default WARN
+    // and the conformance surface (M-ADR 0191 §4.3) run at AGGREGATION tier, where
+    // the reference-architecture `expected_bindings` resolve — NOT here: an app
+    // SDD may consume an adopter context-pack rather than the RA bundle, so a
+    // per-SDD WARN would be inert for it and coupling the build to bundle presence
+    // is the mistake M-ADR 0191 §4.1 / the 0.92.1 membership move corrected.
+    out.set("application_data_plane_bindings", buildApplicationDataPlaneBindings({ manifest, findings }));
+    out.set("application_data_plane_deviations", buildApplicationDataPlaneDeviations({ manifest, findings }));
+    // Conformance coverage (M-ADR 0191 §4.3 WS4) — the product's declared coverage
+    // of / deviations from its archetype's conformance expectations. The
+    // conformance GATE that reads these runs at aggregation tier (like the binding
+    // overlay), where the reference-architecture `conformance` tags resolve.
+    out.set("application_conformance_coverage", buildApplicationConformanceCoverage({ manifest, findings }));
+    // 4. Backfill domains.repo_count from repos.
+    if (domains.length > 0) {
+        const repoCountByDomain = new Map();
+        for (const r of repos) {
+            const d = String(r["domain_id"] ?? "");
+            if (d === "")
+                continue;
+            repoCountByDomain.set(d, (repoCountByDomain.get(d) ?? 0) + 1);
+        }
+        out.set("domains", domains.map((d) => ({
+            ...d,
+            repo_count: repoCountByDomain.get(String(d["id"])) ?? 0,
+        })));
+    }
+    // 5. Services derived 1:1 from runtime-typed repositories.
+    // Forward `description` source (ADR 0163 P1): repo-config `description:`,
+    // parsed but previously dropped by the repositories builder.
+    const repoDescriptions = new Map();
+    const declaredServicesByRepo = new Map();
+    for (const cfg of reposResult.configs) {
+        const desc = (cfg.data.description ?? "").trim();
+        if (desc !== "")
+            repoDescriptions.set(cfg.repoId, desc);
+        if (cfg.data.services !== undefined) {
+            declaredServicesByRepo.set(cfg.repoId, cfg.data.services);
+        }
+    }
+    const servicesResult = await buildServices({
+        schema,
+        manifest,
+        findings,
+        repositories: repos,
+        productId: manifest.sddId,
+        sddPath,
+        repoDescriptions,
+        declaredServicesByRepo,
+    });
+    const services = servicesResult.rows;
+    const declaredNonRepoServiceIds = servicesResult.declaredNonRepoIds;
+    out.set("services", services);
+    // 6. ADRs + adr_supersedes — runs before capabilities edges so
+    // capability_adr can resolve.
+    const adrResult = await buildAdrs({
+        sddPath,
+        findings,
+        knownDomainIds,
+        profile: manifest.profile,
+        category: manifest.category,
+    });
+    const supersedes = buildAdrSupersedes({ findings, adrs: adrResult.parsed });
+    out.set("adr_supersedes", supersedes.rows);
+    // Backfill `superseded_by_id` on adrs.csv from the edge index.
+    const adrsWithBackfill = adrResult.rows.map((row) => {
+        const id = String(row["id"]);
+        const supersededBy = supersedes.supersededByIndex.get(id);
+        if (supersededBy === undefined)
+            return row;
+        return { ...row, superseded_by_id: supersededBy };
+    });
+    out.set("adrs", adrsWithBackfill);
+    const knownAdrIds = new Set(adrResult.parsed.map((a) => a.id));
+    // 7. Capabilities + capability_* edges from traceability YAMLs.
+    const traceability = await loadTraceabilityManifests({ sddPath, findings });
+    const capabilities = await buildCapabilities({
+        sddPath,
+        findings,
+        manifests: traceability,
+        knownDomainIds,
+    });
+    out.set("capabilities", capabilities);
+    // One feature tree per SDD (M-ADR 0056, amended 2026-09-29). An SDD that
+    // CLASSIFIES capabilities must carry docs/platform/feature-tree.md or declare
+    // the SDD whose tree holds its classifications. Neither is reported, so the
+    // absence is never silent — measured: three of one estate's four repos
+    // classified 16 capabilities with no tree and nothing said so. COVERAGE
+    // class: report-only, like every other coverage finding.
+    {
+        const classified = capabilities.filter((r) => String(r["runway_classification"] ?? "").trim() !== "").length;
+        if (classified > 0 &&
+            manifest.featureTreeAnchor === undefined &&
+            (await findFeatureTreeFile(sddPath)) === null) {
+            findings.add("coverage", `feature tree: this SDD classifies ${classified} capabilit${classified === 1 ? "y" : "ies"} ` +
+                `but carries no docs/platform/feature-tree.md and declares no feature_tree_anchor — ` +
+                `author the tree, or declare in .sdd/sdd-manifest.yaml the SDD whose tree holds these ` +
+                `classifications (M-ADR 0056, one tree per SDD)`);
+        }
+    }
+    const knownCapabilityIds = new Set(capabilities.map((c) => String(c["id"])));
+    // Slug → capability-id aliases for feature-grounding path resolution.
+    // The grounding walker derives a capability slug from the design dir
+    // name (docs/domains/<dom>/design/<slug>/), but a capability's declared
+    // id may legitimately differ from its path slug — e.g. design/alerts-rules
+    // maps to id "alerts-rules-engine". Map each capability's spec +
+    // feature-directory basename to its id so the walker resolves these
+    // without forcing a directory rename. Only non-identity, non-colliding
+    // slugs are aliased (first manifest wins).
+    const capabilitySlugToId = new Map();
+    for (const m of traceability) {
+        const id = m.capability.id;
+        for (const p of [m.capability.capability_spec, ...(m.capability.feature_directory ?? [])]) {
+            if (typeof p !== "string" || p.length === 0)
+                continue;
+            const slug = basename(p.replace(/\/+$/, "")).replace(/\.md$/, "");
+            if (slug !== "" &&
+                slug !== id &&
+                !knownCapabilityIds.has(slug) &&
+                !capabilitySlugToId.has(slug)) {
+                capabilitySlugToId.set(slug, id);
+            }
+        }
+    }
+    const knownServiceIds = new Set(services.map((s) => String(s["id"])));
+    // C4 L1 external systems are built here (rather than at step 15b) so the
+    // capability_service builder can categorise unresolved `services[].id`
+    // findings — an id naming a known external system (authzed, workos, …) is
+    // a convention finding, not an orphan. The rows are emitted at their usual
+    // place in step 15b; only the computation is hoisted.
+    const c4External = await buildC4ExternalSystems({
+        sddPath,
+        manifest,
+        findings,
+    });
+    const knownExternalSystemIds = new Set();
+    for (const row of c4External.rows) {
+        const extId = String(row["id"]);
+        knownExternalSystemIds.add(extId);
+        if (extId.startsWith("ext-"))
+            knownExternalSystemIds.add(extId.slice(4));
+    }
+    for (const entryId of c4External.idByEntryId.keys())
+        knownExternalSystemIds.add(entryId);
+    out.set("capability_service", buildCapabilityService({
+        findings,
+        manifests: traceability,
+        knownCapabilityIds,
+        knownServiceIds,
+        knownExternalSystemIds,
+    }));
+    out.set("capability_adr", buildCapabilityAdr({
+        findings,
+        manifests: traceability,
+        knownCapabilityIds,
+        knownAdrIds,
+    }));
+    // 8. Features + feature_groups (per Q7.2 first-class groups).
+    const featureGroups = await buildFeatureGroups({
+        sddPath,
+        findings,
+        productId: manifest.sddId,
+    });
+    out.set("feature_groups", featureGroups);
+    // Schema 2.2.0+: optional adopter-owned runway vocabulary at SDD root.
+    // Absent → no validation runs; bullet runway values accepted verbatim.
+    const runwayVocab = await loadRunwayVocabulary(sddPath);
+    const featuresResult = await buildFeatures({
+        sddPath,
+        findings,
+        manifests: traceability,
+        knownCapabilityIds,
+        profile: manifest.profile,
+        productId: manifest.sddId,
+        runwayVocabulary: runwayVocab?.values ?? null,
+    });
+    out.set("features", featuresResult.rows);
+    out.set("capability_feature", buildCapabilityFeature({
+        findings,
+        manifests: traceability,
+        knownCapabilityIds,
+        featureIdByPath: featuresResult.idByPath,
+    }));
+    // 9. Contracts + capability_contract edge.
+    const contractsResult = await buildContracts({
+        sddPath,
+        findings,
+        knownRepositoryIds: new Set(repos.map((r) => String(r["id"]))),
+    });
+    // D13 — declared-external contracts. A capability manifest may declare a
+    // contract living outside this SDD's discovery paths (the M-ADR 0110
+    // sibling-repo pattern that `.sdd-cli.yaml`'s `contracts_root` names). Only an
+    // ENTRY EXPLICITLY MARKED `external: true` qualifies, and the file is never
+    // read — reading it would make catalogue output depend on whether sibling
+    // repos are checked out, which breaks the committed-catalogue model.
+    //
+    // Runs immediately after discovery so its ids merge into the same path index
+    // capability_contract resolves against; inert until an adopter marks an entry.
+    const declaredExternal = buildDeclaredExternalContracts({
+        findings,
+        manifests: traceability.map((m) => ({
+            relPath: m.relPath,
+            domain: m.capability.domain || m.domainFromPath || "",
+            contracts: m.traceability.contracts,
+        })),
+        discoveredIdByPath: contractsResult.idByPath,
+        existingIds: new Set(contractsResult.rows.map((r) => String(r["id"]))),
+    });
+    const mergedContractIdByPath = new Map(contractsResult.idByPath);
+    for (const [k, v] of declaredExternal.idByPath)
+        mergedContractIdByPath.set(k, v);
+    out.set("contracts", [...contractsResult.rows, ...declaredExternal.rows]);
+    out.set("capability_contract", buildCapabilityContract({
+        findings,
+        manifests: traceability,
+        knownCapabilityIds,
+        contractIdByPath: mergedContractIdByPath,
+    }));
+    // 10. Repo edges — repo_capability, repo_contract (feature_repo empty
+    // here; populated by feature-grounding extractor below per ADR 0143).
+    const capabilityIdByPath = new Map();
+    for (const cap of capabilities) {
+        const sp = String(cap["spec_path"] ?? "");
+        if (sp !== "")
+            capabilityIdByPath.set(sp, String(cap["id"]));
+    }
+    // Per ADR 0157, repo-edges has both forward-declared (additional_context,
+    // repo-config.contracts) and reverse-derived (capability_service ⋈
+    // services.primary_repo_id, contracts.source_repo_id denorm) paths. Note
+    // that the capability_feature ⋈ feature_repo path (Y) needs feature_repo
+    // populated, which the ADR 0143 extractor below (10a) does — but repo-edges
+    // runs first. So Path Y picks up zero rows here; the second pass after
+    // grounding extracts (below) appends the missing edges.
+    const knownRepoIds = new Set(repos.map((r) => String(r["id"])));
+    const repoEdges = buildRepoEdges({
+        findings,
+        configs: reposResult.configs,
+        capabilityIdByPath,
+        contractIdByPath: mergedContractIdByPath,
+        contractRows: contractsResult.rows,
+        serviceRows: services,
+        capabilityServiceRows: out.get("capability_service") ?? [],
+        capabilityFeatureRows: out.get("capability_feature") ?? [],
+        featureRepoRows: [], // populated by grounding extractor below; second pass after
+        knownRepoIds,
+    });
+    out.set("repo_capability", repoEdges.repoCapability);
+    out.set("repo_contract", repoEdges.repoContract);
+    out.set("feature_repo", repoEdges.featureRepo);
+    // 10-bis. repo_capability_exemption per M-ADR 0188 §4.3 — the declared "no"
+    // that makes an uncovered repository distinguishable from an unmodelled one.
+    // The reason vocabulary comes from the schema enum, not a literal here, so
+    // the closed vocabulary has exactly one definition (canonical-schema.yaml).
+    const exemptionReasons = new Set((schema.enums["capability_exemption_reason"]?.values ?? []).map((v) => v.value));
+    out.set("repo_capability_exemption", buildRepoCapabilityExemption({
+        findings,
+        configs: reposResult.configs,
+        knownRepoIds,
+        allowedReasons: exemptionReasons,
+    }));
+    // 10-quater. service_capability_exemption per M-ADR 0133 §4.2b — the
+    // services-tier annotation catalogue. Two reasons only (schema-enforced):
+    // platform-internal, deprecated. Keyed on the repo's own default/primary
+    // service id; a repo whose primary service was dropped from a declared
+    // `services:` block cannot be exempted through this surface yet (no
+    // per-entry authoring surface exists — M-ADR 0197 §4.7, design-only).
+    const knownServiceIdsForExemption = new Set(services.map((r) => String(r["id"])));
+    const serviceExemptionReasons = new Set((schema.enums["service_capability_exemption_reason"]?.values ?? []).map((v) => v.value));
+    out.set("service_capability_exemption", buildServiceCapabilityExemption({
+        findings,
+        configs: reposResult.configs,
+        knownServiceIds: knownServiceIdsForExemption,
+        allowedReasons: serviceExemptionReasons,
+    }));
+    // 10a. Feature-grounding extractor per ADR 0143 (schema 2.5.0).
+    // Walks docs/domains/*/design/*/feature-grounding.md (platform-profile)
+    // or docs/design/integration/feature-grounding.md (integration-product)
+    // and emits feature rows (source: feature-grounding) plus capability_feature,
+    // feature_repo, feature_service edges. Runs after the other feature
+    // sources so precedence (feature-tree / feature-spec win on id
+    // collision) is enforced. Output is appended to the existing rows.
+    const groundingAliases = await loadFeatureGroundingAliases(sddPath);
+    const knownRepoKeys = new Set(repos.map((r) => String(r["id"])));
+    const existingFeatureIds = new Set(featuresResult.rows.map((r) => String(r["id"])));
+    const grounding = await buildFeatureGrounding({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        productId: manifest.sddId,
+        knownCapabilityIds,
+        knownServiceIds,
+        knownRepoKeys,
+        existingFeatureIds,
+        aliases: groundingAliases,
+        capabilitySlugAliases: capabilitySlugToId,
+    });
+    if (grounding.featureRows.length > 0) {
+        out.set("features", [...(out.get("features") ?? []), ...grounding.featureRows]);
+        out.set("capability_feature", [
+            ...(out.get("capability_feature") ?? []),
+            ...grounding.capabilityFeatureRows,
+        ]);
+    }
+    // feature_repo + feature_service edges are stored unconditionally —
+    // per ADR 0143 §2 they're grounding's unique contribution and must
+    // emit even when every grounding row collides on feature id with an
+    // earlier source (`feature-tree` / `feature-spec`). Pre-0.30.2 the
+    // conditional above gated feature_repo on the row emission, dropping
+    // the edges in the all-collide case. Fixed per
+    // `coordination/feature-grounding-collision-edges-coordination.md`.
+    out.set("feature_repo", [
+        ...(out.get("feature_repo") ?? []),
+        ...grounding.featureRepoRows,
+    ]);
+    // feature_service starts here — earlier passes don't populate it.
+    out.set("feature_service", grounding.featureServiceRows);
+    // 10b. Capability-spec extractor per ADR 0145 (schema 2.7.0).
+    // Walks docs/domains/*/product/*.md (platform-profile only) and emits
+    // feature rows (source: capability-spec) plus capability_feature,
+    // feature_repo, feature_service edges from the
+    // `## Feature Grounding (code-path trace)` table. Runs after the
+    // feature-grounding extractor so precedence (feature-grounding wins
+    // on id collision) is enforced. Reuses ADR 0143's alias map for
+    // service / repo resolution.
+    const existingFeatureIdsAfterGrounding = new Set((out.get("features") ?? []).map((r) => String(r["id"])));
+    const capabilitySpec = await buildCapabilitySpec({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        knownCapabilityIds,
+        knownServiceIds,
+        knownRepoKeys,
+        existingFeatureIds: existingFeatureIdsAfterGrounding,
+        aliases: groundingAliases,
+    });
+    if (capabilitySpec.featureRows.length > 0) {
+        out.set("features", [
+            ...(out.get("features") ?? []),
+            ...capabilitySpec.featureRows,
+        ]);
+        out.set("capability_feature", [
+            ...(out.get("capability_feature") ?? []),
+            ...capabilitySpec.capabilityFeatureRows,
+        ]);
+    }
+    // feature_repo + feature_service edges are stored unconditionally —
+    // per ADR 0145 they're capability-spec's unique contribution and must
+    // emit even when every capability-spec row collides on feature id with an
+    // earlier source. Pre-fix the conditional above gated these edges on the
+    // row emission, dropping them in the all-collide case (same two-level bug
+    // feature-grounding had pre-0.30.2). Fixed per
+    // `coordination/capability-spec-collision-edges-coordination.md`.
+    out.set("feature_repo", [
+        ...(out.get("feature_repo") ?? []),
+        ...capabilitySpec.featureRepoRows,
+    ]);
+    out.set("feature_service", [
+        ...(out.get("feature_service") ?? []),
+        ...capabilitySpec.featureServiceRows,
+    ]);
+    // 10b-ter. feature_service — application-product Feature Services table.
+    // WS0c (catalogue-coverage-invariants.md) found this table authored and
+    // unread: 12 SDDs carry a populated `## Feature Services` table in
+    // feature-tree.md, 155 declared rows / 385 feature×service pairs, 0
+    // emitted, because the two extractors above only ever walk
+    // feature-grounding.md / capability-spec paths (platform / integration
+    // profiles). Runs last so knownFeatureIds reflects every prior source.
+    // No `source` column exists on feature_service (schema has none), so rows
+    // are emitted in the same bare {id, feature_id, service_id} shape as the
+    // extractors above — adding one is a separate, unscoped schema decision.
+    if (manifest.profile === "application-product") {
+        const featureTreePath = await findFeatureTreeFile(sddPath);
+        if (featureTreePath !== null) {
+            const relPath = relative(sddPath, featureTreePath);
+            const text = await readFile(featureTreePath, "utf-8");
+            const knownFeatureIdsFinal = new Set((out.get("features") ?? []).map((r) => String(r["id"])));
+            const existingFeatureServiceIds = new Set((out.get("feature_service") ?? []).map((r) => String(r["id"])));
+            const tableRows = [];
+            for (const row of parseFeatureServicesTable(text)) {
+                const featureId = `${manifest.sddId}-${row.featureSlug}`;
+                const featureKnown = knownFeatureIdsFinal.has(featureId);
+                if (!featureKnown) {
+                    findings.add("orphan", `${relPath}: Feature Services row "${row.featureSlug}" doesn't resolve to a known feature id "${featureId}"`);
+                }
+                for (const span of row.rejectedSpans ?? []) {
+                    findings.add("convention", `${relPath}: Feature Services row "${row.featureSlug}" has a backticked span "${span}" that is not a legal service id ([a-z0-9][a-z0-9_-]*); it was not read as a service`);
+                }
+                for (const serviceId of row.serviceIds) {
+                    if (!knownServiceIds.has(serviceId)) {
+                        findings.add("orphan", `${relPath}: Feature Services row "${row.featureSlug}" names service "${serviceId}" which doesn't resolve against services.csv`);
+                        continue;
+                    }
+                    if (!featureKnown)
+                        continue;
+                    const id = `${featureId}__${serviceId}`;
+                    if (existingFeatureServiceIds.has(id))
+                        continue;
+                    existingFeatureServiceIds.add(id);
+                    tableRows.push({ id, feature_id: featureId, service_id: serviceId });
+                }
+            }
+            if (tableRows.length > 0) {
+                out.set("feature_service", [
+                    ...(out.get("feature_service") ?? []),
+                    ...tableRows,
+                ]);
+            }
+        }
+    }
+    // 10b-quater. feature_repo derivation — feature_service ⋈
+    // services.primary_repo_id (D8 of catalogue-coverage-invariants).
+    //
+    // MUST run after 10b-ter, because feature_service is not final until the
+    // app-product Feature Services table has been read — and that table is the
+    // reason this derivation is worth anything in application-product, the profile
+    // where feature_repo previously had no source at all (its only extractor is
+    // platform-gated and its forward source is a `TBD` placeholder).
+    //
+    // MUST run before 10b-bis, so repo_capability Path Y (capability_feature ⋈
+    // feature_repo) sees these rows too. That cascade is deliberate and was
+    // measured before shipping rather than assumed.
+    {
+        const existingFeatureRepo = out.get("feature_repo") ?? [];
+        const derived = deriveFeatureRepoFromServices({
+            featureServiceRows: out.get("feature_service") ?? [],
+            serviceRows: out.get("services") ?? [],
+            knownRepoIds: new Set((out.get("repositories") ?? []).map((r) => String(r["id"]))),
+            existingIds: new Set(existingFeatureRepo.map((r) => String(r["id"]))),
+        });
+        if (derived.length > 0) {
+            out.set("feature_repo", [...existingFeatureRepo, ...derived]);
+        }
+    }
+    // 10b-bis. Second pass on repo_capability Path Y (per ADR 0157 §4.3) —
+    // capability_feature ⋈ feature_repo. The initial repo-edges pass (step 10)
+    // ran before the feature-grounding extractor populated feature_repo, so
+    // Path Y picked up zero rows there. Now that feature_repo is fully built,
+    // re-run just Path Y and merge into the existing repo_capability rows
+    // with deduplication.
+    const existingRepoCap = out.get("repo_capability") ?? [];
+    const repoCapSeen = new Set(existingRepoCap.map((r) => String(r["id"])));
+    const featureRepoFinal = out.get("feature_repo") ?? [];
+    const capFeatureFinal = out.get("capability_feature") ?? [];
+    const knownRepoIdsFinal = new Set(repos.map((r) => String(r["id"])));
+    const featuresToReposFinal = new Map();
+    for (const fr of featureRepoFinal) {
+        const fid = String(fr["feature_id"] ?? "");
+        const rid = String(fr["repo_id"] ?? "");
+        if (fid === "" || rid === "")
+            continue;
+        if (!featuresToReposFinal.has(fid))
+            featuresToReposFinal.set(fid, new Set());
+        featuresToReposFinal.get(fid).add(rid);
+    }
+    const pathYRows = [];
+    for (const cf of capFeatureFinal) {
+        const fid = String(cf["feature_id"] ?? "");
+        const cid = String(cf["capability_id"] ?? "");
+        if (fid === "" || cid === "")
+            continue;
+        const reposForFeature = featuresToReposFinal.get(fid);
+        if (!reposForFeature)
+            continue;
+        for (const repoId of reposForFeature) {
+            if (!knownRepoIdsFinal.has(repoId))
+                continue;
+            const id = `${repoId}__${cid}`;
+            if (repoCapSeen.has(id))
+                continue;
+            repoCapSeen.add(id);
+            pathYRows.push({ id, repo_id: repoId, capability_id: cid });
+        }
+    }
+    if (pathYRows.length > 0) {
+        out.set("repo_capability", [...existingRepoCap, ...pathYRows]);
+    }
+    // 10b-bis². feature_repo zero-resolution SUMMARIES (M-ADR 0143 §4.4), one
+    // per evidence surface, split against the FINAL feature_repo. The per-row
+    // lines fire inside the builders; some name features that another surface
+    // (feature-tree `## Feature Services`, feature-spec, the 10b-quater
+    // derivation) DID anchor. Measured on the reference platform estate:
+    // 641 lines naming 571 features, 120 anchored via another surface — 21%
+    // of the headline was cell quality, not coverage. Only the build can
+    // tell the two apart, which is why the summary lives here.
+    for (const [cellLabel, r] of [
+        ["Evidence", grounding],
+        ["Implementation", capabilitySpec],
+    ]) {
+        const summary = zeroResolutionSummary(cellLabel, r.repoEvidenceRows, r.repoZeroResolutionFeatureIds, featuresToReposFinal);
+        if (summary !== null)
+            findings.add("coverage", summary);
+    }
+    // 10c. feature_subscription_channels per schema 2.9.0 — walks any
+    // `reverse-evidence/feature-grounding-evidence.yaml` in the SDD and
+    // emits one row per `subscription_channels:` entry on each feature.
+    // Runs after all feature sources (10, 10a, 10b) so feature-id
+    // resolution sees the full features.csv id set.
+    const featureIdsAfterAllSources = new Set((out.get("features") ?? []).map((r) => String(r["id"])));
+    out.set("feature_subscription_channels", await buildFeatureSubscriptionChannels({
+        sddPath,
+        findings,
+        existingFeatureIds: featureIdsAfterAllSources,
+        productId: manifest.sddId,
+    }));
+    // 10d. product_platform_dependencies per schema 2.9.0 — walks the same
+    // `reverse-evidence/feature-grounding-evidence.yaml` files for the
+    // product-scoped `platform_dependencies:` block and emits per-SDD edge
+    // rows. The aggregator joins these against platform-side
+    // capability_service at aggregation time to produce
+    // cross_sdd_platform_capability rows.
+    out.set("product_platform_dependencies", await buildProductPlatformDependencies({
+        sddPath,
+        findings,
+        productId: manifest.sddId,
+    }));
+    // data_plane ↔ product_platform_dependencies coherence (M-ADR 0193 §4.2, as
+    // amended): the two surfaces are complementary, cross-checked on their overlap
+    // rather than derived. A synchronous internal `retrieve` binding whose target
+    // service has no platform-dependency row is a drift-visible finding.
+    {
+        const dpBindings = out.get("application_data_plane_bindings") ?? [];
+        const platformDeps = out.get("product_platform_dependencies") ?? [];
+        if (dpBindings.length > 0) {
+            checkDataPlanePlatformDepCoherence({
+                productId: manifest.sddId,
+                bindings: dpBindings,
+                platformDeps,
+                findings,
+            });
+            // publish binding ↔ surface: api coherence (M-ADR 0193 §4.7 / 0167):
+            // complementary views cross-checked, not derived.
+            checkPublishSurfaceCoherence({
+                productId: manifest.sddId,
+                surface: manifest.surface,
+                bindings: dpBindings,
+                findings,
+            });
+        }
+    }
+    // 11. Events + service_event + capability_event.
+    // Per ADR 0156 (schema 2.12.0), events ingest from both the forward-method
+    // avsc path and the reverse-method `event-catalog.yaml` path. YAML wins on
+    // name/domain/publisher/transport; avsc augments schema_path/version.
+    // service_event edges populate from both repo-config events.produces/consumes
+    // (forward) and event-catalog.yaml publisher + consumers[] (reverse).
+    const avroContracts = contractsResult.rows.filter((c) => c["kind"] === "event");
+    const eventsResult = await buildEvents({
+        sddPath,
+        findings,
+        avroContracts,
+        contractIdByPath: mergedContractIdByPath,
+        configs: reposResult.configs,
+        knownServiceIds,
+        knownDomainIds,
+    });
+    out.set("events", eventsResult.rows);
+    const knownEventIds = new Set(eventsResult.rows.map((e) => String(e["id"])));
+    out.set("service_event", buildServiceEvent({
+        findings,
+        configs: reposResult.configs,
+        contractIdByPath: mergedContractIdByPath,
+        knownServiceIds,
+        knownEventIds,
+        yamlEvents: eventsResult.yamlEvents,
+    }));
+    out.set("capability_event", buildCapabilityEvent({
+        findings,
+        manifests: traceability,
+        knownCapabilityIds,
+        knownEventIds,
+        capabilityServiceRows: out.get("capability_service") ?? [],
+        serviceEventRows: out.get("service_event") ?? [],
+    }));
+    // 12. service_contract — exposes rows from repo-config contracts block,
+    // plus consumes rows derived from each service's
+    // repos/<service>/docs/service-architecture.md External Interfaces table.
+    // The consumes-emission path is gated on an adopter-supplied
+    // .sdd/service-contract-aliases.yaml mapping interface display text to
+    // canonical contract names. Pattern documented in ADR 0147.
+    const exposesRows = buildServiceContract({
+        findings,
+        configs: reposResult.configs,
+        contractIdByPath: mergedContractIdByPath,
+        knownServiceIds,
+    });
+    const serviceContractAliases = await loadServiceContractAliases(sddPath);
+    const consumesRows = await buildServiceContractConsumes({
+        sddPath,
+        findings,
+        knownServiceIds,
+        aliases: serviceContractAliases,
+        // M-ADR 0203 §4.4 cut window: alias targets authored as 2.x kindless
+        // contract ids re-key against this build's kind-suffixed rows.
+        legacyContractIdMap: buildLegacyContractIdMap(out.get("contracts") ?? []),
+    });
+    out.set("service_contract", [...exposesRows, ...consumesRows]);
+    // Vacuous-signal (M-ADR 0197 §4.7's fourth failure mode, distinct from
+    // silent loss/loud failure/wrong value): a declared entry whose id
+    // differs from its repository's own can never receive service_event or
+    // service_contract rows today — §4.6's per-entry attribution mechanism
+    // isn't built yet, so nothing downstream even attempts it. That is not
+    // an authoring gap to chase (nothing failed to resolve) and not
+    // evidence the service genuinely publishes/consumes/exposes nothing —
+    // it is a fact that cannot yet be expressed. Named explicitly, once per
+    // declared entry, rather than left to read as a quiet, complete-looking
+    // absence indistinguishable from "this service really has none".
+    if (declaredNonRepoServiceIds.size > 0) {
+        const serviceEventIds = new Set((out.get("service_event") ?? []).map((r) => String(r["service_id"])));
+        const serviceContractIds = new Set((out.get("service_contract") ?? []).map((r) => String(r["service_id"])));
+        for (const id of declaredNonRepoServiceIds) {
+            if (!serviceEventIds.has(id) && !serviceContractIds.has(id)) {
+                findings.add("coverage", `services: declared entry "${id}" has no events/contracts of its own — vacuous, not evidence it has none. No per-entry authoring surface exists yet (M-ADR 0197 §4.6); this is a known modelling gap, not an authoring gap to fix.`);
+            }
+        }
+    }
+    // 12-bis. Second pass on repo_contract Path X (per ADR 0157 §4.2 amendment) —
+    // service_contract ⋈ services.primary_repo_id. The initial repo-edges pass
+    // (step 10) ran before service_contract was built, so Path X picked up zero
+    // rows there. Now that service_contract is fully populated, derive the
+    // missing edges and append with deduplication against existing rows.
+    const existingRepoContract = out.get("repo_contract") ?? [];
+    const repoContractSeen = new Set(existingRepoContract.map((r) => String(r["id"])));
+    const repoBySvcIdRC = new Map();
+    for (const s of services) {
+        const sid = String(s["id"]);
+        const repoId = String(s["primary_repo_id"] ?? "");
+        if (sid !== "" && repoId !== "")
+            repoBySvcIdRC.set(sid, repoId);
+    }
+    const pathXRowsRC = [];
+    const knownRepoIdsRC = new Set(repos.map((r) => String(r["id"])));
+    for (const sc of out.get("service_contract") ?? []) {
+        const svcId = String(sc["service_id"] ?? "");
+        const ctrId = String(sc["contract_id"] ?? "");
+        if (svcId === "" || ctrId === "")
+            continue;
+        const repoId = repoBySvcIdRC.get(svcId);
+        if (repoId === undefined)
+            continue;
+        if (!knownRepoIdsRC.has(repoId))
+            continue;
+        const id = `${repoId}__${ctrId}`;
+        if (repoContractSeen.has(id))
+            continue;
+        repoContractSeen.add(id);
+        pathXRowsRC.push({ id, repo_id: repoId, contract_id: ctrId });
+    }
+    if (pathXRowsRC.length > 0) {
+        out.set("repo_contract", [...existingRepoContract, ...pathXRowsRC]);
+    }
+    // 12a. feature_contract — derived edge per schema 2.3.0. Runs after every
+    // input row set is populated. feature_service is not yet built by the
+    // canonical builder (deferred), so the reverse path produces zero rows
+    // today; the builder is wired for both paths so coverage grows
+    // automatically once feature_service lands.
+    out.set("feature_contract", buildFeatureContract({
+        findings,
+        capabilityFeatureRows: out.get("capability_feature") ?? [],
+        capabilityContractRows: out.get("capability_contract") ?? [],
+        featureServiceRows: out.get("feature_service") ?? [],
+        serviceContractRows: out.get("service_contract") ?? [],
+    }));
+    // 12a-bis. feature_event — derived edge per schema 2.15.0 / ADR 0161.
+    // Pure join of feature_service ⋈ service_event; no authored shape. Mirrors
+    // ADR 0160's capability_event derived path one rung lower in the hierarchy.
+    out.set("feature_event", buildFeatureEvent({
+        knownFeatureIds: featureIdsAfterAllSources,
+        knownEventIds,
+        featureServiceRows: out.get("feature_service") ?? [],
+        serviceEventRows: out.get("service_event") ?? [],
+    }));
+    // 12b. domain_models + capability_domain_model + feature_domain_model
+    // per schema 2.4.0 / ADR 0142. Platform-profile only — non-platform
+    // builds emit headers-only. domain_models runs first; the edges depend
+    // on its known-id set.
+    const domainModels = await buildDomainModels({
+        sddPath,
+        manifest,
+        findings,
+        manifests: traceability,
+        knownDomainIds,
+    });
+    out.set("domain_models", domainModels);
+    const knownDomainModelIds = new Set(domainModels.map((r) => String(r["id"])));
+    out.set("capability_domain_model", buildCapabilityDomainModel({
+        findings,
+        manifest,
+        manifests: traceability,
+        capabilityRows: capabilities,
+        knownCapabilityIds,
+        knownDomainModelIds,
+    }));
+    out.set("feature_domain_model", buildFeatureDomainModel({
+        findings,
+        manifest,
+        capabilityFeatureRows: out.get("capability_feature") ?? [],
+        capabilityDomainModelRows: out.get("capability_domain_model") ?? [],
+    }));
+    // 13. App-product profile builders (personas, journeys, persona/journey
+    // edges, product-edges). Per ADR 0134, app-product SDDs emit these
+    // catalogues; other profiles emit zero rows. Per ADR 0136, product_*
+    // edges' capability_id and service_id are external FKs validated by
+    // the aggregator, not here.
+    const featureIdByPath = featuresResult.idByPath;
+    const featureIdBySlug = featuresResult.idBySlug;
+    const personasResult = await buildPersonas({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        productId: manifest.sddId,
+    });
+    out.set("personas", personasResult.rows);
+    const journeysResult = await buildUserJourneys({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        productId: manifest.sddId,
+    });
+    out.set("user_journeys", journeysResult.rows);
+    out.set("persona_journey", buildPersonaJourney({
+        findings,
+        personaIdByName: personasResult.idByName,
+        personaIdBySlug: personasResult.idBySlug,
+        journeyPrimaryPersonaById: journeysResult.primaryPersonaById,
+        journeySupportingPersonasById: journeysResult.supportingPersonasById,
+    }));
+    out.set("persona_feature", buildPersonaFeature({
+        findings,
+        relatedFeaturesById: personasResult.relatedFeaturesById,
+        featureIdByPath,
+        featureIdBySlug,
+    }));
+    out.set("journey_feature", buildJourneyFeature({
+        findings,
+        journeyFeaturePathsById: journeysResult.featurePathsById,
+        journeyRelatedFeatureSlugsById: journeysResult.relatedFeatureSlugsById,
+        featureIdByPath,
+        featureIdBySlug,
+    }));
+    // UI screens family (per ADR 0166). Application-product profile; the walker
+    // reads `screens/*.md` screen-spec artefacts (frontmatter + ```openui-lang
+    // block) and emits the six catalogues. Other profiles have no screens/ dir →
+    // empty. FK resolution uses the feature + persona id maps already built.
+    // Optional adopter-tunable screen-validation parameters (ADR 0168 §4.5 /
+    // ADR 0169 §4.3); absent → method defaults (the vocabulary-free checks run).
+    const screenValidation = await loadScreenValidationConfig(sddPath);
+    const screensResult = await buildScreens({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        productId: manifest.sddId,
+        featureIdBySlug,
+        featureIdByPath,
+        personaIdBySlug: personasResult.idBySlug,
+        personaIdByName: personasResult.idByName,
+        flatThreshold: screenValidation?.flatThreshold,
+        decorativePrimitives: screenValidation?.decorativePrimitives,
+        archetypeOverlays: screenValidation?.archetypeOverlays,
+    });
+    out.set("screens", screensResult.screens);
+    out.set("ui_components", screensResult.uiComponents);
+    out.set("screen_component", screensResult.screenComponent);
+    out.set("screen_feature", screensResult.screenFeature);
+    out.set("persona_screen", screensResult.personaScreen);
+    out.set("screen_action", screensResult.screenAction);
+    // Rubric scores join the catalogue metamodel (M-ADR 0205 §4.5, schema
+    // 3.2.0). Reads `orchestration/gate-registry/*-scores.yaml` — profile-
+    // agnostic, because any SDD may carry a gate registry and most carry none.
+    // Absent directory → headers-only and no finding: the surface is optional,
+    // and an empty registry is a deliberate state the B2 coverage predicate
+    // reads, not a defect this builder should shout about.
+    // §3i: hand the scores builder the target catalogues' own path columns so a
+    // registry entry with no authored file_path can still gain a (coarse,
+    // scored_at) staleness basis. Built from rows already in `out` — the scores
+    // builder deliberately runs after every path-bearing target catalogue.
+    const pathIndexOf = (cat, pathCol) => new Map((out.get(cat) ?? [])
+        .filter((r) => typeof r["id"] === "string" && typeof r[pathCol] === "string" && r[pathCol] !== "")
+        .map((r) => [r["id"], r[pathCol]]));
+    const cataloguePathIndex = new Map([
+        ["adrs", pathIndexOf("adrs", "doc_path")],
+        ["contracts", pathIndexOf("contracts", "spec_path")],
+        ["capabilities", pathIndexOf("capabilities", "spec_path")],
+    ]);
+    const qualityScoresResult = await buildQualityScores({
+        sddPath,
+        findings,
+        sddId: manifest.sddId,
+        cataloguePathIndex,
+    });
+    out.set("quality_scores", qualityScoresResult.qualityScores);
+    out.set("quality_score_dimensions", qualityScoresResult.qualityScoreDimensions);
+    // Forward scaffold declarations (M-ADR 0207 §4.1, schema 3.4.0). Reads
+    // `orchestration/scaffolds/*.yaml`; absent directory → headers-only and NO
+    // finding (zero adoption is the designed state, §4.4). Runs after every
+    // target-bearing catalogue because its resolution pass derives each item's
+    // `state` from the rows already in `out` — the conditional-FK rule holds by
+    // construction because resolution is what computes state.
+    const scaffoldsResult = await buildScaffolds({
+        sddPath,
+        findings,
+        sddId: manifest.sddId,
+        schema,
+        rowsByCatalogue: out,
+    });
+    out.set("scaffolds", scaffoldsResult.scaffolds);
+    out.set("scaffold_items", scaffoldsResult.scaffoldItems);
+    // Screen↔capability context cross-check (ADR 0170 §4.6, schema 2.21.0):
+    // a screen's `context:` should equal the context of the capability it
+    // realises (screen → screen_feature → feature.capability_id →
+    // capability.context). Convention finding, never an FK failure — the
+    // divergences are the model's seam screens, and `cross-cutting` on
+    // either side is an expected non-match (chrome / straddling features).
+    checkScreenCapabilityContext({
+        findings,
+        screens: out.get("screens") ?? [],
+        screenFeature: out.get("screen_feature") ?? [],
+        features: out.get("features") ?? [],
+        capabilities: out.get("capabilities") ?? [],
+    });
+    const productEdges = await buildProductEdges({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        productId: manifest.sddId,
+    });
+    out.set("product_capability", productEdges.productCapability);
+    out.set("product_service", productEdges.productService);
+    // 14. Integration-product profile: emit one integrations.csv row per
+    // integration-provider SDD from `integration-manifest.yaml`.
+    const integrationsRows = await buildIntegrations({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        sddId: manifest.sddId,
+        repoCount: repos.length,
+        // Threaded from the SDD manifest so `products.exemplar` and
+        // `integrations.exemplar` derive from the one authored field (2.46.0).
+        ...(manifest.exemplar !== undefined ? { exemplar: manifest.exemplar } : {}),
+        ...(manifest.sharedLibrary !== undefined ? { sharedLibrary: manifest.sharedLibrary } : {}),
+    });
+    out.set("integrations", integrationsRows);
+    // 14-di. Data items, supply and demand (M-ADR 0216). Coverage is derived at aggregation,
+    // where supply and demand from different SDDs meet; a member build leaves it empty.
+    out.set("data_items", await buildDataItems(sddPath, findings));
+    out.set("integration_data_item", await buildIntegrationSupply({
+        sddPath,
+        findings,
+        integrationId: String(integrationsRows[0]?.["id"] ?? ""),
+    }));
+    out.set("feature_data_requirement", await buildFeatureDemand({
+        sddPath,
+        findings,
+        idByPath: featuresResult.idByPath,
+        idBySlug: featuresResult.idBySlug,
+        knownFeatureIds: new Set((out.get("features") ?? []).map((r) => String(r["id"]))),
+    }));
+    // 14a. integration_component (M-ADR 0171 §9, catalogued per §10.1): the
+    // component tier the manifest declares, with §10.2 id resolution against this
+    // SDD's repositories/services and the §9.3 aggregate cross-check. Runs after
+    // repos + services so both resolution sets are populated.
+    out.set("integration_component", await buildIntegrationComponents({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        sddId: manifest.sddId,
+        knownRepoIds: knownRepoIdsFinal,
+        knownServiceIds,
+    }));
+    // M-ADR 0217: build-time and generation-time dependencies between repositories,
+    // declared (repo-config depends_on) and derived (per-component sharedLibraries).
+    out.set("repo_dependency", await buildRepoDependencies({ sddPath, configs: reposResult.configs, knownRepoIds: knownRepoIdsFinal, findings }));
+    // 15. C4 systems + containers + components (L1 + L2 + L3). The L3 walker
+    // shipped per `coordination/c4-l3-walker-and-path-convention-coordination.md`
+    // (sdd-method-gov, 2026-05-29) — forward-method authoring path reading
+    // `c4-l3-*.mermaid.md` files alongside the L2 layout. The earlier Path-B
+    // deferral assumed reverse-method code-walking; this walker is the
+    // forward-method analogue, granularity-agnostic (per-container or
+    // per-domain rollup both supported).
+    const c4Systems = await buildC4Systems({
+        sddPath,
+        manifest,
+        findings,
+    });
+    out.set("c4_systems", c4Systems);
+    const knownSystemIds = new Set(c4Systems.map((r) => String(r["id"])));
+    const containerIdByEntryId = new Map();
+    const containerNameByEntryId = new Map();
+    const containerTechByEntryId = new Map();
+    const c4Containers = await buildC4Containers({
+        sddPath,
+        manifest,
+        findings,
+        knownSystemIds,
+        knownServiceIds,
+        knownDomainIds,
+        containerIdByEntryIdOut: containerIdByEntryId,
+        containerNameByEntryIdOut: containerNameByEntryId,
+        containerTechByEntryIdOut: containerTechByEntryId,
+    });
+    out.set("c4_containers", c4Containers);
+    const c4Components = await buildC4Components({
+        sddPath,
+        manifest,
+        findings,
+        c4ContainerRows: c4Containers,
+    });
+    out.set("c4_components", c4Components);
+    // 15b. C4 L1 context elements (ADR 0155): external systems + the
+    // persona→system and system→external edges, extracted from System_Ext /
+    // Person / Rel macros on the L1/L2 diagrams. (The rows were computed at
+    // step 7, where capability_service consults them — see above.)
+    out.set("c4_external_systems", c4External.rows);
+    // external_system_exemption per M-ADR 0189 §4.6 — the declared "genuinely
+    // external" that makes an unverified candidate distinguishable from an
+    // unexamined one. Reason vocabulary from the schema enum (one definition).
+    const externalExemptionReasons = new Set((schema.enums["external_system_exemption_reason"]?.values ?? []).map((v) => v.value));
+    out.set("external_system_exemption", await buildExternalSystemExemption({
+        sddPath,
+        findings,
+        knownExternalIds: new Set(c4External.rows.map((r) => String(r["id"]))),
+        allowedReasons: externalExemptionReasons,
+        // M-ADR 0203 §4.2 cut window: authored exemptions keyed by the 2.x
+        // name-slug ids re-key against this build's declared identities.
+        legacyIdMap: buildLegacyExtIdMap(c4External.rows),
+    }));
+    out.set("system_external_dependency", await buildSystemExternalDependency({
+        sddPath,
+        manifest,
+        findings,
+        knownSystemIds,
+        externalIdByEntryId: c4External.idByEntryId,
+        containerIdByEntryId,
+    }));
+    // container_dependency member tier (F19): the C4-correct authoring —
+    // Rel(container_a, container_b) — emits its edge here; the aggregator's
+    // adjudication leg merges rather than being the only source.
+    out.set("container_dependency", await buildContainerDependency({
+        sddPath,
+        manifest,
+        findings,
+        containerIdByEntryId,
+        externalIdByEntryId: c4External.idByEntryId,
+    }));
+    // persona_container per M-ADR 0189 F26 §3 (schema 2.34.0) — the
+    // L2-granularity companion to persona_c4system.
+    out.set("persona_container", await buildPersonaContainer({
+        sddPath,
+        manifest,
+        findings,
+        containerIdByEntryId,
+        externalIdByEntryId: c4External.idByEntryId,
+        personaIdByName: personasResult.idByName,
+        personaIdBySlug: personasResult.idBySlug,
+    }));
+    reportEntryIdReferentCollisions({
+        findings,
+        containerNameByEntryId,
+        containerTechByEntryId,
+        externalNameByEntryId: c4External.nameByEntryId,
+        externalTechByEntryId: c4External.technologyByEntryId,
+        externalDescByEntryId: c4External.descriptionByEntryId,
+    });
+    out.set("persona_c4system", await buildPersonaC4System({
+        sddPath,
+        manifest,
+        findings,
+        knownSystemIds,
+        personaIdByName: personasResult.idByName,
+        personaIdBySlug: personasResult.idBySlug,
+    }));
+    // 16. Glossary items + cross-references.
+    const glossaryResult = await buildGlossaryItems({
+        sddPath,
+        findings,
+        knownDomainIds,
+    });
+    out.set("glossary_items", glossaryResult.rows);
+    const knownGlossaryIds = new Set(glossaryResult.rows.map((r) => String(r["id"])));
+    // Per ADR 0158 (schema 2.12.0), the glossary-xref builder ingests from
+    // five walkers and emits two catalogues: glossary_xref (term-to-term
+    // relations) and entity_glossary (new sibling — data-model entity to
+    // canonical term mappings).
+    const xref = await buildGlossaryXref({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        idByDomainTerm: glossaryResult.idByDomainTerm,
+        knownGlossaryIds,
+        knownDomainIds,
+    });
+    out.set("glossary_xref", xref.glossaryXref);
+    out.set("entity_glossary", xref.entityGlossary);
+    // Backfill canonical_term_id + aliases onto glossary_items from the xref
+    // edges (same alignment manifest, resolved downstream).
+    out.set("glossary_items", backfillGlossaryRelations(glossaryResult.rows, xref.glossaryXref));
+    // 17. Data-model entities + service_entity + C4 roll-ups per ADR 0159
+    // (schema 2.13.0). Four new catalogues, five walkers:
+    //
+    //   - entities-manifest: forward path, reads models[].entities[] from
+    //     glossary-alignment-manifest.yaml.
+    //   - entities-mermaid: reverse path, parses erDiagram blocks under each
+    //     domain_models row's doc_path.
+    //   - service-entity-tables: reads `## Data Store Mapping` markdown
+    //     tables (relation=owns).
+    //   - c4-container-entity: pure derivation over service_entity ⋈
+    //     c4_containers.service_id.
+    //   - c4-system-entity: aggregation roll-up over c4_container_entity ⋈
+    //     c4_containers.system_id with container_count.
+    const entitiesFromManifest = await buildEntitiesFromManifest({
+        sddPath,
+        findings,
+        profile: manifest.profile,
+        knownDomainIds,
+        knownGlossaryIds,
+    });
+    const entitiesFromMermaid = await buildEntitiesFromMermaid({
+        sddPath,
+        findings,
+        domainModels: domainModels.map((r) => ({
+            id: String(r["id"]),
+            domain_id: String(r["domain_id"]),
+            doc_path: String(r["doc_path"]),
+        })),
+        knownGlossaryIds,
+    });
+    // Forward wins on attribute conflicts (matches per-adopter authoring intent
+    // per ADR 0159 §4.4). Reverse rows seed the map; forward overwrites.
+    const entitiesById = new Map();
+    for (const r of entitiesFromMermaid)
+        entitiesById.set(String(r["id"]), r);
+    for (const r of entitiesFromManifest)
+        entitiesById.set(String(r["id"]), r);
+    const entityRows = [...entitiesById.values()];
+    out.set("entities", entityRows);
+    // Per ADR 0159 §4.9: now that entities.csv exists, append entity_glossary
+    // rows for the reverse-method side. The forward-method emission via
+    // glossary-xref's models[].entities[] walker (ADR 0158) is already in
+    // xref.entityGlossary; here we extend with rows derived from
+    // entities-mermaid's slug-matched glossary_term FKs.
+    const existingEntityGlossaryPks = new Set(xref.entityGlossary.map((r) => String(r["id"])));
+    const extendedEntityGlossary = [...xref.entityGlossary];
+    for (const e of entityRows) {
+        const domainId = String(e["domain_id"] ?? "");
+        const glossaryId = String(e["glossary_term"] ?? "");
+        const name = String(e["name"] ?? "");
+        if (!domainId || !glossaryId || !name)
+            continue;
+        const pk = `${domainId}__${entitySlug(name)}__${glossaryId}`;
+        if (existingEntityGlossaryPks.has(pk))
+            continue;
+        existingEntityGlossaryPks.add(pk);
+        extendedEntityGlossary.push({
+            id: pk,
+            domain_id: domainId,
+            entity_name: name,
+            glossary_item_id: glossaryId,
+            status: "matched_direct",
+            source_sdd_id: "",
+        });
+    }
+    out.set("entity_glossary", extendedEntityGlossary);
+    // Indexes for service_entity-tables resolution.
+    const entityIdByDomainSlug = new Map();
+    const entityIdBySlug = new Map();
+    for (const e of entityRows) {
+        const id = String(e["id"]);
+        const name = String(e["name"]);
+        const dom = String(e["domain_id"] ?? "");
+        const slug = entitySlug(name);
+        if (dom)
+            entityIdByDomainSlug.set(`${dom}|${slug}`, id);
+        if (!entityIdBySlug.has(slug))
+            entityIdBySlug.set(slug, id);
+    }
+    // ADR 0164: backfill entities.persistence_kind from the Data Store Mapping
+    // Store column (reverse-only; forward store-less tables leave it empty).
+    const enrichedEntityRows = await enrichEntityPersistenceKind({
+        sddPath,
+        findings,
+        domainModels: domainModels.map((r) => ({
+            id: String(r["id"]),
+            domain_id: String(r["domain_id"]),
+            doc_path: String(r["doc_path"]),
+        })),
+        entityIdByDomainSlug,
+        entityIdBySlug,
+        entityRows,
+    });
+    out.set("entities", enrichedEntityRows);
+    const serviceEntityRows = await buildServiceEntityFromTables({
+        sddPath,
+        findings,
+        domainModels: domainModels.map((r) => ({
+            id: String(r["id"]),
+            domain_id: String(r["domain_id"]),
+            doc_path: String(r["doc_path"]),
+        })),
+        entityIdByDomainSlug,
+        entityIdBySlug,
+        services,
+        knownServiceIds,
+    });
+    out.set("service_entity", serviceEntityRows);
+    const containerEntityRows = buildC4ContainerEntity({
+        serviceEntityRows,
+        c4Containers,
+    });
+    out.set("c4_container_entity", containerEntityRows);
+    const systemEntityRows = buildC4SystemEntity({
+        containerEntityRows,
+        c4Containers,
+    });
+    out.set("c4_system_entity", systemEntityRows);
+    // M-ADR 0211 §4.3 — the population check that disagrees, run LAST because it needs
+    // c4_containers (built after capability_service) to classify unresolved ids three ways.
+    checkCapabilityServicePopulation({
+        findings,
+        manifests: traceability,
+        capabilityServiceRows: out.get("capability_service") ?? [],
+        knownCapabilityIds,
+        knownServiceIds,
+        knownExternalSystemIds,
+        knownContainers: c4Containers.map((r) => ({ id: String(r["id"]), name: String(r["name"] ?? ""), system_id: String(r["system_id"] ?? "") })),
+    });
+    return out;
+}
+const CONTEXT_CROSS_CUTTING = "cross-cutting";
+/**
+ * Convention check (schema 2.21.0): where a screen carries `context` and the
+ * capability it realises (via screen_feature -> features.capability_id)
+ * also carries `context`, a difference is surfaced as a `convention`
+ * finding. `cross-cutting` on either side is exempt: straddling
+ * features/capabilities and app chrome legitimately diverge — those
+ * screens are the model's documented seam screens.
+ */
+function checkScreenCapabilityContext(args) {
+    const capContext = new Map();
+    for (const cap of args.capabilities) {
+        const ctx = String(cap["context"] ?? "").trim();
+        if (ctx !== "")
+            capContext.set(String(cap["id"]), ctx);
+    }
+    if (capContext.size === 0)
+        return;
+    const featureCap = new Map();
+    for (const f of args.features) {
+        const capId = String(f["capability_id"] ?? "").trim();
+        if (capId !== "")
+            featureCap.set(String(f["id"]), capId);
+    }
+    const screenContext = new Map();
+    for (const scr of args.screens) {
+        const ctx = String(scr["context"] ?? "").trim();
+        if (ctx !== "")
+            screenContext.set(String(scr["id"]), ctx);
+    }
+    for (const edge of args.screenFeature) {
+        const screenId = String(edge["screen_id"] ?? "");
+        const sCtx = screenContext.get(screenId);
+        if (sCtx === undefined || sCtx === CONTEXT_CROSS_CUTTING)
+            continue;
+        const capId = featureCap.get(String(edge["feature_id"] ?? ""));
+        if (capId === undefined)
+            continue;
+        const cCtx = capContext.get(capId);
+        if (cCtx === undefined || cCtx === CONTEXT_CROSS_CUTTING)
+            continue;
+        if (sCtx !== cCtx) {
+            args.findings.add("convention", `screen-capability context mismatch: screen "${screenId}" ` +
+                `(context=${sCtx}) realises capability "${capId}" ` +
+                `(context=${cCtx}) — a seam screen or a mistag (ADR 0170 §4.6)`);
+        }
+    }
+}
+/** Catalogues whose rows come in families an input file can drop wholesale, and the column naming the family. */
+const FAMILY_COLUMN = {
+    quality_scores: "rubric_id",
+    quality_score_dimensions: "rubric_id",
+};
+export async function reportCollapsedFamilies(outDir, ownDir, rowsByCatalogue, findings) {
+    for (const [catalogue, column] of Object.entries(FAMILY_COLUMN)) {
+        let before;
+        for (const dir of [outDir, ownDir]) {
+            try {
+                const parsed = await readCatalogueCsv(join(dir, `${catalogue}.csv`));
+                before = new Map();
+                for (const r of parsed.rows) {
+                    const k = String(r[column] ?? "");
+                    before.set(k, (before.get(k) ?? 0) + 1);
+                }
+                break;
+            }
+            catch {
+                // no committed file there: nothing to compare against
+            }
+        }
+        if (before === undefined)
+            continue;
+        // A catalogue this build emits NOTHING for is not rewritten: the preserve rule keeps the committed
+        // file and says so. Judging it here would fire on every build, since the lost rows stay on disk.
+        if ((rowsByCatalogue.get(catalogue) ?? []).length === 0)
+            continue;
+        const after = new Map();
+        for (const r of rowsByCatalogue.get(catalogue) ?? []) {
+            const k = String(r[column] ?? "");
+            after.set(k, (after.get(k) ?? 0) + 1);
+        }
+        for (const [family, n] of before) {
+            if (family === "" || n === 0 || (after.get(family) ?? 0) > 0)
+                continue;
+            findings.add("coverage", `${catalogue}: family ${column}=${family} had ${n} row(s) in the committed catalogue and this build emits none — an input that produced it has stopped (e.g. a registry that no longer parses); FK, shape and validate all pass on absence, so this is the only signal. If the family was retired ON PURPOSE, commit the rebuilt catalogue: it no longer holds the family, and the next build passes`, "error", `quality_family:${family}`);
+        }
+    }
+}
+//# sourceMappingURL=build.js.map