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

package/dist/lib/catalogue/builders/capabilities.js

@@ -0,0 +1,488 @@
+// Capability discoverer — emits `capabilities.csv` rows from
+// traceability YAMLs (authoritative) plus capability spec files
+// (fallback for specs not covered by a traceability).
+//
+// Per ADR 0134 and the catalogue-builder-specification §"Inputs":
+//   - Authoritative source: docs/domains/<domain>/product/<cap>.traceability.yaml
+//     declares capability.id (canonical), domain, capability_spec, runway.
+//   - Fallback: capability spec markdown files at
+//     docs/domains/<domain>/product/<cap>.md without an accompanying
+//     traceability YAML. Filename stem is used as the capability id.
+//   - When a traceability's capability.id differs from the spec file's
+//     stem, the canonical id wins; the divergence is logged as a finding.
+import { readFile, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { readdir } from "node:fs/promises";
+const DOMAINS_DIR_REL = join("docs", "domains");
+/**
+ * The vocabulary `catalogue-schema.yaml` documents for `capabilities.status`.
+ * WIDENED at catalogue schema 3.5.0 from the prior three-member set: the census
+ * this constant powers is what produced the evidence, and the ruling went the
+ * census's way — `exploration`, `placeholder` and `detailed-pre-lock` each VARY
+ * WITHIN a domain, which is the ruled discriminator for a genuine lifecycle
+ * phase rather than an authoring convention, so all three were admitted rather
+ * than re-authored away.
+ *
+ * Still held as the census's reference set, NOT as a binding — the column
+ * declares no `column_enums`, deliberately and stagedly (binding carries
+ * hard-fail teeth, and one out-of-vocabulary row remains at one estate).
+ */
+const DOCUMENTED_CAPABILITY_STATUS = new Set([
+    "active",
+    "planned",
+    "exploration",
+    "deprecated",
+]);
+/**
+ * M-ADR 0201 SPEC-AUTHORING stages. Not lifecycle phases, and not this column's
+ * axis — they belong in the capability spec's own `**Status:**` header, gated
+ * there by the spec-lifecycle gate.
+ *
+ * Held separately so the census can say WHICH AXIS owns the value instead of
+ * reporting "unknown word". `placeholder` and `detailed-pre-lock` were briefly
+ * admitted into `capabilities.status` at catalogue schema 3.5.0 and retracted at
+ * 3.6.0: one column carrying two orthogonal axes cannot be read, because
+ * `placeholder` gave no way to tell whether the CAPABILITY was a placeholder or
+ * its DOCUMENT was.
+ */
+const SPEC_AUTHORING_STAGES = new Set([
+    "placeholder",
+    "first-draft",
+    "detailed-pre-lock",
+    "reverse-derived",
+]);
+/**
+ * `traceability.contracts.provenance` — how the capability's contract SET was
+ * produced. Added at catalogue schema 3.5.0, reusing the vocabulary the method
+ * already ships for `authoring-mode` rather than minting a second one.
+ *
+ * STRICTLY ORTHOGONAL to `traceability.contracts.status`: a reverse-extracted
+ * contract set that is fully mapped declares `status: complete` AND
+ * `provenance: reverse-extracted`. Two reverse-estate manifests had written
+ * `reverse-extracted` into `contracts.status`, where it is invalid, because
+ * there was nowhere to say both true things at once.
+ */
+const DOCUMENTED_CONTRACT_PROVENANCE = new Set([
+    "hand-authored",
+    "reverse-extracted",
+    "generated",
+]);
+export async function buildCapabilities(inputs) {
+    const rows = [];
+    // Row identity for sliced capabilities is (id, slice_scope); use that as the
+    // dedup key so legitimately-sliced capabilities emit one row per slice
+    // without colliding on `id`.
+    const seen = new Set();
+    // The manifest that WON each dedup key, kept so a later duplicate can be
+    // DIFFED against it rather than merely counted. See the divergence finding.
+    const keptBy = new Map();
+    const usedSpecPaths = new Set();
+    const sliceKey = (id, sliceScope) => sliceScope === "" ? id : `${id}::${sliceScope}`;
+    // Pass 1 — traceability-declared capabilities (authoritative).
+    for (const m of inputs.manifests) {
+        const cap = m.capability;
+        const slice = (cap.slice_scope ?? "").trim();
+        const dedupKey = sliceKey(cap.id, slice);
+        if (seen.has(dedupKey)) {
+            // ⚠ THE DISCARDED COPY'S CONTENT IS THE POINT, not the fact of duplication.
+            // This finding used to say only that a duplicate existed. An estate probe
+            // found SEVEN capabilities with two canonically-named manifests where the
+            // catalogue keeps the first-seen copy and discards the other — and for FOUR
+            // of them the score registry's file_path names the DISCARDED file. So a
+            // scorer read one file while the catalogue reported another, disagreeing on
+            // capability.status, exploration.uncertainty and runway.classification.
+            //
+            // A duplicate whose copies AGREE is harmless. One that disagrees means a
+            // consumer may have read the copy that was thrown away — and a wrong value
+            // in a discarded file emits no other finding, ever. So name the fields.
+            const kept = keptBy.get(dedupKey);
+            const diffs = [];
+            if (kept !== undefined) {
+                const pairs = [
+                    ["capability.status", (kept.capability.status ?? "").trim(), (cap.status ?? "").trim()],
+                    [
+                        "traceability.runway.classification",
+                        (kept.traceability.runway?.classification ?? "").trim(),
+                        (m.traceability.runway?.classification ?? "").trim(),
+                    ],
+                    [
+                        "capability.capability_spec",
+                        (kept.capability.capability_spec ?? "").trim(),
+                        (cap.capability_spec ?? "").trim(),
+                    ],
+                    [
+                        "capability.domain",
+                        (kept.capability.domain ?? "").trim(),
+                        (cap.domain ?? "").trim(),
+                    ],
+                ];
+                for (const [field, keptVal, dropVal] of pairs) {
+                    if (keptVal !== dropVal) {
+                        diffs.push(`${field} kept="${keptVal}" discarded="${dropVal}"`);
+                    }
+                }
+            }
+            const head = slice === ""
+                ? `${m.relPath}: capability.id="${cap.id}" already emitted by an earlier manifest`
+                : `${m.relPath}: capability.id="${cap.id}" slice="${slice}" already emitted by an earlier manifest`;
+            const keptPath = kept === undefined ? "an earlier manifest" : kept.relPath;
+            inputs.findings.add("divergence", diffs.length === 0
+                ? `${head} (${keptPath}) — THIS FILE IS DISCARDED. The two copies agree on ` +
+                    `status, runway classification, spec path and domain, so no consumer can be ` +
+                    `misled by which one was kept; the duplication itself is still worth removing.`
+                : `${head} (${keptPath}) — THIS FILE IS DISCARDED AND THE COPIES DISAGREE: ` +
+                    `${diffs.join("; ")}. Any consumer pointed at the discarded path (a score ` +
+                    `registry file_path, a review, a link) read values the catalogue does not ` +
+                    `report. Decide which copy survives per capability; do not bulk-delete, which ` +
+                    `would publish the discarded values rather than remove them.`);
+            continue;
+        }
+        if (!inputs.knownDomainIds.has(cap.domain)) {
+            inputs.findings.add("orphan", `${m.relPath}: capability.domain="${cap.domain}" has no docs/domains/${cap.domain}/`);
+        }
+        const specRel = cap.capability_spec ?? "";
+        let name = titleCase(cap.id);
+        let description = "";
+        if (specRel) {
+            usedSpecPaths.add(specRel);
+            const specAbs = join(inputs.sddPath, specRel);
+            // F22: an emitted spec_path must exist — a dangling path silently
+            // produced an empty name/description while the column pointed at
+            // nothing. The row still emits (the capability is declared); the
+            // dangle is loud.
+            if (!(await fileExists(specAbs))) {
+                inputs.findings.add("coverage", `${m.relPath}: capability "${cap.id}" declares capability_spec "${specRel}" which does not exist — name/description left empty, spec_path emitted dangling (F22)`);
+            }
+            // M-ADR 0211 §4.2 — the manifest is a declaration and its row is correct. The finding
+            // fires ONLY on a CONTRADICTION between two declaration surfaces: this manifest
+            // catalogues the spec as a capability, and the spec declares a Kind that does not
+            // catalogue. A missing template marker is never a finding (measured: six of seven
+            // such files in one estate were correct meta-aggregates).
+            const declaredKind = (await readSpecDeclaration(specAbs)).kind;
+            if (declaredKind !== "" && !CATALOGUING_KINDS.has(declaredKind)) {
+                inputs.findings.add(KNOWN_KINDS.has(declaredKind) ? "divergence" : "convention", KNOWN_KINDS.has(declaredKind)
+                    ? `${m.relPath}: declaration-mismatch — the manifest catalogues "${cap.id}" as a capability but ${specRel} declares Kind: ${declaredKind}, which does not catalogue; the row is emitted from the manifest and the contradiction is the finding (M-ADR 0211 §4.2)`
+                    : `${specRel}: declares Kind: "${declaredKind}", not in the vocabulary capability | meta-aggregate | policy | synthesis | guide (M-ADR 0211 §4.2)`);
+            }
+            const headingName = await readSpecH1Name(specAbs);
+            if (headingName !== "") {
+                name = headingName;
+            }
+            description = await readSpecOverview(specAbs);
+            // Log id ↔ spec stem divergence (informational).
+            const stem = stemOf(specRel);
+            if (stem !== "" && stem !== cap.id) {
+                inputs.findings.add("divergence", `${m.relPath}: capability.id="${cap.id}" differs from spec stem "${stem}"`);
+            }
+        }
+        // WILD-VOCABULARY CENSUS, reporting-only and deliberately NOT a binding.
+        //
+        // ✅ THE CENSUS WORKED AND ITS QUESTION IS NOW RULED. It measured 44 of the
+        // forward estate's rows outside the old three-member vocabulary — exploration
+        // 26, placeholder 11, detailed-pre-lock 6, first-draft 1 — and that evidence
+        // is what settled the ruling at catalogue schema 3.5.0: all three recurring
+        // values were ADMITTED, not re-authored away, because each varies WITHIN a
+        // domain (the ruled phase-vs-convention discriminator). Re-authoring them
+        // would have rewritten 37 rows that were declaring something true.
+        //
+        // So this census now reports the RESIDUE, not the population: 1 row at the
+        // forward estate (`first-draft`, n=1) and 0 at the reverse estate, measured
+        // structurally by key path. It stays reporting-only because the column still
+        // binds no enum — `convention` is non-gate-acting under M-ADR 0132 §4.3, so
+        // it cannot fail a gate on arrival. Binding is a later deliberate act, gated
+        // on that residue reaching zero at both estates.
+        //
+        // It keeps earning its place: an unenforced field cannot notice a wrong value
+        // when one is written, and this is the only thing that notices.
+        //
+        // Emitted only for an AUTHORED value: Pass 2's hardcoded default is a
+        // default, not a declaration, and reporting it would blame an adopter for
+        // a value the builder chose.
+        const declaredStatus = (cap.status ?? "").trim();
+        if (declaredStatus !== "" && !DOCUMENTED_CAPABILITY_STATUS.has(declaredStatus)) {
+            inputs.findings.add("convention", SPEC_AUTHORING_STAGES.has(declaredStatus)
+                ? `${m.relPath}: capability.status="${declaredStatus}" is a SPEC-AUTHORING stage ` +
+                    `(M-ADR 0201), not a capability lifecycle phase — this column carries lifecycle ` +
+                    `only (${[...DOCUMENTED_CAPABILITY_STATUS].join(" | ")}). Authoring stage belongs ` +
+                    `in the spec's own '**Status:**' header. The value is catalogued as authored and ` +
+                    `nothing is dropped; re-author to the lifecycle phase TRUE of the capability, ` +
+                    `which is not a translation of this word`
+                : `${m.relPath}: capability.status="${declaredStatus}" is outside the documented ` +
+                    `vocabulary (${[...DOCUMENTED_CAPABILITY_STATUS].join(" | ")}) — the value is ` +
+                    `catalogued as authored and nothing is dropped; reported so the population is ` +
+                    `countable`);
+        }
+        // contracts.provenance — orthogonal to contracts.status, and read WITHOUT
+        // consulting it. A value outside the set is reported and still catalogued,
+        // matching the status census's posture rather than dropping the cell.
+        const declaredProvenance = (m.traceability.contracts?.provenance ?? "").trim();
+        if (declaredProvenance !== "" &&
+            !DOCUMENTED_CONTRACT_PROVENANCE.has(declaredProvenance)) {
+            inputs.findings.add("convention", `${m.relPath}: traceability.contracts.provenance="${declaredProvenance}" is outside ` +
+                `the documented vocabulary (${[...DOCUMENTED_CONTRACT_PROVENANCE].join(" | ")}) — ` +
+                `the value is catalogued as authored and nothing is dropped`);
+        }
+        seen.add(dedupKey);
+        keptBy.set(dedupKey, m);
+        rows.push({
+            id: cap.id,
+            name,
+            domain_id: cap.domain,
+            tree_category: "",
+            parent_capability_id: "",
+            evidence_class: (cap.evidence_class ?? "").trim(),
+            context: (cap.context ?? "").trim(),
+            description,
+            status: cap.status ?? "active",
+            spec_path: specRel,
+            contract_provenance: declaredProvenance,
+            source: "capability-spec",
+            runway_classification: m.traceability.runway?.classification ?? "",
+            data_subset: cap.data_subset ?? "",
+            slice_scope: slice,
+            source_sdd_id: "",
+        });
+    }
+    // Pass 2 — capability spec files not covered by any traceability.
+    //
+    // M-ADR 0211 §4.2: placement asserts NOTHING. A product/*.md is catalogued only when it
+    // DECLARES something — the template H1, a lifecycle Status, or a Kind — and its kind
+    // catalogues. A file declaring nothing is silence: named, no row. A file declaring a
+    // non-cataloguing kind (policy, synthesis, guide) is respected: no row, no finding.
+    // §4.3: files=N rows=M excluded=K, every excluded class named, so the count can DISAGREE.
+    const specFiles = await collectCapabilitySpecs(inputs.sddPath);
+    const productFiles = new Set(specFiles.map((p) => relative(inputs.sddPath, p)));
+    let notACapabilitySpec = 0, nonCataloguingKind = 0, collisions = 0, unknownKind = 0;
+    for (const spec of specFiles) {
+        const relPath = relative(inputs.sddPath, spec);
+        if (usedSpecPaths.has(relPath))
+            continue;
+        if (rows.some((r) => r["spec_path"] === relPath))
+            continue;
+        const stem = stemOf(relPath);
+        if (seen.has(stem)) {
+            // The bare `continue` that dropped platform-tier specs silently for months (M-ADR
+            // 0211 §1(c)) — now the same divergence finding the manifest path emits.
+            collisions++;
+            const kept = rows.find((r) => r["id"] === stem);
+            inputs.findings.add("divergence", `capabilities: ${relPath} shares primary key "${stem}" with ${kept ? String(kept["spec_path"]) : "an earlier row"} — the earlier row is kept and THIS file emits no row (M-ADR 0211 §4.3: a stem collision on the spec-only path is now loud; two different things sharing a slug is authoring debt to split, not a key to widen)`);
+            continue;
+        }
+        const decl = await readSpecDeclaration(spec);
+        if (!decl.templateH1 && decl.status === "" && decl.kind === "") {
+            notACapabilitySpec++;
+            inputs.findings.add("coverage", `${relPath}: not-a-capability-spec — the file declares nothing (no template H1, no Status, no Kind), so its directory is not allowed to assert a capability for it; no row (M-ADR 0211 §4.2)`);
+            continue;
+        }
+        const kind = decl.kind === "" ? "capability" : decl.kind;
+        if (!KNOWN_KINDS.has(kind)) {
+            unknownKind++;
+            inputs.findings.add("convention", `${relPath}: declares Kind: "${kind}", not in the vocabulary capability | meta-aggregate | policy | synthesis | guide — catalogued as a capability meanwhile (M-ADR 0211 §4.2)`);
+        }
+        else if (!CATALOGUING_KINDS.has(kind)) {
+            nonCataloguingKind++;
+            continue; // respected, silently: the author declared it is not a capability
+        }
+        const domain = inferDomainFromSpec(relPath);
+        if (domain === "") {
+            inputs.findings.add("orphan", `${relPath}: cannot infer domain from path`);
+            continue;
+        }
+        if (!inputs.knownDomainIds.has(domain)) {
+            inputs.findings.add("orphan", `${relPath}: domain "${domain}" has no docs/domains/${domain}/`);
+        }
+        const heading = await readSpecH1Name(spec);
+        const description = await readSpecOverview(spec);
+        seen.add(sliceKey(stem, ""));
+        rows.push({
+            id: stem,
+            name: heading !== "" ? heading : titleCase(stem),
+            domain_id: domain,
+            tree_category: "",
+            parent_capability_id: "",
+            evidence_class: "",
+            context: "",
+            description,
+            // Pass-2 specs have no manifest to declare a lifecycle phase; `active` is the STATED
+            // default (M-ADR 0211 §4.2), not an assertion made by the directory.
+            status: "active",
+            spec_path: relPath,
+            contract_provenance: "",
+            source: "capability-spec",
+            runway_classification: "",
+            data_subset: "",
+            slice_scope: "",
+            source_sdd_id: "",
+        });
+    }
+    // M-ADR 0211 §4.3 — files against rows, never distinct keys against themselves.
+    const rowFiles = new Set(rows.map((r) => String(r["spec_path"])).filter((p) => productFiles.has(p)));
+    const excluded = notACapabilitySpec + nonCataloguingKind + collisions;
+    inputs.findings.add("metric", `capabilities: files=${productFiles.size} rows=${rows.length} rows-on-product-files=${rowFiles.size} excluded=${excluded} (not-a-capability-spec=${notACapabilitySpec} non-cataloguing-kind=${nonCataloguingKind} collision=${collisions} unknown-kind=${unknownKind})`);
+    if (productFiles.size !== rowFiles.size + excluded) {
+        inputs.findings.add("coverage", `capabilities: the population does not balance — ${productFiles.size} product/*.md files ≠ ${rowFiles.size} files with a row + ${excluded} excluded for a named reason. Files and rows are two instruments; they disagree, and the disagreement is the finding (M-ADR 0211 §4.3)`);
+    }
+    return rows;
+}
+export const CATALOGUING_KINDS = new Set(["capability", "meta-aggregate"]);
+export const KNOWN_KINDS = new Set(["capability", "meta-aggregate", "policy", "synthesis", "guide"]);
+export async function readSpecDeclaration(specAbs) {
+    let text;
+    try {
+        const st = await stat(specAbs);
+        if (!st.isFile())
+            return { templateH1: false, status: "", kind: "" };
+        text = await readFile(specAbs, "utf-8");
+    }
+    catch {
+        return { templateH1: false, status: "", kind: "" };
+    }
+    const head = text.split(/\r?\n/).slice(0, 60);
+    const templateH1 = head.some((l) => /^#\s*(Capability Specification|Spec):/i.test(l.trim()));
+    const bold = (field) => {
+        for (const l of head) {
+            const m = new RegExp(`\\*\\*${field}:\\*\\*\\s*([^|\\n]*)`).exec(l);
+            if (m)
+                return (m[1] ?? "").trim();
+        }
+        return "";
+    };
+    const prose = (field) => {
+        for (const l of head) {
+            if (!l.startsWith(">"))
+                continue;
+            const m = new RegExp(`${field}:\\s*([^|\\n]*)`).exec(l);
+            if (m)
+                return (m[1] ?? "").trim();
+        }
+        return "";
+    };
+    return { templateH1, status: bold("Status") || prose("Status"), kind: bold("Kind") || prose("Kind") };
+}
+async function readSpecH1Name(specAbs) {
+    try {
+        const s = await stat(specAbs);
+        if (!s.isFile())
+            return "";
+    }
+    catch {
+        return "";
+    }
+    const text = await readFile(specAbs, "utf-8");
+    for (const line of text.split(/\r?\n/)) {
+        const t = line.trim();
+        if (t === "")
+            continue;
+        if (!t.startsWith("#"))
+            return "";
+        const stripped = t
+            .replace(/^#+\s*/, "")
+            .replace(/^(Capability Specification|Spec):\s*/i, "")
+            .trim();
+        return stripped;
+    }
+    return "";
+}
+/**
+ * Extract the lead paragraph of a capability spec's `## Overview` section
+ * to use as `capabilities.description`.
+ *
+ * Returns the first non-empty paragraph block after the `## Overview`
+ * heading — lines are joined with single spaces, stopping at the next blank
+ * line or the next heading. Returns "" when the spec has no Overview section
+ * (not all specs require one).
+ */
+async function readSpecOverview(specAbs) {
+    try {
+        const s = await stat(specAbs);
+        if (!s.isFile())
+            return "";
+    }
+    catch {
+        return "";
+    }
+    const text = await readFile(specAbs, "utf-8");
+    const lines = text.split(/\r?\n/);
+    let inOverview = false;
+    const paragraph = [];
+    for (const line of lines) {
+        const t = line.trim();
+        if (!inOverview) {
+            if (/^##\s+Overview\s*$/i.test(t))
+                inOverview = true;
+            continue;
+        }
+        // Stop at the next heading.
+        if (t.startsWith("#"))
+            break;
+        if (t === "") {
+            // Blank line ends the lead paragraph once we've captured content.
+            if (paragraph.length > 0)
+                break;
+            continue;
+        }
+        paragraph.push(t);
+    }
+    return paragraph.join(" ");
+}
+async function collectCapabilitySpecs(sddPath) {
+    const out = [];
+    const domainsDir = join(sddPath, DOMAINS_DIR_REL);
+    let domains;
+    try {
+        domains = await readdir(domainsDir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const d of domains) {
+        if (!d.isDirectory())
+            continue;
+        const productDir = join(domainsDir, d.name, "product");
+        let entries;
+        try {
+            entries = await readdir(productDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (!e.isFile())
+                continue;
+            if (!e.name.endsWith(".md"))
+                continue;
+            const lower = e.name.toLowerCase();
+            if (lower === "readme.md" || lower === "index.md")
+                continue;
+            out.push(join(productDir, e.name));
+        }
+    }
+    return out;
+}
+function inferDomainFromSpec(relPath) {
+    const parts = relPath.split(sep);
+    const i = parts.indexOf("domains");
+    if (i === -1 || i + 1 >= parts.length)
+        return "";
+    return parts[i + 1] ?? "";
+}
+function stemOf(relPath) {
+    const base = relPath.split(sep).slice(-1)[0] ?? "";
+    return base.replace(/\.md$/i, "").replace(/\.traceability\.yaml$/i, "");
+}
+function titleCase(slug) {
+    return slug
+        .split("-")
+        .map((p) => (p.length === 0 ? p : p[0].toUpperCase() + p.slice(1)))
+        .join(" ");
+}
+async function fileExists(path) {
+    try {
+        const { stat } = await import("node:fs/promises");
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/lib/catalogue/builders/capability-domain-model.js

@@ -0,0 +1,74 @@
+// Edge builder for capability_domain_model — emits `capability_domain_model.csv`.
+//
+// Platform-profile only. Non-platform SDDs return an empty list.
+//
+// Sources:
+//   - Forward: for each loaded traceability manifest with
+//     `traceability.domain_model.path` set, emit one row linking
+//     capability_id → domain_model_id with source="traceability-manifest".
+//   - Reverse: for every capability whose domain has a row in
+//     domain_models.csv but which did NOT declare via the manifest,
+//     emit a row with source="inferred". This captures the
+//     "capability lives in domain D, and D has a domain model" inference.
+//
+// Domain model ids follow the `{domain_id}-data-model` convention from
+// the domain-models builder.
+//
+// Added in schema 2.4.0 per ADR 0142.
+export function buildCapabilityDomainModel(inputs) {
+    if (inputs.manifest.profile !== "platform-profile") {
+        return [];
+    }
+    const seen = new Set();
+    const rows = [];
+    // Path 1: Forward — declared in traceability manifests.
+    const declaredCapIds = new Set();
+    for (const m of inputs.manifests) {
+        if (!m.traceability.domain_model)
+            continue;
+        const capId = m.capability.id;
+        if (!inputs.knownCapabilityIds.has(capId))
+            continue;
+        const domainModelId = `${m.capability.domain}-data-model`;
+        if (!inputs.knownDomainModelIds.has(domainModelId))
+            continue;
+        const id = `${capId}__${domainModelId}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        declaredCapIds.add(capId);
+        rows.push({
+            id,
+            capability_id: capId,
+            domain_model_id: domainModelId,
+            source: "traceability-manifest",
+        });
+    }
+    // Path 2: Reverse — inferred from capability's domain having a domain model.
+    // Only emit for capabilities that didn't declare via manifest.
+    for (const cap of inputs.capabilityRows) {
+        const capId = String(cap["id"] ?? "");
+        if (capId === "" || declaredCapIds.has(capId))
+            continue;
+        if (!inputs.knownCapabilityIds.has(capId))
+            continue;
+        const domainId = String(cap["domain_id"] ?? "");
+        if (domainId === "")
+            continue;
+        const domainModelId = `${domainId}-data-model`;
+        if (!inputs.knownDomainModelIds.has(domainModelId))
+            continue;
+        const id = `${capId}__${domainModelId}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        rows.push({
+            id,
+            capability_id: capId,
+            domain_model_id: domainModelId,
+            source: "inferred",
+        });
+    }
+    return rows.sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+}
+//# sourceMappingURL=capability-domain-model.js.map