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

package/dist/lib/catalogue/builders/feature-grounding.js

@@ -0,0 +1,391 @@
+/**
+ * Feature-grounding extractor per ADR 0143 (schema 2.5.0).
+ *
+ * Walks `docs/domains/<dom>/design/<capability>/feature-grounding.md`
+ * (platform-profile) and `docs/design/integration/feature-grounding.md`
+ * (integration-product), parses the canonical markdown table, and
+ * emits four catalogue contributions:
+ *
+ *   - `features.csv` rows with `source: feature-grounding`.
+ *   - `capability_feature.csv` rows (1:1 with each feature row).
+ *   - `feature_repo.csv` rows derived from file-path references in
+ *     the Evidence column.
+ *   - `feature_service.csv` rows derived from class names / file
+ *     basenames / route fragments in API Routes / Backend Handlers
+ *     / Evidence columns, resolved via `services.csv` + the optional
+ *     per-SDD alias map.
+ *
+ * Resolution failures (unresolved capability, service, repo) emit
+ * findings but never break FK validation — only confidently-resolved
+ * rows are emitted.
+ *
+ * Precedence per ADR 0143 §4.4: feature-tree and feature-spec rows
+ * win on id collision; grounding rows are skipped with a divergence
+ * finding.
+ */
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { capabilityIdFromPath, findIntegrationGroundingFile, findPlatformGroundingFiles, parseGroundingTable, } from "./feature-grounding-walker.js";
+const DESCRIPTION_MAX = 500;
+/** Columns the service-name resolver scans for class names / route fragments. */
+const SERVICE_RESOLUTION_COLUMNS = [
+    "ui_components",
+    "api_routes",
+    "backend_handlers",
+    "evidence",
+];
+/** Columns the repo-name resolver scans for file-path references. */
+const REPO_RESOLUTION_COLUMNS = ["evidence", "ui_components"];
+export async function buildFeatureGrounding(inputs) {
+    const featureRows = [];
+    const capabilityFeatureRows = [];
+    const featureRepoRows = [];
+    // M-ADR 0143 §4.4 (amended): rows whose Evidence cell is non-empty but resolves to
+    // ZERO repos. Counted for the summary finding below; each row also gets its own
+    // line. This measures evidence→repo RESOLUTION COVERAGE, not correctness.
+    let repoEvidenceRows = 0;
+    const repoZeroResolutionFeatureIds = [];
+    const featureServiceRows = [];
+    const seenFeatureRepo = new Set();
+    const seenFeatureService = new Set();
+    const seenFeatures = new Set(inputs.existingFeatureIds);
+    // Kept separate from `seenFeatures`, which grows during this walk. The two
+    // sets are what distinguish a BY-DESIGN cross-source collision from a REAL
+    // within-source one — see the split at the collision site below.
+    const fromEarlierSource = new Set(inputs.existingFeatureIds);
+    const files = [];
+    if (inputs.profile === "platform-profile") {
+        for (const absPath of await findPlatformGroundingFiles(inputs.sddPath)) {
+            const capId = capabilityIdFromPath(absPath, inputs.sddPath);
+            files.push({ absPath, capabilityId: capId });
+        }
+    }
+    else if (inputs.profile === "integration-product") {
+        const absPath = await findIntegrationGroundingFile(inputs.sddPath);
+        if (absPath !== null) {
+            // For integration-product, the integration itself is the
+            // capability surface; use the SDD's product id.
+            files.push({ absPath, capabilityId: inputs.productId });
+        }
+    }
+    for (const { absPath, capabilityId: pathCapabilityId } of files) {
+        const relPath = relative(inputs.sddPath, absPath);
+        if (pathCapabilityId === "") {
+            inputs.findings.add("convention", `${relPath}: capability id could not be resolved from file path`);
+            continue;
+        }
+        // Resolve a design-dir slug that is not itself a capability id via the
+        // slug → id alias map (spec / feature-directory basename → declared id).
+        const capabilityId = inputs.knownCapabilityIds.has(pathCapabilityId)
+            ? pathCapabilityId
+            : (inputs.capabilitySlugAliases?.get(pathCapabilityId) ?? pathCapabilityId);
+        if (!inputs.knownCapabilityIds.has(capabilityId)) {
+            inputs.findings.add("convention", `${relPath}: capability "${pathCapabilityId}" from file path does not resolve against capabilities.csv`);
+            continue;
+        }
+        const text = await readFile(absPath, "utf-8");
+        const rows = parseGroundingTable(text);
+        if (rows.length === 0) {
+            inputs.findings.add("coverage", `${relPath}: feature-grounding.md found but no recognisable Feature-to-Code Mapping table`);
+            continue;
+        }
+        const slugsInThisFile = new Set();
+        for (const row of rows) {
+            if (slugsInThisFile.has(row.slug)) {
+                inputs.findings.add("divergence", `${relPath}:${row.lineNumber}: duplicate feature slug "${row.slug}" in same file (first occurrence wins)`);
+                continue;
+            }
+            slugsInThisFile.add(row.slug);
+            const featureId = `${capabilityId}-${row.slug}`;
+            const featureRowCollides = seenFeatures.has(featureId);
+            // Feature row + capability_feature edge: emit only on first sight.
+            // feature-tree / feature-spec win the row identity when they declared
+            // it first — they carry runway / group / parent context that
+            // grounding doesn't, plus capability-spec.ts already emitted the
+            // capability_feature row on the spec source path.
+            //
+            // feature_repo and feature_service edges: emit unconditionally per
+            // ADR 0143 §2 (these are the source's unique contribution; nothing
+            // else carries per-row code-mapping). Pre-0.30.2 the collision skip
+            // dropped these edges too — bug fixed per
+            // `coordination/feature-grounding-collision-edges-coordination.md`.
+            if (featureRowCollides) {
+                // ONE CHECK, TWO MEANINGS — split them, because they are not the same
+                // event and only one of them is a defect.
+                //
+                // `seenFeatures` is seeded from earlier sources AND grows during this
+                // walk, so a hit means either:
+                //   - an earlier SOURCE emitted this id. That is ADR 0143 §2's
+                //     documented precedence rule working exactly as specified: the
+                //     grounding pass re-declares ids that feature-tree/feature-spec
+                //     already own. It happens for essentially every grounded feature,
+                //     measured at 1,545 standing instances across two estates, and it
+                //     is correct output. Reported as `inferred` (the category
+                //     feature-contract.ts already uses for the identical
+                //     both-paths-produced-this dedup shape, and one the gate does not
+                //     act on).
+                //   - an earlier FILE in THIS source pass emitted it — two
+                //     feature-grounding files under one capability declaring the same
+                //     slug. That is a real authoring collision and stays `divergence`,
+                //     matching the within-one-file duplicate check above.
+                //
+                // Before this split the gate's contract ("fail on any new divergence
+                // line") could not work here: a real collision arrived inside a crowd
+                // of 1,545 accepted ones, so the whole category was unusable as a
+                // signal and unbaselineable as a backlog.
+                if (fromEarlierSource.has(featureId)) {
+                    inputs.findings.add("inferred", `${relPath}:${row.lineNumber}: feature id "${featureId}" already emitted by an earlier source (feature-tree / feature-spec wins for the row; feature_repo + feature_service edges still emitted per ADR 0143 §2)`);
+                }
+                else {
+                    inputs.findings.add("divergence", `${relPath}:${row.lineNumber}: feature id "${featureId}" already emitted by another file in this same feature-grounding pass — two files under one capability declare the same slug (first occurrence wins)`);
+                }
+            }
+            else {
+                seenFeatures.add(featureId);
+                featureRows.push({
+                    id: featureId,
+                    name: row.slug,
+                    product_id: "",
+                    capability_id: capabilityId,
+                    parent_group_id: "",
+                    parent_feature_id: "",
+                    description: deriveDescription(row),
+                    maturity: "",
+                    status: "active",
+                    source: "feature-grounding",
+                    runway: "",
+                    source_sdd_id: "",
+                });
+                const cfId = `${capabilityId}__${featureId}`;
+                capabilityFeatureRows.push({
+                    id: cfId,
+                    capability_id: capabilityId,
+                    feature_id: featureId,
+                });
+            }
+            // feature_service edges — emit regardless of row collision.
+            const services = resolveServices(row, inputs);
+            for (const serviceId of services) {
+                const edgeId = `${featureId}__${serviceId}`;
+                if (seenFeatureService.has(edgeId))
+                    continue;
+                seenFeatureService.add(edgeId);
+                featureServiceRows.push({
+                    id: edgeId,
+                    feature_id: featureId,
+                    service_id: serviceId,
+                });
+            }
+            // feature_repo edges — emit regardless of row collision.
+            const repos = resolveRepos(row, inputs);
+            if ((row.cells.get("evidence") ?? "").trim() !== "") {
+                repoEvidenceRows++;
+                if (repos.length === 0) {
+                    repoZeroResolutionFeatureIds.push(featureId);
+                    inputs.findings.add("coverage", `${relPath}:${row.lineNumber}: feature "${featureId}" — Evidence cell is non-empty but resolved to ZERO repos; name a repo key or path the resolver can match, or map the token in .sdd/feature-grounding-aliases.yaml repo_aliases (M-ADR 0143 §4.4)`);
+                }
+            }
+            for (const repoKey of repos) {
+                const edgeId = `${featureId}__${repoKey}`;
+                if (seenFeatureRepo.has(edgeId))
+                    continue;
+                seenFeatureRepo.add(edgeId);
+                featureRepoRows.push({
+                    id: edgeId,
+                    feature_id: featureId,
+                    repo_id: repoKey,
+                });
+            }
+        }
+    }
+    // Summary emitted by the build after feature_repo is final (split against
+    // features left with NO anchor from any surface).
+    return {
+        featureRows,
+        capabilityFeatureRows,
+        featureRepoRows,
+        featureServiceRows,
+        repoEvidenceRows,
+        repoZeroResolutionFeatureIds,
+    };
+}
+/**
+ * Build the description column by joining non-feature cells, capped at
+ * 500 chars to match the feature-tree bullet convention.
+ */
+function deriveDescription(row) {
+    const parts = [];
+    for (const [key, value] of row.cells) {
+        if (value === "")
+            continue;
+        parts.push(`${prettyHeader(key)}: ${value}`);
+    }
+    const joined = parts.join(" • ");
+    return joined.length > DESCRIPTION_MAX
+        ? joined.slice(0, DESCRIPTION_MAX)
+        : joined;
+}
+function prettyHeader(key) {
+    return key
+        .split("_")
+        .map((p) => (p.length === 0 ? p : p[0].toUpperCase() + p.slice(1)))
+        .join(" ");
+}
+/**
+ * Resolve service ids referenced in a row's cells. Strategy:
+ *  - Tokenize backtick-quoted identifiers + CamelCase / kebab-case tokens.
+ *  - Strip extensions (.ts/.java/.yaml/.kt/.py) and trailing parens.
+ *  - Try exact match against services.id (lowercased).
+ *  - Try alias map (case-sensitive — display names often carry case).
+ */
+function resolveServices(row, inputs) {
+    const out = new Set();
+    for (const col of SERVICE_RESOLUTION_COLUMNS) {
+        const cell = row.cells.get(col) ?? "";
+        if (cell === "")
+            continue;
+        for (const token of tokenize(cell)) {
+            const resolved = resolveServiceToken(token, inputs);
+            if (resolved !== null)
+                out.add(resolved);
+        }
+    }
+    return [...out].sort();
+}
+function resolveServiceToken(rawToken, inputs) {
+    // Try alias first (case-sensitive).
+    if (inputs.aliases !== null) {
+        const aliased = inputs.aliases.serviceAliases.get(rawToken);
+        if (aliased !== undefined && inputs.knownServiceIds.has(aliased)) {
+            return aliased;
+        }
+    }
+    // Normalise + try exact match.
+    const normalised = normaliseToken(rawToken);
+    if (normalised === "")
+        return null;
+    if (inputs.knownServiceIds.has(normalised))
+        return normalised;
+    // Try alias on normalised form too.
+    if (inputs.aliases !== null) {
+        const aliased = inputs.aliases.serviceAliases.get(normalised);
+        if (aliased !== undefined && inputs.knownServiceIds.has(aliased)) {
+            return aliased;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve repo ids from file-path references. Strategy:
+ *  - Tokenize path-like spans (contain `/` or end in known extensions).
+ *  - For each token: try longest-prefix match against
+ *    `canonical_repo_key`s; e.g. `example-service-api-master@abc/src/...`
+ *    → `example-service-api` (after stripping branch/sha suffix).
+ *  - Also accept the alias map for display-name → canonical-key.
+ */
+function resolveRepos(row, inputs) {
+    const out = new Set();
+    for (const col of REPO_RESOLUTION_COLUMNS) {
+        const cell = row.cells.get(col) ?? "";
+        if (cell === "")
+            continue;
+        const coded = inputs.repoTokenPolicy === "identifier" ? codeSpanTokens(cell) : null;
+        for (const token of tokenize(cell)) {
+            const resolved = resolveRepoToken(token, inputs);
+            if (resolved === null)
+                continue;
+            if (coded !== null && isPlainWord(token) && !coded.has(token) && inputs.aliases?.repoAliases.get(token) !== resolved)
+                continue;
+            out.add(resolved);
+        }
+    }
+    return [...out].sort();
+}
+function resolveRepoToken(rawToken, inputs) {
+    // Try alias first.
+    if (inputs.aliases !== null) {
+        const aliased = inputs.aliases.repoAliases.get(rawToken);
+        if (aliased !== undefined && inputs.knownRepoKeys.has(aliased)) {
+            return aliased;
+        }
+    }
+    // Direct match on the full token (rare).
+    if (inputs.knownRepoKeys.has(rawToken))
+        return rawToken;
+    // Walk every path segment and try to recover a repo key. Each
+    // segment may carry a `-master@<sha>` or `@<sha>` suffix; strip
+    // those before matching.
+    for (const segment of rawToken.split("/")) {
+        const stripped = segment
+            .replace(/-master@.*$/, "")
+            .replace(/@[^/]+$/, "");
+        if (stripped !== "" && inputs.knownRepoKeys.has(stripped)) {
+            return stripped;
+        }
+        // Also try the segment with the `-master` literal removed (no @sha).
+        const trailingMaster = stripped.replace(/-master$/, "");
+        if (trailingMaster !== stripped &&
+            inputs.knownRepoKeys.has(trailingMaster)) {
+            return trailingMaster;
+        }
+    }
+    return null;
+}
+/**
+ * Extract candidate identifier tokens from a markdown cell. Matches:
+ *  - Backticked spans: `` `AuthHandler.handleLoginRequest()` ``
+ *  - Bare identifiers: `ExampleOauthService`
+ *  - kebab-case identifiers: `example-service-api`
+ *  - Path-like tokens with at least one `/`.
+ * Strips leading method names (e.g. `AuthHandler.foo()` → `AuthHandler`).
+ */
+function tokenize(cell) {
+    const out = new Set();
+    // Backticked spans.
+    for (const match of cell.matchAll(/`([^`]+)`/g)) {
+        const inner = match[1] ?? "";
+        addCandidatesFromToken(inner, out);
+    }
+    // Bare identifiers outside backticks — strip backtick spans first.
+    const stripped = cell.replace(/`[^`]+`/g, " ");
+    for (const match of stripped.matchAll(/[A-Za-z][A-Za-z0-9._@/-]*[A-Za-z0-9]/g)) {
+        addCandidatesFromToken(match[0], out);
+    }
+    return [...out];
+}
+function addCandidatesFromToken(token, out) {
+    if (token === "")
+        return;
+    // Path token: take first segment as a candidate AND keep the full path.
+    if (token.includes("/")) {
+        out.add(token);
+        const first = token.split("/")[0] ?? "";
+        if (first !== "" && first !== token)
+            out.add(first);
+        return;
+    }
+    // Method/class form: split on `.`, contribute each segment except (), [].
+    const head = token.split(/[(.[]/)[0] ?? "";
+    if (head !== "")
+        out.add(head);
+    // Also keep the full token for alias-map matching on exact display
+    // strings like `AuthHandler.handleLoginRequest`.
+    out.add(token);
+}
+/** Candidate tokens that came from backticked code spans only. */
+function codeSpanTokens(cell) {
+    const out = new Set();
+    for (const match of cell.matchAll(/`([^`]+)`/g))
+        addCandidatesFromToken(match[1] ?? "", out);
+    return out;
+}
+/** A letters-only word — ordinary prose unless it is written as code. */
+const isPlainWord = (token) => /^[A-Za-z]+$/.test(token);
+function normaliseToken(token) {
+    return token
+        .toLowerCase()
+        .replace(/\.(ts|tsx|js|jsx|java|kt|kts|py|go|rs|yaml|yml|json|md)$/i, "")
+        .replace(/\(\)$/, "")
+        .trim();
+}
+//# sourceMappingURL=feature-grounding.js.map

package/dist/lib/catalogue/builders/feature-groups.js

@@ -0,0 +1,63 @@
+// FeatureGroups discoverer — emits `feature_groups.csv` rows from
+// hierarchical `feature-tree.md` files.
+//
+// Per Q7.2 resolution (adopt-canonical-catalogue-builder.md §7.2),
+// FeatureGroups are first-class entities. This builder consumes the
+// shared `feature-tree-walker` and emits one row per H2/H3 heading
+// outside fenced code blocks.
+//
+// ASCII-tree representations inside fenced code blocks are NOT parsed
+// — those are an adopter authoring style that doesn't map cleanly to
+// catalogue entities. Adopters wanting first-class groups format their
+// feature trees with proper H2/H3 headings.
+//
+// Source paths: see `findFeatureTreeFile` in feature-tree-walker.ts.
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { featureGroupId, findFeatureTreeFile, walkFeatureTree, } from "./feature-tree-walker.js";
+export async function buildFeatureGroups(inputs) {
+    const featureTreePath = await findFeatureTreeFile(inputs.sddPath);
+    if (!featureTreePath) {
+        return [];
+    }
+    const text = await readFile(featureTreePath, "utf-8");
+    const events = walkFeatureTree(text);
+    const rows = [];
+    for (const ev of events) {
+        if (ev.kind === "h2") {
+            rows.push({
+                id: featureGroupId(inputs.productId, ev.slug),
+                name: ev.text,
+                product_id: inputs.productId,
+                capability_id: "",
+                parent_group_id: "",
+                description: "",
+                source: "feature-tree-h2",
+                source_sdd_id: "",
+            });
+        }
+        else if (ev.kind === "h3") {
+            if (ev.parentH2Slug === "") {
+                // H3 with no enclosing H2 — orphan; surface as finding but emit anyway.
+                inputs.findings.add("convention", `${relative(inputs.sddPath, featureTreePath)}: H3 "${ev.text}" has no enclosing H2`);
+            }
+            const id = ev.parentH2Slug !== ""
+                ? featureGroupId(inputs.productId, ev.parentH2Slug, ev.slug)
+                : featureGroupId(inputs.productId, ev.slug);
+            rows.push({
+                id,
+                name: ev.text,
+                product_id: inputs.productId,
+                capability_id: "",
+                parent_group_id: ev.parentH2Slug !== ""
+                    ? featureGroupId(inputs.productId, ev.parentH2Slug)
+                    : "",
+                description: "",
+                source: "feature-tree-h3",
+                source_sdd_id: "",
+            });
+        }
+    }
+    return rows;
+}
+//# sourceMappingURL=feature-groups.js.map

package/dist/lib/catalogue/builders/feature-subscription-channels.js

@@ -0,0 +1,228 @@
+// feature_subscription_channels builder — emits one row per
+// `subscription_channels:` entry in any `reverse-evidence/feature-grounding-evidence.yaml`
+// file in the SDD. Added in schema 2.9.0.
+//
+// Per resolved decision §1 of `content/plans/v0-9-0-cohort-sweep-derived-bundle.md`
+// (see also `docs/method/methods/reverse/rubrics/reverse-application-evidence-quality.md`
+// per-feature slot vocabulary): `subscription_channels:` is a peer of
+// `graphql_operations:` in the per-feature evidence shape — `graphql_operations:`
+// carries the operation names declared in the GraphQL schema; this builder
+// captures the channel/topic layer (AppSync WebSocket, Pekko WS, MQTT, SSE,
+// etc.) that physically delivers push events.
+//
+// Input shape (per the rubric):
+//
+//   features:
+//     - feature_slug: <slug>
+//       subscription_channels:
+//         - name: <channel-identifier>
+//           transport: appsync-websocket | pekko-ws | mqtt | sse | webhook-push | other
+//           evidence: <sub-repo>/<path>:<line>
+//           payload_ref: <event-name>          # optional
+//
+// Feature-id resolution: the canonical builder emits feature rows with ids
+// shaped `{product_id|capability_id}-{feature_slug}`. Adopters' evidence
+// yamls carry only the bare `feature_slug:`. This builder accepts a set of
+// known feature ids (`existingFeatureIds`) and probes each candidate
+// resolution (`{productId}-{slug}` and `{slug}` and `<capability>-{slug}`
+// for any capability id ending in `-{slug}`). When no candidate resolves,
+// the row is dropped and an `orphan` finding is emitted so reviewers can
+// reconcile.
+import { readFile, readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+const VALID_TRANSPORTS = new Set([
+    "appsync-websocket",
+    "pekko-ws",
+    "mqtt",
+    "sse",
+    "webhook-push",
+    "other",
+]);
+export async function buildFeatureSubscriptionChannels(inputs) {
+    const rows = [];
+    const seenIds = new Set();
+    const evidenceFiles = await collectEvidenceFiles(inputs.sddPath);
+    for (const file of evidenceFiles) {
+        const relPath = relative(inputs.sddPath, file);
+        // The per-design-dir `feature-grounding-evidence.yaml` is this builder's
+        // dedicated contract — read/parse failures are its findings. The
+        // per-domain `<domain>-feature-grounding.yaml` files (ADR 0164) are
+        // primarily authored for other tooling and only opportunistically scanned
+        // for a `feature_subscription_channels:` key; they may not be strict YAML,
+        // so their read/parse failures are skipped silently (not this builder's
+        // authority to validate).
+        const isCanonical = file.substring(file.lastIndexOf(sep) + 1) === "feature-grounding-evidence.yaml";
+        let text;
+        try {
+            text = await readFile(file, "utf-8");
+        }
+        catch {
+            if (isCanonical) {
+                inputs.findings.add("convention", `${relPath}: cannot read evidence file`);
+            }
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = parseYaml(text);
+        }
+        catch (err) {
+            if (isCanonical) {
+                const msg = err instanceof Error ? err.message : String(err);
+                inputs.findings.add("convention", `${relPath}: invalid YAML — ${msg}`);
+            }
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object")
+            continue;
+        // Per-feature subscription_channels live under `features:` (per-design-dir
+        // layout) or a top-level `feature_subscription_channels:` list (per-domain
+        // layout, ADR 0164). Both are lists of { feature_slug, subscription_channels }.
+        const obj = parsed;
+        const featureEntries = [];
+        if (Array.isArray(obj["features"]))
+            featureEntries.push(...obj["features"]);
+        if (Array.isArray(obj["feature_subscription_channels"])) {
+            featureEntries.push(...obj["feature_subscription_channels"]);
+        }
+        if (featureEntries.length === 0)
+            continue;
+        for (const f of featureEntries) {
+            if (!f || typeof f !== "object")
+                continue;
+            const feat = f;
+            const slug = String(feat["feature_slug"] ?? "").trim();
+            if (slug === "")
+                continue;
+            const channels = feat["subscription_channels"];
+            if (!Array.isArray(channels) || channels.length === 0)
+                continue;
+            const featureId = resolveFeatureId(slug, inputs.productId, inputs.existingFeatureIds);
+            if (featureId === "") {
+                inputs.findings.add("orphan", `${relPath}: feature_slug="${slug}" carries subscription_channels but does not resolve to any catalogue feature id`);
+                continue;
+            }
+            for (const ch of channels) {
+                if (!ch || typeof ch !== "object")
+                    continue;
+                const channelObj = ch;
+                const channelName = String(channelObj["name"] ?? "").trim();
+                if (channelName === "") {
+                    inputs.findings.add("convention", `${relPath}: subscription_channels entry under feature_slug="${slug}" missing required "name" field`);
+                    continue;
+                }
+                const transport = String(channelObj["transport"] ?? "").trim();
+                if (transport === "") {
+                    inputs.findings.add("convention", `${relPath}: subscription_channels entry "${channelName}" under feature_slug="${slug}" missing required "transport" field`);
+                    continue;
+                }
+                if (!VALID_TRANSPORTS.has(transport)) {
+                    inputs.findings.add("convention", `${relPath}: subscription_channels entry "${channelName}" under feature_slug="${slug}" has unknown transport="${transport}" (expected one of ${[...VALID_TRANSPORTS].join(", ")})`);
+                    // Don't drop — emit the row with the literal transport. The
+                    // schema accepts any string; this finding lets reviewers
+                    // notice the deviation.
+                }
+                const evidence = typeof channelObj["evidence"] === "string"
+                    ? channelObj["evidence"].trim()
+                    : "";
+                const payloadRef = typeof channelObj["payload_ref"] === "string"
+                    ? channelObj["payload_ref"].trim()
+                    : "";
+                const rowId = `${featureId}__${channelName}`;
+                if (seenIds.has(rowId)) {
+                    inputs.findings.add("divergence", `${relPath}: duplicate subscription_channels row id="${rowId}" — same (feature_id, channel_name) already emitted`);
+                    continue;
+                }
+                seenIds.add(rowId);
+                rows.push({
+                    id: rowId,
+                    feature_id: featureId,
+                    channel_name: channelName,
+                    transport,
+                    evidence,
+                    payload_ref: payloadRef,
+                    source_sdd_id: "",
+                });
+            }
+        }
+    }
+    return rows;
+}
+/**
+ * Resolve a bare `feature_slug` from evidence yaml to a canonical feature id
+ * present in `existingFeatureIds`. Candidates probed in order:
+ *   1. `{productId}-{slug}` — typical for application-product / integration-product features.
+ *   2. The slug as-is — when the feature id is just the slug (legacy / capability-spec source).
+ *   3. Any existing id ending in `-{slug}` — covers `{capability-id}-{slug}` for capability-spec sourced features.
+ *
+ * Returns `""` when no candidate resolves.
+ */
+function resolveFeatureId(slug, productId, existing) {
+    if (productId !== "") {
+        const candidate = `${productId}-${slug}`;
+        if (existing.has(candidate))
+            return candidate;
+    }
+    if (existing.has(slug))
+        return slug;
+    for (const id of existing) {
+        if (id.endsWith(`-${slug}`))
+            return id;
+    }
+    return "";
+}
+async function collectEvidenceFiles(sddPath) {
+    const out = [];
+    await walk(sddPath, sddPath, out);
+    return out;
+}
+async function walk(root, current, out) {
+    let entries;
+    try {
+        entries = await readdir(current, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name === "node_modules" || e.name === ".git" || e.name === "source" || e.name === "catalogues" || e.name === "dist") {
+            continue;
+        }
+        const abs = join(current, e.name);
+        if (e.isDirectory()) {
+            // Check whether this is the reverse-evidence dir; if so, look for the file directly.
+            if (e.name === "reverse-evidence") {
+                // Two reverse-evidence layouts are read (ADR 0164):
+                //   - per-design-dir: `reverse-evidence/feature-grounding-evidence.yaml`
+                //     (features: → per-feature subscription_channels:).
+                //   - per-domain: `reverse-evidence/<domain>-feature-grounding.yaml`
+                //     at the SDD root (top-level feature_subscription_channels: list).
+                let reEntries;
+                try {
+                    reEntries = await readdir(abs, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const re of reEntries) {
+                    if (!re.isFile())
+                        continue;
+                    if (re.name === "feature-grounding-evidence.yaml" ||
+                        re.name.endsWith("-feature-grounding.yaml")) {
+                        out.push(join(abs, re.name));
+                    }
+                }
+                continue;
+            }
+            // Bound recursion depth via a heuristic on path component count from root
+            // to avoid pathological deep trees; reverse-evidence lives at most a few
+            // levels deep in adopters we've seen.
+            const rel = relative(root, abs);
+            if (rel.split(sep).length > 8)
+                continue;
+            await walk(root, abs, out);
+        }
+    }
+}
+//# sourceMappingURL=feature-subscription-channels.js.map