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

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

@@ -0,0 +1,152 @@
+// Personas discoverer — emits `personas.csv` rows from `personas/*.md`
+// at the SDD root.
+//
+// Source convention (per docs/method/methods/persona-template.md):
+//   personas/<slug>.md
+//   ---
+//   # Persona: {Name}
+//   **App:** {app-name}
+//   ## Summary
+//   {1-2 sentences}
+//
+// Cross-profile path (per coordination/persona-walker-platform-product-gap-
+// coordination.md, 2026-05-29): the walker reads `personas/` at SDD root
+// for every profile. Each SDD's personas/ carries personas at that SDD's
+// scope — for application-product that's app-specific personas, for
+// platform-product that's platform-wide / cross-app personas surfaced as
+// Person() actors on the L1 context diagram. integration-product can use
+// the same shape if a partner-side persona is ever needed (rare).
+//
+// id = `{product_id}-{slug}`, slug from filename stem.
+// name = H1 (with the optional `Persona:` prefix stripped).
+// description = first non-empty paragraph under `## Summary`.
+// role = empty (template doesn't carry a single-token role today; the
+//        column stays available for ecosystems that want to populate it).
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative } from "node:path";
+const PERSONAS_DIR_REL = "personas";
+export async function buildPersonas(inputs) {
+    const idByPath = new Map();
+    const idBySlug = new Map();
+    const idByName = new Map();
+    const relatedFeaturesById = new Map();
+    const dir = join(inputs.sddPath, PERSONAS_DIR_REL);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+        inputs.findings.add("coverage", `${PERSONAS_DIR_REL}/ not found — emitting empty personas.csv`);
+        return { rows: [], idByPath, idBySlug, idByName, relatedFeaturesById };
+    }
+    const files = entries
+        .filter((e) => e.isFile() && e.name.endsWith(".md") && !isTemplate(e.name))
+        .map((e) => e.name)
+        .sort();
+    const rows = [];
+    for (const filename of files) {
+        const slug = basename(filename).replace(/\.md$/i, "");
+        const id = `${inputs.productId}-${slug}`;
+        const absPath = join(dir, filename);
+        const relPath = relative(inputs.sddPath, absPath);
+        const text = await readFile(absPath, "utf-8");
+        const name = extractName(text) || titleCase(slug);
+        const description = extractSummary(text);
+        const relatedFeatures = extractRelatedFeatures(text);
+        rows.push({
+            id,
+            name,
+            product_id: inputs.productId,
+            role: "",
+            description,
+            source_sdd_id: "",
+        });
+        idByPath.set(relPath, id);
+        idBySlug.set(slug, id);
+        idByName.set(normaliseName(name), id);
+        relatedFeaturesById.set(id, relatedFeatures);
+    }
+    return { rows, idByPath, idBySlug, idByName, relatedFeaturesById };
+}
+function isTemplate(name) {
+    return /[{}]/.test(name) || name.toLowerCase().endsWith("-template.md");
+}
+function extractName(text) {
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line === "")
+            continue;
+        // Only the top-level H1 counts as a name. Skip non-heading lines and
+        // sub-headings (## ...).
+        const m = /^#\s+(.+)$/.exec(line);
+        if (!m)
+            return "";
+        const stripped = (m[1] ?? "").trim();
+        const personaPrefix = /^Persona:\s*(.+)$/i.exec(stripped);
+        return personaPrefix ? (personaPrefix[1] ?? "").trim() : stripped;
+    }
+    return "";
+}
+function extractSummary(text) {
+    const lines = text.split(/\r?\n/);
+    let i = 0;
+    // Find `## Summary` heading.
+    while (i < lines.length) {
+        if (/^##\s+summary\b/i.test(lines[i] ?? ""))
+            break;
+        i++;
+    }
+    if (i === lines.length)
+        return "";
+    i++;
+    // Skip blank lines.
+    while (i < lines.length && (lines[i] ?? "").trim() === "")
+        i++;
+    // Capture first non-empty paragraph until blank line.
+    const para = [];
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        if (line.trim() === "")
+            break;
+        if (line.startsWith("#") || line.startsWith("---"))
+            break;
+        para.push(line.trim());
+        i++;
+    }
+    return para.join(" ").trim().slice(0, 500);
+}
+function extractRelatedFeatures(text) {
+    const lines = text.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        if (/^##\s+related\s+features\b/i.test(lines[i] ?? ""))
+            break;
+        i++;
+    }
+    if (i === lines.length)
+        return [];
+    i++;
+    const out = [];
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        if (line.startsWith("#") || line.startsWith("---"))
+            break;
+        const m = /^[-*]\s+`?([a-z0-9][a-z0-9-]*)`?(?:\s|$)/i.exec(line.trim());
+        if (m && m[1])
+            out.push(m[1].toLowerCase());
+        i++;
+    }
+    return out;
+}
+function normaliseName(name) {
+    return name.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function titleCase(slug) {
+    return slug
+        .split("-")
+        .map((p) => (p.length === 0 ? p : p[0].toUpperCase() + p.slice(1)))
+        .join(" ");
+}
+//# sourceMappingURL=personas.js.map

package/dist/lib/catalogue/builders/product-edges.js

@@ -0,0 +1,106 @@
+// Product-edge builders — emit:
+//   - product_capability  (product depends on / consumes capability)
+//   - product_service     (product depends on / consumes service)
+//
+// Source: `app-platform-dependencies.yaml` at the SDD root for
+// application-product profile SDDs. Per the schema, both edges'
+// referenced columns are external FKs (capability_id and service_id
+// are owned by the platform-root SDD, not by the consuming app SDD).
+// The per-SDD builder logs `[finding] external` for each unresolved
+// reference; the aggregator validates after merge per ADR 0134 §4.3.
+//
+// Profile gating: only application-product SDDs read this file. Other
+// profiles emit zero rows (no convention defined).
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+const REL_PATH = "app-platform-dependencies.yaml";
+const DependencyEntrySchema = z.object({
+    capability_id: z.string().optional(),
+    service_id: z.string().optional(),
+    target_locus: z.string().optional(),
+    required_stability: z.string().optional(),
+    notes: z.string().optional(),
+});
+const FileSchema = z.object({
+    app_id: z.string().optional(),
+    platform_dependencies: z.array(DependencyEntrySchema).optional(),
+});
+export async function buildProductEdges(inputs) {
+    if (inputs.profile !== "application-product") {
+        return { productCapability: [], productService: [] };
+    }
+    const path = join(inputs.sddPath, REL_PATH);
+    let text;
+    try {
+        text = await readFile(path, "utf-8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+        inputs.findings.add("coverage", `${REL_PATH} not found — emitting empty product_capability + product_service`);
+        return { productCapability: [], productService: [] };
+    }
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        inputs.findings.add("convention", `${REL_PATH}: failed to parse YAML — ${err.message}`);
+        return { productCapability: [], productService: [] };
+    }
+    const parsed = FileSchema.safeParse(raw);
+    if (!parsed.success) {
+        inputs.findings.add("convention", `${REL_PATH}: shape violation — ${parsed.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; ")}`);
+        return { productCapability: [], productService: [] };
+    }
+    const productCapability = [];
+    const productService = [];
+    const seenCap = new Set();
+    const seenSvc = new Set();
+    for (const dep of parsed.data.platform_dependencies ?? []) {
+        // M-ADR 0204: an off-platform entry produces NO platform edges — its
+        // service_id slot holds an external-system id, and emitting it into
+        // product_service would recreate at this table the dangling reference the
+        // locus field exists to prevent. The dependency is fully represented in
+        // product_platform_dependencies with its locus.
+        const locusRaw = (dep.target_locus ?? "").trim().toLowerCase();
+        if (locusRaw === "external" || locusRaw === "legacy")
+            continue;
+        const capabilityId = (dep.capability_id ?? "").trim();
+        const serviceId = (dep.service_id ?? "").trim();
+        const requiredStability = (dep.required_stability ?? "").trim();
+        const notes = (dep.notes ?? "").trim();
+        if (capabilityId !== "") {
+            const id = `${inputs.productId}__${capabilityId}`;
+            if (!seenCap.has(id)) {
+                seenCap.add(id);
+                productCapability.push({
+                    id,
+                    product_id: inputs.productId,
+                    capability_id: capabilityId,
+                    role: "consumes",
+                    notes,
+                });
+                inputs.findings.add("external", `product_capability: ${id} → capability_id="${capabilityId}" (external FK; aggregator validates)`);
+            }
+        }
+        if (serviceId !== "") {
+            const id = `${inputs.productId}__${serviceId}`;
+            if (!seenSvc.has(id)) {
+                seenSvc.add(id);
+                productService.push({
+                    id,
+                    product_id: inputs.productId,
+                    service_id: serviceId,
+                    role: "consumes",
+                    required_stability: requiredStability,
+                });
+                inputs.findings.add("external", `product_service: ${id} → service_id="${serviceId}" (external FK; aggregator validates)`);
+            }
+        }
+    }
+    return { productCapability, productService };
+}
+//# sourceMappingURL=product-edges.js.map

package/dist/lib/catalogue/builders/product-platform-dependencies.js

@@ -0,0 +1,405 @@
+// product_platform_dependencies builder — emits per-SDD rows recording a
+// product's consumption of a platform-side (capability, service) pair.
+//
+// Multi-source ingestion (ADR 0157 parity principle; same shape as ADR 0156
+// events ingestion). Two equal-status authoring sources, merged by PK:
+//
+//   1. FORWARD — `app-platform-dependencies.yaml` at the SDD root, the same
+//      file `product-edges.ts` already reads for product_capability /
+//      product_service. Its `platform_dependencies:` entries carry
+//      capability_id + service_id (+ required_stability), which is exactly a
+//      (product, target-capability, target-service) triple. Forward-method
+//      consuming SDDs author this today; pre-fix the builder read it into
+//      product_capability / product_service but never into this edge.
+//
+//   2. REVERSE — `reverse-evidence/feature-grounding-evidence.yaml`'s
+//      `platform_dependencies:` block (the original schema-2.9.0 source),
+//      richer shape with domain / contract_type / contract_path / consumed_by.
+//
+//   platform_dependencies:
+//     - capability_id: <target-capability-slug>      # platform-side capability
+//       service_id: <target-service-slug>            # platform-side service
+//       domain: <domain-hint>                        # optional (reverse shape)
+//       contract_type: rest | graphql | openapi | grpc | event | other
+//       required_stability: locked | provisional | unknown
+//       contract_path: <relative-path-in-platform-sdd>  # optional (reverse)
+//       consumed_by:                                     # optional (reverse)
+//         - <service-name-within-this-product>
+//
+// Each entry emits one row keyed by `(product_id, target_capability_id,
+// target_service_id)` — or, for an ASYNC shared-stream entry with no realiser
+// service (M-ADR 0192), `(product_id, target_capability_id, contract_path)`.
+// The aggregator subsequently joins synchronous rows against platform-side
+// `capability_service` to derive `cross_sdd_platform_capability` edges (per
+// ADR 0134, federation); async rows resolve via the capability leg (no
+// realiser service to join on) and skip the F18 realiser-join.
+//
+// Cross-SDD references (target_capability_id, target_service_id) are
+// declared `external: true` in the schema — per-SDD FK validation
+// doesn't run them.
+//
+// Merge rule:
+//   - Forward (app-platform-dependencies.yaml) is read first and WINS on PK
+//     conflict (matches per-adopter authoring intent). A reverse entry whose
+//     PK was already claimed by forward emits `divergence` and is dropped.
+//   - Within a single source, a duplicate PK emits `divergence` and keeps
+//     the first.
+//   - Reverse: missing capability_id → skip, log `convention`. A synchronous
+//     entry missing service_id → skip, log `convention`. An async entry
+//     (contract_type in the M-ADR 0192 set) may omit service_id but must carry
+//     contract_path to key on, else `convention`. Forward: a synchronous entry
+//     with only the capability is a valid product_capability / product_service
+//     row but cannot form this edge — skipped silently; an async entry missing
+//     its contract_path logs `convention`.
+//
+// Schema 2.36.0: target_service_id is conditionally nullable — empty for async
+// shared-stream rows, which key on contract_path (M-ADR 0192).
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+const FORWARD_REL_PATH = "app-platform-dependencies.yaml";
+/**
+ * Contract types that denote an ASYNC shared-stream dependency (M-ADR 0192).
+ * A dependency of one of these kinds binds to a stream contract published by a
+ * capability, not to a synchronous realiser service — so it characteristically
+ * has no `service_id`, and the F18 realiser-join does not apply to it at
+ * aggregation. Kept lowercase; callers normalise before testing.
+ */
+export const ASYNC_CONTRACT_TYPES = new Set([
+    "event",
+    "event-stream",
+    "stream",
+]);
+/** True when `contractType` denotes an async shared-stream dependency (M-ADR 0192). */
+export function isAsyncContractType(contractType) {
+    return ASYNC_CONTRACT_TYPES.has(contractType.trim().toLowerCase());
+}
+// M-ADR 0204: closed three-value enum. `platform` (or absent) keeps every
+// pre-0204 behaviour; external/legacy rows target something OFF-platform, carry
+// empty FK columns, and name their target in target_external_system_id instead.
+export const TARGET_LOCUS_VALUES = new Set([
+    "platform",
+    "external",
+    "legacy",
+]);
+/**
+ * Resolve an entry's target_locus. Invalid values are reported and treated as
+ * `platform` — the SAFEST reading, because a platform row is fully validated
+ * (FKs, resolution, realiser join); treating an unknown locus as off-platform
+ * would silently exempt the row from every check, which is the failure mode
+ * this whole field exists to end.
+ */
+export function resolveTargetLocus(raw, findings, where) {
+    const v = String(raw ?? "").trim().toLowerCase();
+    if (v === "")
+        return "platform";
+    if (TARGET_LOCUS_VALUES.has(v))
+        return v;
+    findings.add("convention", `${where}: invalid target_locus "${v}" (allowed: platform | external | legacy) — treated as platform, so the row stays fully validated`);
+    return "platform";
+}
+/**
+ * Emit an off-platform (M-ADR 0204 external|legacy) row. FK columns stay
+ * EMPTY — the target is not the platform, so nothing may join or FK-validate
+ * against it; the target's identity goes to target_external_system_id (the
+ * authored service_id slot, routed). A capability_id present on such an entry
+ * is reported and dropped rather than carried: §4.3, and the measured instance
+ * where that slot held the product's own feature slug is why.
+ * Returns the row id, or null (with a finding) when the entry binds to nothing.
+ */
+function buildOffPlatformRow(inputs, locus, dep, where) {
+    const capabilityId = String(dep["capability_id"] ?? "").trim();
+    const externalId = String(dep["service_id"] ?? "").trim();
+    const contractPath = optString(dep["contract_path"]);
+    if (capabilityId !== "") {
+        inputs.findings.add("convention", `${where}: target_locus="${locus}" entry carries capability_id="${capabilityId}" — an off-platform target has no platform capability (M-ADR 0204 §4.3); dropped from the row, keep the intent in notes`);
+    }
+    const keyLeg = externalId !== "" ? externalId : contractPath;
+    if (keyLeg === "") {
+        inputs.findings.add("convention", `${where}: target_locus="${locus}" entry names neither an external-system id (service_id) nor a contract_path — it binds to nothing and cannot be recorded`);
+        return null;
+    }
+    const consumedBy = dep["consumed_by"];
+    const consumedByJoined = Array.isArray(consumedBy)
+        ? consumedBy.map((v) => String(v).trim()).filter((v) => v !== "").join(",")
+        : typeof consumedBy === "string"
+            ? consumedBy.trim()
+            : "";
+    return {
+        id: `${inputs.productId}__${locus}__${keyLeg}`,
+        product_id: inputs.productId,
+        target_capability_id: "",
+        target_locus: locus,
+        target_external_system_id: externalId,
+        target_service_id: "",
+        target_domain: optString(dep["domain"]),
+        contract_type: optString(dep["contract_type"]),
+        required_stability: optString(dep["required_stability"]),
+        contract_path: contractPath,
+        consumed_by_services: consumedByJoined,
+        source_sdd_id: "",
+    };
+}
+function resolveKeyLeg(serviceId, contractType, contractPath) {
+    if (serviceId !== "")
+        return { ok: true, keyLeg: serviceId };
+    if (!isAsyncContractType(contractType)) {
+        return { ok: false, reason: "sync-single-sided" };
+    }
+    if (contractPath === "")
+        return { ok: false, reason: "async-no-contract-path" };
+    return { ok: true, keyLeg: contractPath };
+}
+export async function buildProductPlatformDependencies(inputs) {
+    const rows = [];
+    // Tracks which source claimed each PK, so divergence messages are accurate.
+    const seen = new Map();
+    if (inputs.productId === "") {
+        // No product id means no rows can be emitted — product_platform_dependencies
+        // is product-scoped. Return empty silently (the orchestrator decides
+        // whether to log this as a finding).
+        return rows;
+    }
+    // 1. FORWARD source — app-platform-dependencies.yaml at SDD root.
+    await readForwardSource(inputs, rows, seen);
+    // 2. REVERSE source — reverse-evidence/feature-grounding-evidence.yaml.
+    const evidenceFiles = await collectEvidenceFiles(inputs.sddPath);
+    for (const file of evidenceFiles) {
+        const relPath = relative(inputs.sddPath, file);
+        let text;
+        try {
+            text = await readFile(file, "utf-8");
+        }
+        catch {
+            inputs.findings.add("convention", `${relPath}: cannot read evidence file`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = parseYaml(text);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            inputs.findings.add("convention", `${relPath}: invalid YAML — ${msg}`);
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object")
+            continue;
+        const deps = parsed["platform_dependencies"];
+        if (!Array.isArray(deps))
+            continue;
+        for (const d of deps) {
+            if (!d || typeof d !== "object")
+                continue;
+            const dep = d;
+            const locus = resolveTargetLocus(dep["target_locus"], inputs.findings, relPath);
+            if (locus !== "platform") {
+                const offRow = buildOffPlatformRow(inputs, locus, dep, relPath);
+                if (offRow !== null) {
+                    const claimed = seen.get(String(offRow.id));
+                    if (claimed !== undefined) {
+                        inputs.findings.add("divergence", `${relPath}: duplicate platform_dependencies row id="${offRow.id}"`);
+                    }
+                    else {
+                        seen.set(String(offRow.id), "reverse");
+                        rows.push(offRow);
+                    }
+                }
+                continue;
+            }
+            const capabilityId = String(dep["capability_id"] ?? "").trim();
+            const serviceId = String(dep["service_id"] ?? "").trim();
+            const contractType = optString(dep["contract_type"]);
+            const contractPath = optString(dep["contract_path"]);
+            if (capabilityId === "") {
+                inputs.findings.add("convention", `${relPath}: platform_dependencies entry missing required capability_id (service_id="${serviceId}")`);
+                continue;
+            }
+            // M-ADR 0192: an async shared-stream entry legitimately has no service_id
+            // (no single realiser) and keys on its stream contract_path instead.
+            const keyRes = resolveKeyLeg(serviceId, contractType, contractPath);
+            if (!keyRes.ok) {
+                inputs.findings.add("convention", keyRes.reason === "async-no-contract-path"
+                    ? `${relPath}: async platform_dependencies entry for capability "${capabilityId}" (contract_type="${contractType}") has neither service_id nor contract_path — cannot key the stream dependency`
+                    : `${relPath}: platform_dependencies entry for capability "${capabilityId}" missing required service_id (a synchronous dependency must name its realiser service)`);
+                continue;
+            }
+            const rowId = `${inputs.productId}__${capabilityId}__${keyRes.keyLeg}`;
+            const claimedBy = seen.get(rowId);
+            if (claimedBy === "forward") {
+                inputs.findings.add("divergence", `${relPath}: platform_dependencies id="${rowId}" also declared forward in ${FORWARD_REL_PATH} — forward wins; reverse entry dropped`);
+                continue;
+            }
+            if (claimedBy === "reverse") {
+                inputs.findings.add("divergence", `${relPath}: duplicate platform_dependencies row id="${rowId}" — same (product_id, target_capability_id, target_service_id) already emitted`);
+                continue;
+            }
+            seen.set(rowId, "reverse");
+            const consumedBy = dep["consumed_by"];
+            const consumedByJoined = Array.isArray(consumedBy)
+                ? consumedBy
+                    .map((v) => String(v).trim())
+                    .filter((v) => v !== "")
+                    .join(",")
+                : typeof consumedBy === "string"
+                    ? consumedBy.trim()
+                    : "";
+            rows.push({
+                id: rowId,
+                product_id: inputs.productId,
+                target_capability_id: capabilityId,
+                target_locus: "platform",
+                target_external_system_id: "",
+                target_service_id: serviceId,
+                target_domain: optString(dep["domain"]),
+                contract_type: contractType,
+                required_stability: optString(dep["required_stability"]),
+                contract_path: contractPath,
+                consumed_by_services: consumedByJoined,
+                source_sdd_id: "",
+            });
+        }
+    }
+    return rows;
+}
+/**
+ * Forward source: `app-platform-dependencies.yaml` at the SDD root. Reads its
+ * `platform_dependencies:` block — the same block product-edges.ts consumes
+ * for product_capability / product_service. Only entries carrying BOTH
+ * capability_id and service_id can form this edge; entries with just one are
+ * valid product_capability / product_service rows and are skipped silently
+ * here. File presence (not profile) is the gate — the file only exists in
+ * consuming SDDs.
+ */
+async function readForwardSource(inputs, rows, seen) {
+    const path = join(inputs.sddPath, FORWARD_REL_PATH);
+    let text;
+    try {
+        text = await readFile(path, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        inputs.findings.add("convention", `${FORWARD_REL_PATH}: cannot read file`);
+        return;
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(text);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        inputs.findings.add("convention", `${FORWARD_REL_PATH}: invalid YAML — ${msg}`);
+        return;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return;
+    const deps = parsed["platform_dependencies"];
+    if (!Array.isArray(deps))
+        return;
+    for (const d of deps) {
+        if (!d || typeof d !== "object")
+            continue;
+        const dep = d;
+        const locus = resolveTargetLocus(dep["target_locus"], inputs.findings, FORWARD_REL_PATH);
+        if (locus !== "platform") {
+            const offRow = buildOffPlatformRow(inputs, locus, dep, FORWARD_REL_PATH);
+            if (offRow !== null) {
+                if (seen.has(String(offRow.id))) {
+                    inputs.findings.add("divergence", `${FORWARD_REL_PATH}: duplicate platform_dependencies row id="${offRow.id}"`);
+                }
+                else {
+                    seen.set(String(offRow.id), "forward");
+                    rows.push(offRow);
+                }
+            }
+            continue;
+        }
+        const capabilityId = String(dep["capability_id"] ?? "").trim();
+        const serviceId = String(dep["service_id"] ?? "").trim();
+        const contractType = optString(dep["contract_type"]);
+        const contractPath = optString(dep["contract_path"]);
+        // Entry needs a capability plus a key leg to form this edge. A synchronous
+        // entry keys on service_id; a single-sided synchronous entry is a valid
+        // product_capability / product_service row (emitted by product-edges.ts)
+        // and is skipped silently here. An async shared-stream entry (M-ADR 0192)
+        // keys on its stream contract_path instead of a realiser service.
+        if (capabilityId === "")
+            continue;
+        const keyRes = resolveKeyLeg(serviceId, contractType, contractPath);
+        if (!keyRes.ok) {
+            if (keyRes.reason === "async-no-contract-path") {
+                inputs.findings.add("convention", `${FORWARD_REL_PATH}: async platform_dependencies entry for capability "${capabilityId}" (contract_type="${contractType}") has neither service_id nor contract_path — cannot key the stream dependency`);
+            }
+            // sync-single-sided → skip silently (legitimate product_capability /
+            // product_service row, not an error).
+            continue;
+        }
+        const rowId = `${inputs.productId}__${capabilityId}__${keyRes.keyLeg}`;
+        if (seen.has(rowId)) {
+            inputs.findings.add("divergence", `${FORWARD_REL_PATH}: duplicate platform_dependencies row id="${rowId}" — same (product_id, target_capability_id, target_service_id/contract_path) already emitted`);
+            continue;
+        }
+        seen.set(rowId, "forward");
+        rows.push({
+            id: rowId,
+            product_id: inputs.productId,
+            target_capability_id: capabilityId,
+            target_locus: "platform",
+            target_external_system_id: "",
+            target_service_id: serviceId,
+            target_domain: optString(dep["domain"]),
+            contract_type: contractType,
+            required_stability: optString(dep["required_stability"]),
+            contract_path: contractPath,
+            consumed_by_services: "",
+            source_sdd_id: "",
+        });
+    }
+}
+function optString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+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()) {
+            if (e.name === "reverse-evidence") {
+                const candidate = join(abs, "feature-grounding-evidence.yaml");
+                try {
+                    const s = await stat(candidate);
+                    if (s.isFile())
+                        out.push(candidate);
+                }
+                catch {
+                    // No file in this reverse-evidence dir — skip silently.
+                }
+                continue;
+            }
+            const rel = relative(root, abs);
+            if (rel.split(sep).length > 8)
+                continue;
+            await walk(root, abs, out);
+        }
+    }
+}
+//# sourceMappingURL=product-platform-dependencies.js.map